Dreams

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

Dreams ermöglichen es Claude, das aufzuräumen. Ein Dream liest einen bestehenden Memory Store zusammen mit vergangenen Session-Transkripten und erzeugt daraus einen neuen, reorganisierten Memory Store: Duplikate werden zusammengeführt, veraltete oder widersprüchliche Einträge durch den aktuellsten Wert ersetzt und neue Erkenntnisse herausgearbeitet.

Der Input-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: den 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 Output-Memory-Store, getrennt vom Input. Die ID des Output-Stores erscheint in den outputs[] des Dreams kurz nachdem der Dream den Status running erreicht hat, sobald der Workflow den Input-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-Inputs 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-opus-5, claude-fable-5, claude-opus-4-8, claude-opus-4-7, claude-sonnet-5 und claude-sonnet-4-6 unterstützt. Optional kannst du 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 Output-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 Inputs, kein Editor, der auf den Text des Stores angewendet wird. Imperative Anweisungen, die auf bestimmte Zeilen abzielen („ändere Satz X zu Y", „korrigiere die Anzahl in Abschnitt Z"), bewirken daher in der Regel keine Änderung. Um gezielte Änderungen an einzelnen Memories vorzunehmen, verwende die Memory Stores API direkt auf dem Output-Store.



Fortschritt verfolgen

Dreams laufen asynchron und dauern typischerweise Minuten bis einige Stunden, abhängig von der Anzahl der Input-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



Die Pipeline beim Laufen beobachten

Sobald ein Dream den Status running hat, 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 handelt sich um einen gewöhnlichen Memory Store in deinem Workspace. Überprüfe ihn mit der Memory Stores API oder in der Console, dann entweder:

• Nutze ihn: hänge ihn als memory_store-Ressource an zukünftige Sessions an, anstelle des (oder zusätzlich zum) Input-Memory-Stores, 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 Inputs niemals. Bei failed oder canceled bleibt der Output-Store mit teilweisen Inhalten bestehen, sodass du überprüfen 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 mit Status pending oder running sofort in den Status canceled. Das Abbrechen eines bereits auf canceled gesetzten Dreams ist eine idempotente No-Op; das Abbrechen eines Dreams mit 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-List-Antworten ausgeschlossen, bleiben aber per ID lesbar. Das Archivieren eines bereits archivierten Dreams ist eine idempotente No-Op. Das Archivieren eines Dreams mit 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 Output-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, Maximum 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 vollständige Liste möglicher Dreaming-Fehler.



Abrechnung

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



Limits

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