---
title: Dreams
url: https://platform.claude.com/docs/de/managed-agents/dreams
description: Lass Claude über vergangene Sitzungen reflektieren, um das Gedächtnis eines Agenten zu kuratieren und neue Erkenntnisse zutage zu fördern.
---

<Tip>
  Dreaming ist eine Funktion in der Research Preview. [Fordere Zugriff an](https://claude.com/form/claude-managed-agents), um sie auszuprobieren.
</Tip>

Agenten schreiben während ihrer Arbeit in ihre [„memory stores“ (Gedächtnisspeicher)](https://platform.claude.com/docs/de/managed-agents/memory), aber diese Schreibvorgänge sind lokal und inkrementell: Über viele Sitzungen hinweg sammelt ein Memory Store Duplikate, Widersprüche und veraltete Einträge an.

**„Dreams“** (Träume) lassen Claude das aufräumen. Ein Dream liest einen bestehenden Memory Store zusammen mit Transkripten vergangener Sitzungen und erzeugt dann einen neuen, reorganisierten Memory Store: Duplikate werden zusammengeführt, veraltete oder widersprochene Einträge durch den neuesten Wert ersetzt und neue Erkenntnisse zutage gefördert.

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

<Note>
  Dream-Endpunkte sind durch den Beta-Header `dreaming-2026-04-21` geschützt; der Header `managed-agents-2026-04-01` allein gewährt keinen Zugriff auf Dreams. Die Beispiele für Dream-Endpunkte auf dieser Seite senden beide Header; Aufrufe für Sitzungen und Memory Stores benötigen nur `managed-agents-2026-04-01`. Das SDK setzt diese automatisch.
</Note>

## So funktioniert es

Ein **Dream** ist ein asynchroner Job, der Folgendes entgegennimmt:

* einen bereits bestehenden **Memory Store:** den Store, den Claude überprüft, dedupliziert und reorganisiert, und
* 1 bis 100 **Sitzungen:** 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 im Array `outputs` (csharp, go: `Outputs`) des Dreams kurz nachdem der Dream in den Status `running` übergeht, sobald der Workflow den Eingabe-Store geklont hat; ein Dream im Status `running` kann kurzzeitig ein leeres Array `outputs` (csharp, go: `Outputs`) melden.

## Einen Dream erstellen

<CodeGroup>
  ```bash cURL
  curl -s https://api.anthropic.com/v1/dreams \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21" \
    -H "content-type: application/json" \
    --data '{
      "inputs": [
        { "type": "memory_store", "memory_store_id": "'"$store_id"'" },
        { "type": "sessions", "session_ids": ["'"$session_a"'", "'"$session_b"'"] }
      ],
      "model": "claude-opus-5-5",
      "instructions": "Focus on coding-style preferences; ignore one-off debugging notes."
    }'
  ```

  ```bash CLI
  ant beta:dreams create <<YAML
  inputs:
    - type: memory_store
      memory_store_id: $store_id
    - type: sessions
      session_ids: [$session_a, $session_b]
  model: claude-opus-5-5
  instructions: Focus on coding-style preferences; ignore one-off debugging notes.
  YAML
  ```

  ```python Python
  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-5-5",
      instructions="Focus on coding-style preferences; ignore one-off debugging notes.",
  )
  print(dream.id)  # drm_01...
  ```

  ```typescript TypeScript
  let dream = await client.beta.dreams.create({
    inputs: [
      { type: "memory_store", memory_store_id: storeId },
      { type: "sessions", session_ids: [sessionA, sessionB] }
    ],
    model: "claude-opus-5-5",
    instructions: "Focus on coding-style preferences; ignore one-off debugging notes."
  });
  console.log(dream.id); // drm_01...
  ```

  ```csharp C#
  var dream = await client.Beta.Dreams.Create(new()
  {
      Inputs =
      [
          new BetaDreamMemoryStoreInput
          {
              Type = BetaDreamMemoryStoreInputType.MemoryStore,
              MemoryStoreID = storeID,
          },
          new BetaDreamSessionsInput
          {
              Type = BetaDreamSessionsInputType.Sessions,
              SessionIds = [sessionA, sessionB],
          },
      ],
      Model = "claude-opus-5-5",
      Instructions = "Focus on coding-style preferences; ignore one-off debugging notes.",
  });
  Console.WriteLine(dream.ID);  // drm_01...
  ```

  ```go Go
  dream, err := client.Beta.Dreams.New(ctx, anthropic.BetaDreamNewParams{
  	Inputs: []anthropic.BetaDreamInputUnionParam{
  		anthropic.BetaDreamInputParamOfMemoryStore(storeID),
  		anthropic.BetaDreamInputParamOfSessions([]string{sessionA, sessionB}),
  	},
  	Model: anthropic.BetaDreamNewParamsModelUnion{
  		OfString: anthropic.String("claude-opus-5-5"),
  	},
  	Instructions: anthropic.String("Focus on coding-style preferences; ignore one-off debugging notes."),
  })
  if err != nil {
  	panic(err)
  }
  fmt.Println(dream.ID) // drm_01...
  ```

  ```java Java
  var dream = client.beta().dreams().create(
      DreamCreateParams.builder()
          .addMemoryStoreInput(storeId)
          .addSessionsInput(List.of(sessionA, sessionB))
          .model("claude-opus-5-5")
          .instructions("Focus on coding-style preferences; ignore one-off debugging notes.")
          .build()
  );
  IO.println(dream.id());  // drm_01...
  ```

  ```php PHP
  $dream = $client->beta->dreams->create(
      inputs: [
          ['type' => 'memory_store', 'memory_store_id' => $storeId],
          ['type' => 'sessions', 'session_ids' => [$sessionA, $sessionB]],
      ],
      model: 'claude-opus-5-5',
      instructions: 'Focus on coding-style preferences; ignore one-off debugging notes.',
  );
  echo "{$dream->id}\n"; // drm_01...
  ```

  ```ruby Ruby
  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-5-5",
    instructions: "Focus on coding-style preferences; ignore one-off debugging notes."
  )
  puts dream.id # drm_01...
  ```
</CodeGroup>

Die Eingaben für Dreaming umfassen den bereits bestehenden Memory Store und ein Array von Sitzungen. Das ausgewählte Modell führt die Dreaming-Pipeline aus. Während der Research Preview werden `claude-opus-5-5`, `claude-fable-5-1`, `claude-opus-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-5-5`, `claude-sonnet-5` und `claude-sonnet-4-6` unterstützt. Optional kannst du `instructions` (csharp, go: `Instructions`) übergeben, um den Dreaming-Prozess zu steuern. Siehe [Mit Anweisungen steuern](https://platform.claude.com/docs/de/managed-agents/dreams#steer-with-instructions).

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

```json
{
  "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-5-5" },
  "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
}
```

<Tip>
  Wenn du nur Sitzungstranskripte und keinen bestehenden Store hast, [erstelle zuerst einen leeren Memory Store](https://platform.claude.com/docs/de/managed-agents/memory#create-a-memory-store) und übergib ihn als `memory_store`-Eingabe.
</Tip>

### Mit Anweisungen steuern

Das optionale Feld `instructions` (csharp, go: `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` (csharp, go: `Instructions`) für übergeordnete Syntheseanleitungen wie Schwerpunktbereiche („konzentriere dich auf Präferenzen zum Coding-Stil“), Inhalte, die unverändert erhalten bleiben sollen, oder Ausgabekonventionen, die im gesamten Store angewendet werden sollen. Die Pipeline ist ein Syntheseschritt ü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 Änderungen an einzelnen Erinnerungen vorzunehmen, verwende die [Memory Stores API](https://platform.claude.com/docs/de/managed-agents/memory#view-and-edit-memories) direkt auf dem Ausgabe-Store.

## Fortschritt verfolgen

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

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/dreams/$dream_id" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams retrieve --dream-id "$dream_id"
  ```

  ```python Python
  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}")
  ```

  ```typescript TypeScript
  while (dream.status === "pending" || dream.status === "running") {
    await sleep(10_000);
    dream = await client.beta.dreams.retrieve(dream.id);
    console.log(`status=${dream.status} input_tokens=${dream.usage.input_tokens}`);
  }
  ```

  ```csharp C#
  while (dream.Status.Value() is BetaDreamStatus.Pending or BetaDreamStatus.Running)
  {
      await Task.Delay(TimeSpan.FromSeconds(10));
      dream = await client.Beta.Dreams.Retrieve(dream.ID);
      Console.WriteLine($"status={dream.Status.Raw()} input_tokens={dream.Usage.InputTokens}");
  }
  ```

  ```go Go
  for dream.Status == anthropic.BetaDreamStatusPending || dream.Status == anthropic.BetaDreamStatusRunning {
  	time.Sleep(10 * time.Second)
  	dream, err = client.Beta.Dreams.Get(ctx, dream.ID, anthropic.BetaDreamGetParams{})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("status=%s input_tokens=%d\n", dream.Status, dream.Usage.InputTokens)
  }
  ```

  ```java Java
  while (dream.status().equals(BetaDreamStatus.PENDING)
          || dream.status().equals(BetaDreamStatus.RUNNING)) {
      Thread.sleep(10_000);
      dream = client.beta().dreams().retrieve(dream.id());
      IO.println("status=" + dream.status() + " input_tokens=" + dream.usage().inputTokens());
  }
  ```

  ```php PHP
  while (in_array($dream->status, [BetaDreamStatus::PENDING->value, BetaDreamStatus::RUNNING->value], true)) {
      sleep(10);
      $dream = $client->beta->dreams->retrieve($dream->id);
      echo "status={$dream->status} input_tokens={$dream->usage->inputTokens}\n";
  }
  ```

  ```ruby Ruby
  while %i[pending running].include?(dream.status)
    sleep 10
    dream = client.beta.dreams.retrieve(dream.id)
    puts "status=#{dream.status} input_tokens=#{dream.usage.input_tokens}"
  end
  ```
</CodeGroup>

### Lebenszyklus

| `status` (csharp, go: `Status`) | Bedeutung                                                                                                                             |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `pending`                       | Dream erfolgreich erstellt und in die Warteschlange eingereiht.                                                                       |
| `running`                       | Die Pipeline verarbeitet. `usage` (csharp, go: `Usage`) wird mit fortschreitender Arbeit aktualisiert.                                |
| `completed`                     | Erfolgreich abgeschlossen. Der Wert `outputs` (csharp, go: `Outputs`) ist der neue Memory Store.                                      |
| `failed`                        | Der Dreaming-Lauf endete mit einem Fehler. Der Ausgabe-Memory-Store bleibt unverändert mit dem, was vor dem Fehler geschrieben wurde. |
| `canceled`                      | Der Dreaming-Lauf wurde abgebrochen. Der Ausgabe-Memory-Store bleibt unverändert.                                                     |

### Den Pipeline-Lauf beobachten

Sobald ein Dream im Status `running` ist, verweist sein Feld `session_id` (java: `sessionId`; php: `sessionID`; csharp, go: `SessionID`) auf die zugrunde liegende [Sitzung](https://platform.claude.com/docs/de/managed-agents/sessions), die die Pipeline ausführt. Du kannst die [Events](https://platform.claude.com/docs/de/managed-agents/events-and-streaming) dieser Sitzung streamen, um in Echtzeit zu beobachten, was der Dream liest und schreibt. Die Sitzung wird archiviert (nicht gelöscht), wenn der Dream einen Endzustand erreicht, sodass das Transkript danach weiterhin verfügbar bleibt.

## Die Ausgabe verwenden

Wenn `status` (csharp, go: `Status`) den Wert `completed` erreicht, verweist der `memory_store`-Eintrag in `outputs` (csharp, go: `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](https://platform.claude.com/docs/de/managed-agents/memory#view-and-edit-memories) oder in der Console und dann entweder:

* **Nutze ihn:** Hänge ihn an zukünftige Sitzungen als `memory_store`-Ressource anstelle des (oder zusätzlich zum) Eingabe-Memory-Stores an, oder
* **Verwirf ihn:** [Lösche den Memory Store](https://platform.claude.com/docs/de/api/beta/memory_stores/delete) oder [archiviere den Memory Store](https://platform.claude.com/docs/de/api/beta/memory_stores/archive).

<CodeGroup>
  ```bash cURL
  # $output_store_id is the memory_store_id of the completed dream's memory_store output
  curl -s https://api.anthropic.com/v1/sessions \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01" \
    -H "content-type: application/json" \
    --data '{
      "agent": "'"$agent_id"'",
      "environment_id": "'"$environment_id"'",
      "resources": [
        { "type": "memory_store", "memory_store_id": "'"$output_store_id"'" }
      ]
    }'
  ```

  ```bash CLI
  # $output_store_id is the memory_store_id of the completed dream's memory_store output
  ant beta:sessions create <<YAML
  agent: $agent_id
  environment_id: $environment_id
  resources:
    - type: memory_store
      memory_store_id: $output_store_id
  YAML
  ```

  ```python Python
  # 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},
      ],
  )
  ```

  ```typescript TypeScript
  // Nach Ende des Dreams enthält die Ausgabe den neu aufgebauten Memory-Store
  const output = dream.outputs.find((entry) => entry.type === "memory_store");
  const outputStoreId = output!.memory_store_id;

  await client.beta.sessions.create({
    agent: agentId,
    environment_id: environmentId,
    resources: [{ type: "memory_store", memory_store_id: outputStoreId }]
  });
  ```

  ```csharp C#
  var output = dream.Outputs.FirstOrDefault(entry => entry.Type == "memory_store");
  if (output is { MemoryStoreID: var outputStoreID })
  {
      await client.Beta.Sessions.Create(new()
      {
          Agent = agentID,
          EnvironmentID = environmentID,
          Resources =
          [
              new BetaManagedAgentsMemoryStoreResourceParam
              {
                  Type = BetaManagedAgentsMemoryStoreResourceParamType.MemoryStore,
                  MemoryStoreID = outputStoreID,
              },
          ],
      });
  }
  ```

  ```go Go
  for _, output := range dream.Outputs {
  	if output.Type != "memory_store" {
  		continue
  	}
  	outputStoreID := output.MemoryStoreID

  	session, err := client.Beta.Sessions.New(ctx, anthropic.BetaSessionNewParams{
  		Agent: anthropic.BetaSessionNewParamsAgentUnion{
  			OfString: anthropic.String(agentID),
  		},
  		EnvironmentID: environmentID,
  		Resources: []anthropic.BetaSessionNewParamsResourceUnion{{
  			OfMemoryStore: &anthropic.BetaManagedAgentsMemoryStoreResourceParam{
  				Type:          anthropic.BetaManagedAgentsMemoryStoreResourceParamTypeMemoryStore,
  				MemoryStoreID: outputStoreID,
  			},
  		}},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Println(session.ID)
  	break
  }
  ```

  ```java Java
  var output = dream.outputs().stream()
      .filter(entry -> entry.type().equals(BetaDreamOutput.Type.MEMORY_STORE))
      .findFirst();
  if (output.isPresent()) {
      var outputStoreId = output.get().memoryStoreId();

      var session = client.beta().sessions().create(
          SessionCreateParams.builder()
              .agent(agentId)
              .environmentId(environmentId)
              .addMemoryStoreResource(outputStoreId)
              .build()
      );
  }
  ```

  ```php PHP
  $matches = array_filter($dream->outputs, fn($output) => $output->type === 'memory_store');
  $output = $matches ? reset($matches) : null;
  if ($output !== null) {
      $session = $client->beta->sessions->create(
          agent: $agentId,
          environmentID: $environmentId,
          resources: [
              ['type' => 'memory_store', 'memory_store_id' => $output->memoryStoreID],
          ],
      );
  }
  ```

  ```ruby Ruby
  output = dream.outputs.find { it.type == :memory_store }
  if output
    client.beta.sessions.create(
      agent: agent_id,
      environment_id: environment_id,
      resources: [
        {type: "memory_store", memory_store_id: output.memory_store_id}
      ]
    )
  end
  ```
</CodeGroup>

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

<Warning>
  Während ein Dream `pending` oder `running` ist, gilt die 400-Schutzprüfung für das Archivieren des Dreams selbst, nicht für seine Stores. Das Archivieren oder Löschen eines *Eingabe*-Memory-Stores während des Laufs (oder das Löschen einer Eingabesitzung) führt dazu, dass der Dream mit `input_memory_store_unavailable` oder `input_session_unavailable` fehlschlägt.
</Warning>

## Einen Dream abbrechen

Abbrechen versetzt einen Dream im Status `pending` oder `running` sofort in `canceled`. Das Abbrechen eines bereits `canceled` Dreams ist ein idempotenter No-op; das Abbrechen eines Dreams im Status `completed` oder `failed` gibt 400 zurück.

<Note>
  Nach dem Abbruch können die `usage` (csharp, go: `Usage`)-Felder des Dreams noch einige Sekunden lang aktualisiert werden, während laufende Arbeit ausklingt. Frage den Dream ab, bis sich `usage` (csharp, go: `Usage`) stabilisiert, wenn du die endgültige Anzahl benötigst.
</Note>

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/dreams/$dream_id/cancel" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams cancel --dream-id "$dream_id"
  ```

  ```python Python
  client.beta.dreams.cancel(dream.id)
  ```

  ```typescript TypeScript
  await client.beta.dreams.cancel(dream.id);
  ```

  ```csharp C#
  await client.Beta.Dreams.Cancel(dream.ID);
  ```

  ```go Go
  dream, err = client.Beta.Dreams.Cancel(ctx, dream.ID, anthropic.BetaDreamCancelParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().dreams().cancel(dream.id());
  ```

  ```php PHP
  $client->beta->dreams->cancel($dream->id);
  ```

  ```ruby Ruby
  client.beta.dreams.cancel(dream.id)
  ```
</CodeGroup>

## Einen Dream archivieren

Archivieren setzt `archived_at` (java, php: `archivedAt`; csharp, go: `ArchivedAt`) bei einem Dream, der einen Endzustand erreicht hat (`completed`, `failed` oder `canceled`); `status` (csharp, go: `Status`) bleibt unverändert. Archivierte Dreams sind von Standard-Listenantworten ausgeschlossen, bleiben aber per ID lesbar. Das Archivieren eines bereits archivierten Dreams ist ein idempotenter No-op. Das Archivieren eines Dreams im Status `pending` oder `running` gibt 400 zurück; brich ihn zuerst ab. Es gibt kein Aufheben der Archivierung.

<CodeGroup>
  ```bash cURL
  curl -s -X POST "https://api.anthropic.com/v1/dreams/$dream_id/archive" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams archive --dream-id "$dream_id"
  ```

  ```python Python
  client.beta.dreams.archive(dream.id)
  ```

  ```typescript TypeScript
  await client.beta.dreams.archive(dream.id);
  ```

  ```csharp C#
  await client.Beta.Dreams.Archive(dream.ID);
  ```

  ```go Go
  dream, err = client.Beta.Dreams.Archive(ctx, dream.ID, anthropic.BetaDreamArchiveParams{})
  if err != nil {
  	panic(err)
  }
  ```

  ```java Java
  client.beta().dreams().archive(dream.id());
  ```

  ```php PHP
  $client->beta->dreams->archive($dream->id);
  ```

  ```ruby Ruby
  client.beta.dreams.archive(dream.id)
  ```
</CodeGroup>

Das Archivieren eines Dreams berührt seinen Ausgabe-Memory-Store nicht; verwalte diesen separat über die [Memory Stores API](https://platform.claude.com/docs/de/managed-agents/memory#view-and-edit-memories).

## Dreams auflisten

Gibt alle nicht archivierten Dreams im Workspace zurück, die neuesten zuerst. Verwende `limit` (csharp, go: `Limit`) (Standard 20, maximal 100) und den Cursor `page` (csharp, go: `Page`) zum Paginieren. Setze `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) auf `true`, um archivierte Dreams einzuschließen.

<CodeGroup>
  ```bash cURL
  curl -s "https://api.anthropic.com/v1/dreams?limit=20" \
    -H "x-api-key: $ANTHROPIC_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"
  ```

  ```bash CLI
  ant beta:dreams list --limit 20
  ```

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

  ```typescript TypeScript
  for await (const listedDream of client.beta.dreams.list({ limit: 20 })) {
    console.log(listedDream.id, listedDream.status);
  }
  ```

  ```csharp C#
  var page = await client.Beta.Dreams.List(new() { Limit = 20 });
  await foreach (var listed in page.Paginate())
  {
      Console.WriteLine($"{listed.ID} {listed.Status.Raw()}");
  }
  ```

  ```go Go
  dreams := client.Beta.Dreams.ListAutoPaging(ctx, anthropic.BetaDreamListParams{
  	Limit: anthropic.Int(20),
  })
  for dreams.Next() {
  	listed := dreams.Current()
  	fmt.Println(listed.ID, listed.Status)
  }
  if err := dreams.Err(); err != nil {
  	panic(err)
  }
  ```

  ```java Java
  for (var listedDream : client.beta().dreams().list(
      DreamListParams.builder().limit(20).build()
  ).autoPager()) {
      IO.println(listedDream.id() + " " + listedDream.status());
  }
  ```

  ```php PHP
  foreach ($client->beta->dreams->list(limit: 20)->pagingEachItem() as $dream) {
      echo "{$dream->id} {$dream->status}\n";
  }
  ```

  ```ruby Ruby
  client.beta.dreams.list(limit: 20).auto_paging_each do
    puts "#{it.id} #{it.status}"
  end
  ```
</CodeGroup>

## Fehler

Es folgt eine nicht abschließende Liste möglicher Dreaming-Fehler.

| `error.type`                      | Wann                                                                                                                   |
| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| `timeout`                         | Die Pipeline hat ihr Laufzeitbudget überschritten.                                                                     |
| `internal_error`                  | Nicht klassifizierter Pipeline-Fehler.                                                                                 |
| `memory_store_org_limit_exceeded` | Deine Organisation hat ihre Obergrenze für Memory Stores erreicht, während die Pipeline Arbeitsspeicher bereitstellte. |
| `input_memory_store_too_large`    | Der Eingabe-Memory-Store überschreitet das Größenlimit der Pipeline.                                                   |
| `input_memory_store_unavailable`  | Der Eingabe-Memory-Store wurde archiviert oder gelöscht, nachdem der Dream erstellt wurde.                             |
| `input_session_unavailable`       | Eine Eingabesitzung wurde gelöscht, nachdem der Dream erstellt wurde.                                                  |

## Abrechnung

Dreams werden zu den Standard-API-Token-Preisen für das von dir ausgewählte Modell abgerechnet; `usage` (csharp, go: `Usage`) auf der Ressource meldet die genauen Summen. Die Kosten skalieren ungefähr linear mit der Anzahl und Länge der Eingabesitzungen. Beginne mit einer kleinen Gruppe von Sitzungen und skaliere hoch, sobald du mit der Kurationsqualität zufrieden bist.

## Limits

| Limit                                                 | Wert                                                                                                                                                                        |
| ----------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sitzungen pro Dream                                   | 100                                                                                                                                                                         |
| Länge von `instructions` (csharp, go: `Instructions`) | 4.096 Zeichen                                                                                                                                                               |
| Unterstützte Modelle                                  | `claude-opus-5-5`, `claude-fable-5-1`, `claude-opus-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-5-5`, `claude-sonnet-5`, `claude-sonnet-4-6` |

Für die Erstellung von Dreams gelten Standard-Ratenlimits, solange sich diese Funktion in der Research Preview befindet. [Kontaktiere den Support](https://support.claude.com), wenn du höhere Limits benötigst.