How does Claude Dreaming actually work?

Four mechanics. (1) Schedule — Dreaming runs as an async background process between sessions, not during them. You can also trigger it manually with /dream in Claude Code. (2) Sandbox — the dream process is scoped to the memory directory and cannot modify source code, environment, or other project files. (3) Process — it loads up to 100 past sessions in a single dream cycle and rewrites the memory store: prunes outdated notes, merges duplicate entries, resolves contradictions, reorganizes file structure. (4) Output — the consolidated memory replaces the old store and is used by subsequent sessions. It does not modify Claude's model weights — Dreaming is a maintenance layer on top of an external memory store, not fine-tuning.

Which Claude models support Dreaming?

As of May 2026, Dreaming is available for Claude Opus 4.7 and Claude Sonnet 4.6. Each dream cycle can process up to 100 past sessions. The feature is shipped as a research preview, meaning Anthropic considers the behavior, prompt design, and consolidation heuristics still subject to change. You can check whether Auto Dream is enabled in Claude Code with the /memory command. Manual trigger is /dream. For Claude API users, Dreaming is currently exposed through Claude Managed Agents and Claude Code — it's not yet a generally-available standalone API.

Is Claude Dreaming actually useful in production?

The early evidence is striking. Harvey, the legal AI company that has been a flagship Claude customer since 2023, reported approximately 6x improvement in agent task-completion rate on legal-drafting workflows after enabling Dreaming. The mechanism: long legal projects accumulate dozens of session memories that contradict each other (different drafts, different client guidance, different precedent decisions). Without consolidation, the agent gets confused by stale context; with Dreaming, the memory store stays coherent. For shorter or simpler workflows the lift is smaller. The pattern is clear: Dreaming helps most for long-running, multi-session, contradiction-prone agent work. Less useful for one-shot tasks. As a research preview, expect quality and reliability to improve through 2026.

Quick Answer

What Is Claude Dreaming? Auto Dream Memory Consolidation

Q: What is Claude Dreaming?

Claude Dreaming (sometimes called 'Auto Dream' in Claude Code) is a memory consolidation feature Anthropic shipped as a research preview at Code with Claude 2026 on May 6, 2026. It runs as a scheduled background process that reviews and rewrites an agent's memory store between sessions — pruning stale notes, merging duplicates, resolving contradictions, and reorganizing memory files into a leaner, more accurate layer for the next session. The analogy Anthropic uses is REM sleep: the brain consolidates the day's events, decides what to keep, what to compress, what to discard. Legal-AI company Harvey reported ~6x improvement in agent task-completion rates after enabling Dreaming for their legal-drafting workflows.

Published: May 25, 2026

What Is Claude Dreaming? (May 2026)

Anthropic shipped Claude Dreaming (Auto Dream) as a research preview at Code with Claude on May 6, 2026. It’s a memory consolidation feature that runs between sessions — pruning stale notes, merging duplicates, resolving contradictions — and Harvey reported ~6x improvement in legal-drafting task completion after turning it on.

Last verified: May 25, 2026.

TL;DR

Announced: Code with Claude SF, May 6, 2026 (research preview).
What it is: Async memory consolidation for Claude agents.
The analogy: REM sleep — consolidate memories between sessions.
Supported models: Claude Opus 4.7, Claude Sonnet 4.6.
Cycle size: Up to 100 past sessions per dream.
Triggers: Scheduled (Auto Dream) or manual (/dream in Claude Code).
Sandbox: Memory directory only — cannot modify source code.
Flagship result: Harvey reported ~6x agent task-completion improvement on legal drafting.

What Dreaming actually does

The mechanic is straightforward but powerful:

1. Memory accumulates

Across sessions, an agent writes notes to a persistent memory store: facts learned, decisions made, project context, user preferences, work-in-progress states. Over weeks or months, the memory store grows large and incoherent — duplicate entries, stale information, contradictory notes from different drafts or sessions.

2. Dream cycle runs (scheduled or manual)

Dreaming spawns an asynchronous background process that loads the memory store (up to 100 past sessions in a single cycle) and asks the model to consolidate:

Prune stale notes — information no longer relevant, decisions superseded by later ones.
Merge duplicates — multiple notes describing the same fact, collapsed into one canonical entry.
Resolve contradictions — when two memory entries disagree, the model decides which to keep based on recency, source authority, and surrounding context.
Reorganize structure — memory files are restructured for retrieval efficiency.

3. Consolidated memory replaces the old store

The cleaned memory store becomes the input for subsequent sessions. The agent starts the next session with a leaner, more coherent memory rather than the messy accumulation.

4. Sandboxed to memory only

The dream process is scoped to the memory directory. It cannot modify source code, environment, or other project files. The model itself is unchanged — Dreaming is maintenance on an external memory store, not fine-tuning.

Why this matters

Long-running agent workflows fail in a specific way that prompt engineering can’t fix: memory rot. As context accumulates, the signal-to-noise ratio of the memory store degrades. The agent’s later behavior reflects contradictions in its own notes, not the user’s intent.

The standard fix is “summarize and replace” — but humans had to design and trigger the summarization. Dreaming makes it automatic, scheduled, and aware of the consolidation patterns that work for agent memory specifically.

Harvey’s ~6x lift on legal drafting is the clearest evidence: their workflows are long, multi-session, and full of intermediate decisions that get superseded. Without consolidation, the agent gets confused by its own prior notes. With Dreaming, the memory store stays coherent across weeks of work.

Where Dreaming fits in the broader May 2026 Anthropic stack

Three Code with Claude announcements that compose:

Feature	Status	Solves
Outcomes	Public beta	”Agent did the wrong thing because it couldn’t tell good from bad” — adds rubric-driven quality gates
Multi-agent orchestration	Public beta	”One agent overloaded by complex task” — lead agent dispatches sub-agents with shared FS
Dreaming (Auto Dream)	Research preview	”Agent didn’t learn from past sessions” — async memory consolidation

Together they position Claude Managed Agents as Anthropic’s answer to LangGraph + LangSmith + a hosted runtime — fewer pieces to assemble, more opinionated patterns built in.

How to use Dreaming today

In Claude Code:

/memory    # check whether Auto Dream is enabled
/dream     # trigger a dream cycle manually

In Claude Managed Agents: Dreaming is available as a configuration option on managed agents during the public beta. Check the Managed Agents console for the toggle.

In the Claude API directly: not yet a standalone GA primitive. Anthropic positions Dreaming today as a Managed Agents and Claude Code feature; broader API exposure expected post-research-preview.

What’s actually new (vs prior Anthropic memory work)

Anthropic has shipped memory before:

September 2025: Team and Enterprise plans got a memory feature — Claude remembers professional contexts, project details, team patterns.
March 2026: Memory import — users can transfer preferences, conversation style, and instructions from other AI tools (ChatGPT, Gemini) into Claude.

Dreaming is different in one key way: it’s not about more memory; it’s about better memory. Prior memory work added persistence. Dreaming adds maintenance. The two compose — you want persistent memory and consolidation.

Where Dreaming helps most (and least)

Big lift expected:

Long-running agent workflows (weeks or months on the same project)
Multi-session legal, medical, research, engineering work
Workflows with frequent revision, contradiction, supersession
Agents that accumulate detailed user/project context over time

Modest lift expected:

Short one-shot agent tasks
Workflows with little memory accumulation
Stateless or near-stateless agent calls

The mechanism only helps when there’s meaningful memory accumulation to consolidate.

Honest caveats

Research preview. Behavior, prompt design, and heuristics are subject to change. Don’t bet a production-critical workflow on Dreaming’s exact behavior without testing.
Async scheduling adds latency to feedback loops. If you change a project assumption today, the next dream cycle might still reflect the old assumption depending on scheduling.
Consolidation can drop information you wanted to keep. Anthropic ships sensible defaults but you should review consolidated memory periodically — especially in regulated workflows where audit trails matter.
No standalone API yet. If you’re not on Claude Code or Managed Agents, Dreaming isn’t directly accessible today.

Verdict

What it is: Async memory consolidation for Claude agents — REM sleep for AI.
Who needs it: Anyone running long, multi-session Claude agent workflows. Especially anyone whose memory store has accumulated contradictions.
What it replaces: Manual “summarize and replace” memory management. Ad-hoc memory pruning scripts.
What it complements: Outcomes (quality gates) and multi-agent orchestration — the three together form Anthropic’s opinionated production agent stack.
Bottom line: The most concrete production-relevance demonstration is Harvey’s 6x lift. If your workflow looks like Harvey’s — long, multi-session, contradiction-prone — Dreaming is the most impactful Anthropic feature shipped in 2026.