---
title: Sueños
url: https://platform.claude.com/docs/es/managed-agents/dreams
description: Permite que Claude reflexione sobre sesiones pasadas para curar la memoria de un agente y sacar a la luz nuevos insights.
---

<Tip>
  El "dreaming" (soñar) es una función en vista previa de investigación. [Solicita acceso](https://claude.com/form/claude-managed-agents) para probarla.
</Tip>

Los agentes escriben en sus [memory stores (almacenes de memoria)](https://platform.claude.com/docs/es/managed-agents/memory) mientras trabajan, pero estas escrituras son locales e incrementales: a lo largo de muchas sesiones, un almacén de memoria acumula duplicados, contradicciones y entradas obsoletas.

Los **"dreams" (sueños)** permiten que Claude limpie eso. Un sueño lee un almacén de memoria existente junto con transcripciones de sesiones pasadas y luego produce un almacén de memoria nuevo y reorganizado: duplicados fusionados, entradas obsoletas o contradichas reemplazadas por el valor más reciente, y nuevos insights sacados a la luz.

El almacén de entrada nunca se modifica, por lo que puedes revisar la salida y descartarla si no te gusta el resultado.

<Note>
  Los endpoints de sueños están restringidos por el encabezado beta `dreaming-2026-04-21`; el encabezado `managed-agents-2026-04-01` por sí solo no otorga acceso a los sueños. Los ejemplos de endpoints de sueños en esta página envían ambos encabezados; las llamadas de sesiones y almacenes de memoria solo necesitan `managed-agents-2026-04-01`. El SDK los configura automáticamente.
</Note>

## Cómo funciona

Un **sueño** es un trabajo asíncrono que toma:

* un **almacén de memoria** preexistente: el almacén que Claude verifica, deduplica y reorganiza, y
* de 1 a 100 **sesiones:** transcripciones pasadas que Claude examina en busca de patrones e insights para incorporar en la salida.

El sueño produce otro **almacén de memoria de salida**, separado del de entrada. El ID del almacén de salida aparece en el arreglo `outputs` (csharp, go: `Outputs`) del sueño poco después de que el sueño pasa a `running`, una vez que el flujo de trabajo ha clonado el almacén de entrada; un sueño en `running` puede reportar brevemente un arreglo `outputs` (csharp, go: `Outputs`) vacío.

## Crear un sueño

<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>

Las entradas de dreaming incluyen el almacén de memoria preexistente y un arreglo de sesiones. El modelo seleccionado ejecuta el pipeline de dreaming. Durante la vista previa de investigación, se admiten `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` y `claude-sonnet-4-6`. Opcionalmente, puedes pasar `instructions` (csharp, go: `Instructions`) para orientar el proceso de dreaming. Consulta [Orientar con instrucciones](https://platform.claude.com/docs/es/managed-agents/dreams#steer-with-instructions).

La respuesta es el recurso `dream` completo con `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>
  Si solo tienes transcripciones de sesiones y ningún almacén existente, primero [crea un almacén de memoria vacío](https://platform.claude.com/docs/es/managed-agents/memory#create-a-memory-store) y pásalo como la entrada `memory_store`.
</Tip>

### Orientar con instrucciones

El campo opcional `instructions` (csharp, go: `Instructions`) orienta lo que sintetiza el pipeline de dreaming. Se aplica a lo largo de todo el pipeline: qué leer con atención, qué fusionar o descartar y cómo estructurar el almacén de salida.

Usa `instructions` (csharp, go: `Instructions`) para orientación de síntesis de alto nivel, como áreas de enfoque ("enfócate en las preferencias de estilo de código"), contenido que debe conservarse sin cambios o convenciones de salida que quieras aplicar en todo el almacén. El pipeline es una pasada de síntesis sobre las entradas, no un editor aplicado al texto del almacén, por lo que las directivas imperativas dirigidas a líneas específicas ("cambia la oración X por Y", "corrige el conteo en la sección Z") generalmente no producen ningún cambio. Para hacer ediciones específicas en memorias individuales, usa la [API de Memory Stores](https://platform.claude.com/docs/es/managed-agents/memory#view-and-edit-memories) directamente sobre el almacén de salida.

## Seguir el progreso

Los sueños se ejecutan de forma asíncrona y normalmente tardan desde minutos hasta unas pocas horas, según la cantidad de transcripciones de entrada. Consulta el sueño por ID para verificar su estado:

<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>

### Ciclo de vida

| `status` (csharp, go: `Status`) | Significado                                                                                                                                 |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
| `pending`                       | Sueño creado correctamente y en cola.                                                                                                       |
| `running`                       | El pipeline está procesando. `usage` (csharp, go: `Usage`) se actualiza a medida que avanza el trabajo.                                     |
| `completed`                     | Finalizó correctamente. El valor de `outputs` (csharp, go: `Outputs`) es el nuevo almacén de memoria.                                       |
| `failed`                        | La ejecución del dreaming terminó con un error. El almacén de memoria de salida queda tal cual, con lo que se haya escrito antes del fallo. |
| `canceled`                      | Ejecución del dreaming cancelada. El almacén de memoria de salida queda tal cual.                                                           |

### Observar la ejecución del pipeline

Una vez que un sueño está en `running`, su campo `session_id` (java: `sessionId`; php: `sessionID`; csharp, go: `SessionID`) apunta a la [sesión](https://platform.claude.com/docs/es/managed-agents/sessions) subyacente que ejecuta el pipeline. Puedes hacer streaming de los [eventos](https://platform.claude.com/docs/es/managed-agents/events-and-streaming) de esa sesión para observar en tiempo real lo que el sueño está leyendo y escribiendo. La sesión se archiva (no se elimina) cuando el sueño alcanza un estado terminal, por lo que la transcripción sigue disponible después.

## Usar la salida

Cuando `status` (csharp, go: `Status`) llega a `completed`, la entrada `memory_store` en `outputs` (csharp, go: `Outputs`) hace referencia a un almacén completamente poblado. Es un almacén de memoria común en tu espacio de trabajo. Revísalo con la [API de Memory Stores](https://platform.claude.com/docs/es/managed-agents/memory#view-and-edit-memories) o en la Console, y luego:

* **Aprovéchalo:** adjúntalo a sesiones futuras como un recurso `memory_store` en lugar del almacén de memoria de entrada (o junto a él), o
* **Descártalo:** [elimina el almacén de memoria](https://platform.claude.com/docs/es/api/beta/memory_stores/delete) o [archiva el almacén de memoria](https://platform.claude.com/docs/es/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
  # Tras finalizar el dream, la salida contiene el almacén de memoria reconstruido
  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
  // Cuando el dream finaliza, la salida contiene el almacén de memoria reconstruido
  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>

El sueño en sí nunca elimina ni modifica sus entradas. En `failed` o `canceled`, el almacén de salida persiste con contenido parcial para que puedas inspeccionar lo que se produjo antes de detenerse; límpialo mediante la API de Memory Stores si no lo necesitas.

<Warning>
  Mientras un sueño está en `pending` o `running`, la protección 400 se aplica al archivado del sueño en sí, no a sus almacenes. Archivar o eliminar un almacén de memoria de *entrada* a mitad de la ejecución (o eliminar una sesión de entrada) hará que el sueño falle con `input_memory_store_unavailable` o `input_session_unavailable`.
</Warning>

## Cancelar un sueño

Cancelar mueve un sueño en `pending` o `running` a `canceled` de inmediato. Cancelar un sueño que ya está en `canceled` es una operación idempotente sin efecto; cancelar un sueño en `completed` o `failed` devuelve 400.

<Note>
  Después de la cancelación, los campos `usage` (csharp, go: `Usage`) del sueño podrían seguir actualizándose durante unos segundos mientras finaliza el trabajo en curso. Consulta el sueño hasta que `usage` (csharp, go: `Usage`) se estabilice si necesitas el conteo final.
</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>

## Archivar un sueño

Archivar establece `archived_at` (java, php: `archivedAt`; csharp, go: `ArchivedAt`) en un sueño que ha alcanzado un estado terminal (`completed`, `failed` o `canceled`); `status` (csharp, go: `Status`) no se modifica. Los sueños archivados se excluyen de las respuestas de listado predeterminadas, pero siguen siendo legibles por ID. Archivar un sueño ya archivado es una operación idempotente sin efecto. Archivar un sueño en `pending` o `running` devuelve 400; cancélalo primero. No existe la opción de desarchivar.

<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>

Archivar un sueño no toca su almacén de memoria de salida; adminístralo por separado mediante la [API de Memory Stores](https://platform.claude.com/docs/es/managed-agents/memory#view-and-edit-memories).

## Listar sueños

Devuelve todos los sueños no archivados del espacio de trabajo, del más reciente al más antiguo. Usa `limit` (csharp, go: `Limit`) (predeterminado 20, máximo 100) y el cursor `page` (csharp, go: `Page`) para paginar. Establece `include_archived` (java, php: `includeArchived`; csharp, go: `IncludeArchived`) en `true` para incluir los sueños archivados.

<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>

## Errores

A continuación se presenta una lista no exhaustiva de posibles errores de dreaming.

| `error.type`                      | Cuándo                                                                                                                  |
| --------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `timeout`                         | El pipeline excedió su presupuesto de tiempo de ejecución.                                                              |
| `internal_error`                  | Fallo del pipeline sin clasificar.                                                                                      |
| `memory_store_org_limit_exceeded` | Tu organización alcanzó su límite de almacenes de memoria mientras el pipeline aprovisionaba almacenamiento de trabajo. |
| `input_memory_store_too_large`    | El almacén de memoria de entrada excede el límite de tamaño del pipeline.                                               |
| `input_memory_store_unavailable`  | El almacén de memoria de entrada fue archivado o eliminado después de que se creó el sueño.                             |
| `input_session_unavailable`       | Una sesión de entrada fue eliminada después de que se creó el sueño.                                                    |

## Facturación

Los sueños se facturan según las tarifas estándar de tokens de la API para el modelo que selecciones; `usage` (csharp, go: `Usage`) en el recurso reporta los totales exactos. El costo escala de forma aproximadamente lineal con la cantidad y la longitud de las sesiones de entrada. Comienza con un lote pequeño de sesiones y escala una vez que estés satisfecho con la calidad de la curación.

## Límites

| Límite                                                  | Valor                                                                                                                                                                       |
| ------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Sesiones por sueño                                      | 100                                                                                                                                                                         |
| Longitud de `instructions` (csharp, go: `Instructions`) | 4,096 caracteres                                                                                                                                                            |
| Modelos admitidos                                       | `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` |

Se aplican los "rate limits" (límites de velocidad) predeterminados a la creación de sueños mientras esta función está en vista previa de investigación. [Contacta a soporte](https://support.claude.com) si necesitas límites más altos.