Dreams

The OMA Console reserves a Dreaming entry, but the current release does not yet expose the complete Dreams API. This page records the compatibility target and is not a current availability commitment.

Dreaming is a research preview feature. Request access to try it.

Agents write to their memory stores as they work, but these writes are local and incremental: over many sessions a memory store accumulates duplicates, contradictions, and stale entries. Dreams clean that up. A dream reads an existing memory store alongside past session transcripts, then produces a new, reorganized memory store: duplicates merged, stale or contradicted entries replaced with the latest value, and new insights surfaced. The input store is never modified, so you can review the output and discard it if you don’t like the result.

Dream endpoints are gated by the dreaming-2026-04-21 beta header; the managed-agents-2026-04-01 header on its own doesn’t grant access to dreams. The dream-endpoint examples on this page send both headers; session and memory-store calls need only managed-agents-2026-04-01. The SDK sets these automatically.

How it works

A dream is an asynchronous job that takes:

a pre-existing memory store: the store the model verifies, deduplicates, and reorganizes, and
1 to 100 sessions: past transcripts the model mines for patterns and insights to fold into the output.

The dream produces another output memory store, separate from the input. The output store ID appears in the dream’s outputs[] shortly after the dream starts running, once the workflow has cloned the input store; a running dream can briefly report an empty outputs[].

Create a dream

dream=$(curl -s http://localhost:38080/v1/dreams \
  -H "x-api-key: $OMA_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 @- <<EOF
{
  "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."
}
EOF
)
dream_id=$(jq -r '.id' <<< "$dream")
echo "$dream_id"  # drm_01...

dream_id=$(ant beta:dreams create --transform id --raw-output <<YAML
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.
YAML
)

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

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

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-4-8",
    Instructions = "Focus on coding-style preferences; ignore one-off debugging notes.",
});
Console.WriteLine(dream.ID);  // drm_01...

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

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

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

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."
)
puts dream.id # drm_01...

Dreaming inputs include the pre-existing memory store and an array of sessions. The selected model runs the dreaming pipeline; during the research preview claude-opus-5, claude-fable-5, claude-opus-4-8, claude-opus-4-7, claude-sonnet-5, and claude-sonnet-4-6 are supported. You can optionally pass instructions to steer the dreaming process; see Steer with instructions. The response is the full dream resource with 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
}

If you only have session transcripts and no existing store, create an empty memory store first and pass it as the memory_store input.

Steer with instructions

The optional instructions field steers what the dreaming pipeline synthesizes. It is applied throughout the pipeline: what to read closely, what to merge or drop, and how to structure the output store. Use instructions for high-level synthesis guidance such as focus areas (“focus on coding-style preferences”), content to preserve unchanged, or output conventions you want applied across the store. The pipeline is a synthesis pass over the inputs, not an editor applied to the text of the store, so imperative directives that target specific lines (“change sentence X to Y”, “fix the count in section Z”) generally produce no change. To make targeted edits to individual memories, use the Memory Stores API on the output store directly.

Track progress

Dreams run asynchronously and typically take minutes to a few hours, driven by the number of input transcripts. Poll the dream by ID to check status:

while true; do
  dream=$(curl -s "http://localhost:38080/v1/dreams/$dream_id" \
    -H "x-api-key: $OMA_API_KEY" \
    -H "anthropic-version: 2023-06-01" \
    -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21")
  status=$(jq -r '.status' <<< "$dream")
  echo "status=$status input_tokens=$(jq -r '.usage.input_tokens' <<< "$dream")"
  [[ "$status" == "pending" || "$status" == "running" ]] || break
  sleep 10
done

ant beta:dreams retrieve --dream-id "$dream_id"

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

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}`);
}

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

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

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());
}

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

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

Lifecycle

`status`	Meaning
`pending`	Dream successfully created and queued.
`running`	The pipeline is processing. `usage` updates as work progresses.
`completed`	Finished successfully. The `outputs[]` value is the new memory store.
`failed`	Dreaming run ended with an error. The output memory store is left as-is with whatever was written before failure.
`canceled`	Dreaming run canceled. The output memory store is left as-is.

Watch the pipeline run

Once a dream is running, its session_id field points at the underlying session running the pipeline. You can stream that session’s events to observe what the dream is reading and writing in real time. The session is archived (not deleted) when the dream reaches a terminal state, so the transcript remains available afterward.

Use the output

When status reaches completed, the memory_store entry in outputs[] references a fully populated store. It’s an ordinary memory store in your workspace. Review it with the Memory Stores API or in the Console, then either:

Leverage it: attach it to future sessions as a memory_store resource in place of (or alongside) the input memory store, or
Discard it: delete the memory store or archive the memory store.

# After the dream ends, the memory_store output holds the rebuilt store
output_store_id=$(jq -r 'first(.outputs[] | select(.type == "memory_store")).memory_store_id' <<< "$dream")

curl -s http://localhost:38080/v1/sessions \
  -H "x-api-key: $OMA_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01" \
  -H "content-type: application/json" \
  --data @- <<EOF
{
  "agent": "$agent_id",
  "environment_id": "$environment_id",
  "resources": [
    { "type": "memory_store", "memory_store_id": "$output_store_id" }
  ]
}
EOF

output_store_id=$(ant beta:dreams retrieve --dream-id "$dream_id" --format json |
  jq -r 'first(.outputs[] | select(.type == "memory_store")).memory_store_id')

ant beta:sessions create <<YAML
agent: $agent_id
environment_id: $environment_id
resources:
  - type: memory_store
    memory_store_id: $output_store_id
YAML

# After the dream ends, the output holds the rebuilt 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},
    ],
)

// After the dream ends, the output holds the rebuilt 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 },
  ],
});

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

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{
                MemoryStoreID: outputStoreID,
            },
        }},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(session.ID)
    break
}

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()
    );
}

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

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

The dream itself never deletes or modifies its inputs. On failed or canceled the output store persists with partial contents so you can inspect what was produced before stopping; clean it up through the Memory Stores API if you don’t need it.

While a dream is pending or running, the 400 guard applies to archiving the dream itself, not its stores. Archiving or deleting an input memory store mid-run (or deleting an input session) will cause the dream to fail with input_memory_store_unavailable or input_session_unavailable.

Cancel a dream

Cancel moves a pending or running dream to canceled immediately. Canceling an already-canceled dream is an idempotent no-op; canceling a completed or failed dream returns 400.

After cancellation, the dream’s usage fields might continue to update for a few seconds while in-flight work winds down. Poll the dream until usage stabilizes if you need the final count.

curl -s -X POST "http://localhost:38080/v1/dreams/$dream_id/cancel" \
  -H "x-api-key: $OMA_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"

ant beta:dreams cancel --dream-id "$dream_id"

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

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

await client.Beta.Dreams.Cancel(dream.ID);

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

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

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

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

Archive a dream

Archive sets archived_at on a dream that has reached a terminal state (completed, failed, or canceled); status is left unchanged. Archived dreams are excluded from default list responses but remain readable by ID. Archiving an already-archived dream is an idempotent no-op. Archiving a pending or running dream returns 400; cancel it first. There is no unarchive.

curl -s -X POST "http://localhost:38080/v1/dreams/$dream_id/archive" \
  -H "x-api-key: $OMA_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"

ant beta:dreams archive --dream-id "$dream_id"

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

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

await client.Beta.Dreams.Archive(dream.ID);

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

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

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

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

Archiving a dream does not touch its output memory store; manage that separately through the Memory Stores API.

List dreams

Returns all non-archived dreams in the workspace, newest first. Use limit (default 20, max 100) and the page cursor to paginate. Pass include_archived=true to include archived dreams.

curl -s "http://localhost:38080/v1/dreams?limit=20" \
  -H "x-api-key: $OMA_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: managed-agents-2026-04-01,dreaming-2026-04-21"

ant beta:dreams list --limit 20

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

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

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

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

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

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

client.beta.dreams.list(limit: 20).auto_paging_each do
  puts "#{it.id} #{it.status}"
end

Errors

A non-exhaustive list of possible dreaming errors follows.

`error.type`	When
`timeout`	The pipeline exceeded its runtime budget.
`internal_error`	Unclassified pipeline failure.
`memory_store_org_limit_exceeded`	Your organization hit its memory-store cap while the pipeline was provisioning working storage.
`input_memory_store_too_large`	The input memory store exceeds the pipeline’s size limit.
`input_memory_store_unavailable`	The input memory store was archived or deleted after the dream was created.
`input_session_unavailable`	An input session was deleted after the dream was created.

Billing

Dreams are billed at standard API token rates for the model you select; usage on the resource reports the exact totals. Cost scales roughly linearly with the number and length of input sessions. Start with a small batch of sessions and scale up once you’re satisfied with the curation quality.

Limits

Limit	Value
Sessions per dream	100
`instructions` length	4,096 characters
Supported models	`claude-opus-5`, `claude-fable-5`, `claude-opus-4-8`, `claude-opus-4-7`, `claude-sonnet-5`, `claude-sonnet-4-6`

Default rate limits apply to dream creation while this feature is in research preview. Contact support if you need higher limits.

First steps

Define your agent

Configure agent environment

Delegate work to your agent

Manage agent context

Advanced orchestration

Reference

How it works

Create a dream

Steer with instructions

Track progress

Lifecycle

Watch the pipeline run

Use the output

Cancel a dream

Archive a dream

List dreams

Errors

Billing

Limits

​How it works

​Create a dream

​Steer with instructions

​Track progress

​Lifecycle

​Watch the pipeline run

​Use the output

​Cancel a dream

​Archive a dream

​List dreams

​Errors

​Billing

​Limits

How it works

Create a dream

Steer with instructions

Track progress

Lifecycle

Watch the pipeline run

Use the output

Cancel a dream

Archive a dream

List dreams

Errors

Billing

Limits