Sueños

Los agentes escriben en sus memory stores (almacenes de memoria) 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.

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 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 estado running puede reportar brevemente un outputs[] vacío.

Crear un sueño

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

Las entradas del 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, claude-fable-5, claude-opus-4-8, claude-opus-4-7, claude-sonnet-5 y claude-sonnet-4-6. Opcionalmente puedes pasar instructions para orientar el proceso de dreaming. Consulta Orientar con instrucciones.

La respuesta es el recurso dream completo con 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
}

Orientar con instrucciones

El campo opcional 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 para guía de síntesis de alto nivel, como áreas de enfoque ("enfócate en las preferencias de estilo de código"), contenido que se debe preservar 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 puntuales a memorias individuales, usa la API de Memory Stores 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:

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}")

Ciclo de vida

Observar la ejecución del pipeline

Una vez que un sueño está en running, su campo session_id apunta a la sesión subyacente que ejecuta el pipeline. Puedes hacer streaming de los eventos 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 llega a completed, la entrada memory_store en outputs[] hace referencia a un almacén completamente poblado. Es un almacén de memoria ordinario en tu espacio de trabajo. Revísalo con la API de Memory Stores 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 o archiva el almacén de memoria.

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

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.

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.

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

Archivar un sueño

Archivar establece archived_at en un sueño que ha alcanzado un estado terminal (completed, failed o canceled); status queda sin cambios. 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.

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

Archivar un sueño no toca su almacén de memoria de salida; adminístralo por separado mediante la API de Memory Stores.

Listar sueños

Devuelve todos los sueños no archivados del espacio de trabajo, del más reciente al más antiguo. Usa limit (predeterminado 20, máximo 100) y el cursor page para paginar. Pasa include_archived=true para incluir los sueños archivados.

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

Errores

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

Facturación

Los sueños se facturan a las tarifas estándar de tokens de la API para el modelo que selecciones; 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

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 si necesitas límites más altos.