Claude Memory “dreaming” is an offline memory consolidation process introduced by Anthropic for long-running AI agents. Rather than simply appending raw session logs or compressing an active conversation window, dreaming runs asynchronously through the Managed Agents Dreams API (currently in research preview under the dreaming-2026-04-21 beta header) to review past session histories and existing memory stores, resolve contradictions, prune stale assumptions, and write back a clean, structured memory state for future runs.
For developers building autonomous AI agents that execute dozens or hundreds of tasks over days and weeks, persistent memory often degrades into a cluttered scratchpad. Early mistakes get repeated because the agent reads its own outdated notes as ground truth. Anthropic designed dreaming to tackle that failure mode directly by separating active task execution from background memory maintenance.
What Is Claude Memory Dreaming?
In human cognition, sleep plays a critical role in turning short-term experiences into organized long-term knowledge while discarding irrelevant noise. Anthropic borrows this metaphor for agent engineering. In the context of Claude Managed Agents, dreaming is a dedicated, asynchronous step where the system inspects accumulated session traces alongside the agent’s existing persistent memory and reorganizes what the agent “knows.”
When an agent works across multiple sessions, it typically writes notes, discoveries, and intermediate rules to a persistent store. Over time, those notes accumulate:
- Duplicate observations recorded across separate runs
- Stale hypotheses that were disproved in later sessions but never deleted from earlier notes
- Unstructured dumps that obscure critical operational rules
- Contradictory instructions gathered from edge-case failures
Instead of forcing the agent to sort through that clutter in real time while trying to solve a user’s prompt, a dream job runs offline between active sessions. It takes the prior memory state and recent session transcripts as inputs, synthesizes what actually held true across trajectories, and outputs an updated, consolidated memory store.
How Does Dreaming Differ from Same-Session Compaction?
A common point of confusion for developers working with the Claude API is the difference between same-session compaction and cross-session dreaming. While both techniques help manage context limits and AI token consumption, they operate on different timescales and solve distinct architectural problems.
| Feature | Same-Session Compaction | Claude Memory Dreaming |
|---|---|---|
| Scope | Single active conversation or task thread | Cross-session knowledge across multiple runs |
| Timing | Synchronous (triggers mid-session near context limits) | Asynchronous / offline (runs between sessions) |
| Primary Goal | Free up context window space to keep the current run alive | Reorganize, deduplicate, and correct persistent memory |
| Input | Current Claude API message thread | Past session histories + existing memory files/stores |
| Output | Condensed summary replacing older turns in the active prompt | Refactored, structured long-term memory for future sessions |
Same-session compaction is an emergency valve for context length. When an agent loops through dozens of tool calls in a single sitting and approaches the model’s context ceiling, compaction summarizes earlier turns so the session can continue without throwing a token limit error. However, compaction is inherently lossy and local—it only knows about the current thread.
Dreaming, by contrast, is strategic and global. It looks across multiple completed sessions to spot patterns that a single-thread summary would miss. If an agent tried three different approaches across three separate sessions and only the third succeeded, a dream cycle can overwrite the failed hypotheses from sessions one and two and promote the validated workflow into the core memory store.
How Does Dreaming Compare to ChatGPT-Style Chat Memory?
It is also useful to distinguish Anthropic’s agent dreaming from consumer-facing chat memory features, such as the cross-session memory used in ChatGPT. While both mechanisms allow an AI system to remember facts across separate conversations, they are built for different workloads: cross-session storage versus offline reorganization.
Consumer chat memory generally works as a lightweight fact store. When a user mentions a preference, role, or project detail, the assistant extracts a short snippet and appends it to a persistent profile that gets injected into future system prompts. That approach works well for remembering a user’s preferred programming language or writing tone, where facts are mostly additive and rarely require deep structural synthesis.
Agent workloads look very different. An agent navigating a codebase, maintaining an internal wiki, or playing a complex game generates thousands of lines of environmental observations, tentative plans, and tool outputs. Simply appending “facts” to a flat list quickly pollutes the context window. Dreaming treats memory not as an append-only list of user facts, but as an evolving knowledge base that periodically requires offline garbage collection, conflict resolution, and schema reorganization.
How Does the Managed Agents Dreams API Work?
Anthropic exposes this capability through the Managed Agents Dreams API, which is currently available as a research preview. Because the feature is in beta, requests must include the explicit beta header:
anthropic-beta: dreaming-2026-04-21Core Mechanics: Inputs, Outputs, and Async Execution
Unlike standard message generation calls that stream tokens back to an interactive user in seconds, dreaming is built around asynchronous execution:
- Inputs: You provide the Dreams API with the agent’s current memory state (the persistent files or structured memory blocks the agent has accumulated) along with the session logs or trajectories from recent agent runs.
- Offline Processing: The dream job runs asynchronously in the background. Because it is decoupled from the live user-facing loop, the model can spend the necessary compute and reasoning tokens to cross-reference session transcripts against stored beliefs without adding latency to an active chat turn.
- Outputs: Once the asynchronous job completes, the API returns a reorganized memory payload—pruned of dead ends, updated with verified findings, and structured so future agent sessions can ingest it cleanly.
By pairing consolidated memory files with prompt caching, developers can inject the newly reorganized memory into the system prefix of subsequent sessions, keeping per-turn latency and input costs predictable while giving the agent higher-quality context.
Does Dreaming Actually Improve Agent Performance?
To demonstrate why offline memory consolidation matters, Anthropic shared several internal evaluation examples showing how raw, unmaintained memory can actively harm agent performance—and how dreaming fixes those regressions.
1. Fixing Self-Reinforced Errors in Pokémon (Mt. Moon)
One of the clearest qualitative examples comes from Claude playing Pokémon. During earlier play sessions, the agent wrote an incorrect assumption about navigating Mt. Moon into its persistent memory notes. In subsequent runs, whenever the agent re-entered the area, it read its own faulty note, trusted it as established fact, and repeatedly got stuck following the bad route.
According to Anthropic, running a dreaming cycle allowed the system to compare the agent’s written assumption against the actual outcomes recorded in the session transcripts. The dream process recognized that the stored strategy consistently failed, corrected the erroneous Mt. Moon note, and allowed the agent to progress on later runs.
2. Scaling Multi-Session Wiki Maintenance (13% to 48%)
In a long-horizon knowledge management evaluation where an agent was tasked with building and maintaining a wiki across a scaled number of sessions, raw memory accumulation caused performance to degrade sharply as the session count grew.
According to Anthropic, adding dreaming raised the agent’s success rate on this multi-session wiki scaling benchmark from 13% to 48%. By periodically reorganizing how pages, links, and notes were indexed between runs, the agent avoided drowning in its own fragmented drafts.
3. LAB Contract Benchmark (72% to 100%)
Anthropic also evaluated dreaming on a LAB contract task requiring consistent rule tracking and multi-step verification across sessions. According to Anthropic, incorporating offline memory dreaming increased the completion rate from 72% to 100%. Where standard persistent memory occasionally carried over partial or conflicting interpretations from earlier attempts, the consolidated memory state kept the agent aligned with every contract constraint.
(Note: All benchmark figures above are Anthropic-reported evaluations from the research preview announcement and reflect specific multi-session test harnesses rather than guaranteed gains across all production workloads.)
Practical Takeaways for Developers Building Agents
Even if you are not yet migrating your entire stack to Claude Managed Agents, the architecture behind the dreaming-2026-04-21 preview offers a clear blueprint for anyone building stateful workflows—whether you are orchestrating coding assistants, automated research pipelines, or multimodal production pipelines on platforms like AI Studio Video.
Stop Treating Agent Memory as Append-Only
The biggest lesson from Anthropic’s evaluations is that bad memory is worse than no memory. When an agent writes a hallucinated root cause or a flawed workaround into a persistent MEMORY.md file or vector database, every future session inherits that bug. If your agent has write access to persistent memory during active runs, you need a separate mechanism that can edit and delete those entries later.
Separate Execution Prompts from Consolidation Prompts
During an active task, an agent’s prompt is optimized for forward progress: calling tools, writing code, or answering a customer. Asking the same prompt to simultaneously audit its entire historical knowledge base splits the model’s attention and burns active-session tokens. Moving memory cleanup into an asynchronous background job—triggered after $N$ sessions, at the end of a workday, or when a task branch closes—keeps live interactions fast and focused.
Require Evidence from Transcripts Before Promoting Facts
Notice how the Pokémon Mt. Moon correction worked: the dream step did not just summarize the agent’s notes; it checked the notes against what actually happened in the session logs. When designing your own memory workflows or adopting the Managed Agents Dreams API, make sure the consolidation step has access to ground-truth tool outputs and final task outcomes, not just the agent’s self-reported commentary.
Know When You Need Dreaming vs. Simple Compaction
Not every application needs an asynchronous dream pipeline:
- Use same-session compaction when your tasks are self-contained within a single long run (for example, a one-off code refactoring session that takes 80 tool turns but doesn’t need to carry domain knowledge into next week).
- Use cross-session dreaming when an agent operates over days or weeks in the same environment, accumulates evolving domain knowledge, and risks poisoning its own context with outdated observations.
Frequently Asked Questions
What is the beta header for Anthropic’s Dreams API?
To access the Managed Agents Dreams API during its research preview, include the dreaming-2026-04-21 value in the anthropic-beta HTTP header on your API requests.
Does Claude Memory dreaming run in real time during a chat?
No. Unlike same-session compaction, which compresses context mid-conversation so a thread can continue, dreaming runs asynchronously offline between sessions. It takes past session histories and current memory as inputs and produces a reorganized memory store for future sessions.
Why did Anthropic name the feature “dreaming”?
The name draws an analogy to how biological brains consolidate memories during sleep—replaying recent experiences, strengthening verified patterns, pruning irrelevant details, and integrating new findings into existing long-term memory without real-time sensory input.
How much did dreaming improve performance in Anthropic’s benchmarks?
According to Anthropic, offline memory dreaming improved multi-session wiki scaling performance from 13% to 48% and raised the LAB contract evaluation score from 72% to 100%, while also resolving self-reinforced navigation errors in long-horizon Pokémon playtests.
