Anthropic Adds ‘Dreaming’ To Claude Managed Agents To Curate Memory

Anthropic told developers at its Code with Claude conference this week that Claude Managed Agents will start to dream. The feature, launched in research preview on the Claude Platform, schedules a background process that walks back through recent agent sessions, picks the few facts worth keeping, and writes those into a long-term memory store the agent will read on its next run. It targets the problem persistent memory alone hasn’t solved: deciding what survives the cleanup pass and what gets dropped.

The pitch is biological. The mechanism is closer to an overnight archivist deciding which whiteboard notes get photographed before the morning wipe. And it lands roughly two weeks after Anthropic added persistent memory to Managed Agents in public beta, completing what the company has framed as a stack for agents that run for hours and want to come back smarter.

What Dreaming Actually Does Between Agent Runs

Dreaming is scheduled, not real-time. While an agent is idle, the platform reviews recent session transcripts and the memory files the agent has been writing during work. It curates a subset, writes those into the long-term store, and discards or merges the rest. The agent reads the curated store on its next invocation.

Anthropic’s April 8 launch announcement for Claude Managed Agents described the product as a hosted runtime where Claude reads files, runs commands, browses, and executes code under guardrails the developer sets. Persistent memory followed on April 23. Dreaming is the third layer added to that stack.

The whole thing is opt-in and configurable. A developer can read the curated memory file, edit it, export it, or wipe it through the API or the Claude Console. That matters for any production deployment routing regulated data through an agent.

The Memory Wall Behind The Marketing

Long-running agents hit a ceiling chat models mostly avoid. A coding agent grinding through a six-hour refactor accumulates state faster than a 200,000-token window can hold. Anthropic’s standard context tops out at 200K tokens, with a 1-million-token window available for select customers. Above that, something has to give.

The model is also not the state. Anthropic’s engineering team made the architectural point in a separate post on decoupling the brain from the body in Managed Agents, where the runtime layer holding files, tools, and conversation history sits logically apart from the inference layer running the model. That separation is what makes dreaming possible. It is also what makes it necessary.

Why Context Windows Stall On Multi-Hour Tasks

Even when the window is technically large, attention dilutes. Researchers have shown for two years that LLMs lose the middle of long prompts. A model can hold a fact in context and still fail to surface it because surrounding tokens have crowded the signal out.

Different vendors are taking different routes at this problem. Subquadratic shipped a 12-million-token context window earlier this week, betting a fundamentally new attention design solves dilution at the architecture level. Anthropic chose the curator route: keep the context window where it is, run a separate process that decides what’s worth remembering.

What Compaction Already Does, And Doesn’t

Compaction is the existing trick on the chat side. The system summarizes older turns and replaces them with a shorter representation, keeping recent turns in full. JetBrains researchers benchmarked this approach in late 2025 and reported that observation masking outperformed straight LLM summarization on cost and reliability, with both strategies cutting costs by more than 50% versus unmanaged memory.

The catch is summarization drift. Each pass throws away detail. After a half-dozen rewrites the summary no longer matches what actually happened. Dreaming attacks the problem from the other side. Instead of compressing every turn, it lifts the small handful of durable facts worth keeping and writes them into a separate file the agent reads directly.

Where Dreaming Sits In The Managed Agents Stack

Dreaming joins two other research-preview features Anthropic has been testing on the platform. Outcomes lets a developer define a success criterion so the agent self-evaluates against it. Multiagent lets several agents coordinate on the same task. Memory and dreaming round out the persistence side.

Here’s the full picture of what a Managed Agents deployment looks like as of today:

• A configurable agent runtime running on Anthropic infrastructure with sandboxed tool execution
• Persistent memory mounted as a filesystem, accessible via API and described in the Claude Managed Agents platform documentation
• Dreaming, in research preview, that curates session memory between agent runs
• Outcomes and multiagent coordination features, both in research preview
• Native integrations with Microsoft 365 and ten financial-services agent templates released in late April

Dreaming Versus Auto Dream In Claude Code

The dream branding now lives in two products. The platform-level feature on Managed Agents is one. The other is Auto Dream, a feature inside Claude Code, the agentic coding CLI, that runs on a developer’s local checkout and consolidates memory files inside a project directory.

These are not the same product, and developers building anything serious should not treat them that way. Auto Dream is a Claude Code client feature operating on local files. Platform dreaming runs server-side on Anthropic-managed infrastructure and operates on session transcripts plus the memory store that lives there.

The split matters because data residency, audit trails, and concurrency look different in each case. A team building an internal coding tool may want both running in tandem. A team shipping a customer-facing agent will want only the platform variant, with a clear policy on what gets read.

Independent Researchers Sound Cautious

The memory-consolidation problem isn’t new. Researchers have argued for at least three years that production agents need an external memory layer above the model. The Mem0 paper from April 2025 argued that scalable agents need extraction, deduplication, and retrievable storage of facts, events, instructions, and tasks pulled from message history. The paper’s measurements showed multi-second latency improvements and answer-quality jumps on long-conversation benchmarks against unmanaged baselines.

Cloudflare made a parallel argument when it launched Agent Memory as a managed product, calling memory the missing tier between an agent and its tools. The thesis on both sides has been consistent: agents that forget cannot improve.

“Memory on Managed Agents mounts directly onto a filesystem, so Claude can rely on the same bash and code execution capabilities that make it effective at agentic tasks.”

That line, from Anthropic’s Managed Agents documentation, puts dreaming on familiar ground. Anthropic is treating memory as text in directories, not vectors in databases. Files developers can grep, diff, and version-control are easier to audit than embeddings. The trade-off is that the curator’s editorial decisions are visible only after the fact.

That visibility is the part skeptics want to watch. Reading agents that consume the curated file inherit whatever the dreaming pass kept. If the curator drops a fact the agent later needs, the agent won’t know what it doesn’t know. The Mem0 paper authors framed the alternative as a memory tier that “extracts facts, events, instructions, and tasks from message history” and stores them in a structured, retrievable form, with explicit deduplication. Anthropic’s bet is that a curator running between sessions does that job well enough for most teams without forcing each one to build its own store.

What Developers Should Know Before Turning It On

Dreaming is in research preview. That means the API surface, the cadence of the dreaming pass, and the rules the curator applies are all subject to change. Teams shipping production workloads on Managed Agents should treat the feature as observability, not as a contract.

Practical points before flipping the switch:

1. Confirm the data sensitivity of session transcripts and memory files; the dreaming pass reads both
2. Export memory files routinely so any curator decision you disagree with is reversible
3. Audit what dreaming kept and dropped after the first few cycles to calibrate trust
4. For multi-agent setups, decide whether each agent gets its own memory store or shares one
5. Treat behavior changes after a dreaming pass as expected, not as model regressions

Frequently Asked Questions

Is Dreaming Available For My Production Workload Today?

No, not for general production use. Dreaming is in research preview on the Claude Platform, available to developers on Managed Agents who opt in via the Console. Anthropic has not committed to a general availability date. Teams shipping regulated workloads should keep it gated to non-production environments until the API surface stabilizes and the curator’s behavior is documented in detail.

How Is Dreaming Different From Compaction On The Chat Side?

Compaction summarizes older conversation turns inline, replacing detail with a shorter representation while keeping recent turns intact. Dreaming runs out-of-band, between agent sessions, and writes a separate curated memory file the agent reads at startup. Compaction shrinks the live context window. Dreaming builds a parallel long-term store. Both can run together on Managed Agents.

Can I Edit Or Override What Dreaming Decides To Keep?

Yes. Memory files mount as a filesystem, and developers can read, edit, export, or wipe them through the API or directly inside the Claude Console. If the dreaming pass drops a fact the agent later needs, you can write it back manually. Standard developer tools like cat, grep, and git work on the contents, since the store is a directory of text files rather than an opaque vector index.

Does Dreaming Send My Data Anywhere New?

No. The pass runs inside Anthropic’s managed infrastructure on data already inside the Managed Agents environment. It reads session transcripts and memory files the platform already holds and writes back into the same store. It does not call out to external services or third-party retrieval systems. The same data-handling commitments that apply to the rest of the Claude Platform apply to dreaming.

The bigger question is whether agents that remember actually get better, or just get more confident about old assumptions. Anthropic’s bet is that a curator running between sessions, with developer override, is the cleanest answer available today. The skeptics’ bet is that any consolidation layer eventually decides things on the developer’s behalf they wouldn’t have agreed to.

Either way, the persistence stack on Managed Agents now has three layers: live context, persistent memory, and a janitor that runs at night. Whether developers learn to trust the janitor is the question that matters next.