Dreams

Agenten schreiben während ihrer Arbeit in ihre Memory Stores, aber diese Schreibvorgänge sind lokal und inkrementell: Über viele Sessions hinweg sammelt ein Memory Store Duplikate, Widersprüche und veraltete Einträge an.

Dreams lassen Claude das aufräumen. Ein Dream liest einen bestehenden Memory Store zusammen mit Transkripten vergangener Sessions und erzeugt dann einen neuen, reorganisierten Memory Store: Duplikate werden zusammengeführt, veraltete oder widersprüchliche Einträge durch den neuesten Wert ersetzt und neue Erkenntnisse zutage gefördert.

Der Eingabe-Store wird niemals verändert, sodass du die Ausgabe überprüfen und verwerfen kannst, wenn dir das Ergebnis nicht gefällt.



So funktioniert es

Ein Dream ist ein asynchroner Job, der Folgendes entgegennimmt:

• einen bereits bestehenden Memory Store: der Store, den Claude verifiziert, dedupliziert und reorganisiert, und
• 1 bis 100 Sessions: vergangene Transkripte, die Claude nach Mustern und Erkenntnissen durchsucht, um sie in die Ausgabe einfließen zu lassen.

Der Dream erzeugt einen weiteren Ausgabe-Memory-Store, getrennt von der Eingabe. Die ID des Ausgabe-Stores erscheint kurz nach dem Start des Dreams in dessen outputs[], sobald der Dream running ist und der Workflow den Eingabe-Store geklont hat; ein Dream im Status running kann kurzzeitig ein leeres outputs[] melden.



Einen Dream erstellen

dream = client.beta.dreams.create(
    inputs=[
        {"type": "memory_store", "memory_store_id": store_id},
        {"type": "sessions", "session_ids": [session_a, session_b]},
    ],
    model="claude-opus-4-8",
    instructions="Focus on coding-style preferences; ignore one-off debugging notes.",
)
print(dream.id)  # drm_01...

Die Dreaming-Eingaben umfassen den bereits bestehenden Memory Store und ein Array von Sessions. Das ausgewählte Modell führt die Dreaming-Pipeline aus; während der Research Preview werden claude-fable-5, claude-opus-4-8, claude-opus-4-7, claude-sonnet-5 und claude-sonnet-4-6 unterstützt. Du kannst optional instructions übergeben, um den Dreaming-Prozess zu steuern; siehe Mit Instructions steuern.

Die Antwort ist die vollständige dream-Ressource mit status: "pending":

{
  "type": "dream",
  "id": "drm_01AbCDefGhIjKlMnOpQrStUv",
  "status": "pending",
  "inputs": [
    { "type": "memory_store", "memory_store_id": "memstore_01Hx..." },
    { "type": "sessions", "session_ids": ["sesn_01...", "sesn_02..."] }
  ],
  "outputs": [],
  "model": { "id": "claude-opus-4-8" },
  "instructions": "Focus on coding-style preferences; ignore one-off debugging notes.",
  "session_id": null,
  "created_at": "2026-04-29T17:04:10Z",
  "ended_at": null,
  "archived_at": null,
  "usage": {
    "input_tokens": 0,
    "output_tokens": 0,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0
  },
  "error": null
}



Mit Instructions steuern

Das optionale Feld instructions steuert, was die Dreaming-Pipeline synthetisiert. Es wird in der gesamten Pipeline angewendet: was genau gelesen werden soll, was zusammengeführt oder verworfen werden soll und wie der Ausgabe-Store strukturiert werden soll.

Verwende instructions für übergeordnete Synthese-Anleitungen wie Schwerpunktbereiche („konzentriere dich auf Coding-Style-Präferenzen"), Inhalte, die unverändert erhalten bleiben sollen, oder Ausgabekonventionen, die du im gesamten Store angewendet haben möchtest. Die Pipeline ist ein Synthese-Durchlauf über die Eingaben, kein Editor, der auf den Text des Stores angewendet wird. Daher bewirken imperative Anweisungen, die auf bestimmte Zeilen abzielen („ändere Satz X zu Y", „korrigiere die Anzahl in Abschnitt Z"), in der Regel keine Änderung. Um gezielte Bearbeitungen an einzelnen Memories vorzunehmen, verwende die Memory Stores API direkt auf dem Ausgabe-Store.



Fortschritt verfolgen

Dreams laufen asynchron und dauern typischerweise Minuten bis einige Stunden, abhängig von der Anzahl der Eingabe-Transkripte. Frage den Dream per ID ab, um den Status zu prüfen:

while dream.status in ("pending", "running"):
    time.sleep(10)
    dream = client.beta.dreams.retrieve(dream.id)
    print(f"status={dream.status} input_tokens={dream.usage.input_tokens}")



Lebenszyklus



Den Pipeline-Lauf beobachten

Sobald ein Dream running ist, verweist sein Feld session_id auf die zugrunde liegende Session, die die Pipeline ausführt. Du kannst die Events dieser Session streamen, um in Echtzeit zu beobachten, was der Dream liest und schreibt. Die Session wird archiviert (nicht gelöscht), wenn der Dream einen Endzustand erreicht, sodass das Transkript danach weiterhin verfügbar bleibt.



Die Ausgabe verwenden

Wenn status den Wert completed erreicht, verweist der memory_store-Eintrag in outputs[] auf einen vollständig befüllten Store. Es ist ein gewöhnlicher Memory Store in deinem Workspace. Überprüfe ihn mit der Memory Stores API oder in der Console und dann entweder:

• Nutze ihn: hänge ihn an zukünftige Sessions als memory_store-Ressource anstelle des (oder zusätzlich zum) Eingabe-Memory-Store an, oder
• Verwirf ihn: lösche den Memory Store oder archiviere den Memory Store.

# Nach Ende des Dreams enthält die Ausgabe den neu aufgebauten Memory-Store
output_store_id = next(
    output.memory_store_id for output in dream.outputs if output.type == "memory_store"
)

session = client.beta.sessions.create(
    agent=agent_id,
    environment_id=environment_id,
    resources=[
        {"type": "memory_store", "memory_store_id": output_store_id},
    ],
)

Der Dream selbst löscht oder verändert seine Eingaben niemals. Bei failed oder canceled bleibt der Ausgabe-Store mit Teilinhalten bestehen, sodass du inspizieren kannst, was vor dem Stopp erzeugt wurde; räume ihn über die Memory Stores API auf, wenn du ihn nicht benötigst.



Einen Dream abbrechen

Cancel versetzt einen Dream im Status pending oder running sofort in den Status canceled. Das Abbrechen eines bereits abgebrochenen (canceled) Dreams ist eine idempotente No-Op; das Abbrechen eines Dreams im Status completed oder failed gibt 400 zurück.

client.beta.dreams.cancel(dream.id)



Einen Dream archivieren

Archive setzt archived_at auf einem Dream, der einen Endzustand erreicht hat (completed, failed oder canceled); status bleibt unverändert. Archivierte Dreams werden aus den Standard-Listenantworten ausgeschlossen, bleiben aber per ID lesbar. Das Archivieren eines bereits archivierten Dreams ist eine idempotente No-Op. Das Archivieren eines Dreams im Status pending oder running gibt 400 zurück; brich ihn zuerst ab. Es gibt kein Unarchive.

client.beta.dreams.archive(dream.id)

Das Archivieren eines Dreams berührt seinen Ausgabe-Memory-Store nicht; verwalte diesen separat über die Memory Stores API.



Dreams auflisten

Gibt alle nicht archivierten Dreams im Workspace zurück, neueste zuerst. Verwende limit (Standard 20, max. 100) und den page-Cursor zum Paginieren. Übergib include_archived=true, um archivierte Dreams einzuschließen.

for listed_dream in client.beta.dreams.list(limit=20):
    print(listed_dream.id, listed_dream.status)



Fehler

Es folgt eine nicht erschöpfende Liste möglicher Dreaming-Fehler.



Abrechnung

Dreams werden zu den Standard-API-Token-Tarifen für das von dir ausgewählte Modell abgerechnet; usage auf der Ressource meldet die genauen Summen. Die Kosten skalieren ungefähr linear mit der Anzahl und Länge der Eingabe-Sessions. Beginne mit einer kleinen Menge an Sessions und skaliere hoch, sobald du mit der Kuratierungsqualität zufrieden bist.



Limits

Für die Dream-Erstellung gelten die Standard-Ratenlimits, solange sich dieses Feature in der Research Preview befindet. Kontaktiere den Support, wenn du höhere Limits benötigst.