Anthropic shipped “Dreaming” on May 6, 2026, as part of a broader Claude Managed Agents update that also added outcomes tracking and multi-agent orchestration. Dreaming is the company’s term for a scheduled memory-consolidation pass that lets Claude agents review their own past sessions between runs, identify patterns, deduplicate redundant entries, drop outdated information, and reorganize their memory layer to improve future performance. Crucially, it runs offline — when the agent is idle — and developers can approve, reject, or edit the reorganized memory before it’s deployed. The result is a self-improving loop that closes one of the biggest gaps enterprises have flagged with autonomous agent systems: agents that don’t learn from their mistakes.
What’s actually new about Claude Dreaming
Three concrete shifts from the previous Claude Managed Agents capabilities. First, the memory consolidation is autonomous between sessions. Before Dreaming, an agent’s memory grew indefinitely — every session added new entries, duplicates accumulated, outdated facts persisted alongside the corrected version. Developers had to either accept the bloat or manually curate memory, which doesn’t scale beyond toy use cases. Dreaming runs periodically (configurable: nightly, weekly, on-demand) and produces a reorganized memory layer as output.
Second, the process is reviewable rather than fully autonomous. Anthropic explicitly designed Dreaming to require human approval before changes take effect in production. The output isn’t applied to the live memory automatically; it’s presented as a diff that developers can accept wholesale, reject, or modify selectively. This makes it safe to deploy in regulated environments where uncontrolled memory mutation would be a compliance issue. For lower-stakes use cases, the approval step can be skipped via a one-time setting per agent.
Third, the input is more than raw transcripts. Dreaming accepts the existing memory store plus large batches of session transcripts and produces a structured reorganization that includes: merged duplicate facts; removed outdated entries (where Claude detected newer information overrides older); promoted recurring patterns (repeated mistakes, team-specific preferences); and consolidated related notes into single coherent entries. The output isn’t just “smaller” — it’s structurally improved.
Why Claude Dreaming matters for agent systems
- Self-improving agents are the missing piece of practical autonomy. Without learning between sessions, agents either need constant human curation or accumulate noise that degrades performance. Dreaming is the first frontier-lab implementation of automated memory consolidation that ships in a production product.
- The approval-gated design is the right safety posture. Letting an agent silently rewrite its own memory would be a security risk (an adversarial input could trigger malicious memory mutations). The diff-and-approve model preserves audit trails and human oversight without losing the productivity benefit.
- Reduces operational toil for enterprise deployments. Teams running 10+ production agents previously had to allocate engineering time to memory hygiene; Dreaming automates 80-90% of that work.
- Closes the gap between agents and human assistants. A human assistant gets better at their job over time by learning what works and what doesn’t. Until Dreaming, AI agents lost that learning between sessions. The new architecture starts to match human-like accumulation of context.
- Sets a pattern competitors will copy. OpenAI’s Codex and Google’s Gemini-based agents don’t have an equivalent automated memory-consolidation feature today. Expect both to announce similar capabilities within months.
- Three additions ship together — Dreaming, outcomes tracking, and multi-agent orchestration. The combination signals that Anthropic is treating Claude Managed Agents as a serious enterprise platform, not a research preview.
How to use Claude Dreaming today
Dreaming is in research preview for Claude Managed Agents customers as of May 6, 2026. Access requires a Claude Teams or Enterprise plan plus the Managed Agents add-on. Here’s the activation path.
- Confirm your workspace is on a Claude plan with Managed Agents enabled. Workspace admins can check at console.claude.ai → Plan → Managed Agents.
- For an existing managed agent, navigate to its detail page: Managed Agents → select agent → Settings → Memory. Toggle Enable Dreaming.
- Configure the schedule. Options: nightly (default), weekly, monthly, or on-demand. For agents with high interaction volume, nightly is recommended; for low-volume agents, weekly is enough.
# Agent dreaming configuration (YAML in the dashboard or via API)
agent_id: agent_abc123
dreaming:
enabled: true
schedule: nightly
schedule_time: "03:00 UTC"
inputs:
sessions_since: 24h # consider last 24h of sessions
memory_store: primary # which memory store to consolidate
review:
require_approval: true # default; false for lower-stakes agents
notify: alice@team.example,review-bot@team.example- For programmatic agents (built via the Claude Agent SDK), enable Dreaming in the agent’s configuration:
# Python SDK
from anthropic_agent import ManagedAgent, DreamingConfig
agent = ManagedAgent(
agent_id="agent_abc123",
memory_config=...,
dreaming=DreamingConfig(
enabled=True,
schedule="nightly",
inputs={"sessions_since": "24h"},
require_approval=True,
)
)
# When a dreaming pass completes, the agent emits a webhook to your endpoint
# Webhook payload includes: memory diff, justifications, suggested action
# Approve via API or via the dashboard
# Approve a dreaming proposal
agent.dreaming.approve(proposal_id="prop_xyz")
# Or reject
agent.dreaming.reject(proposal_id="prop_xyz", reason="too aggressive consolidation")
# Or selectively modify
agent.dreaming.partial_accept(proposal_id="prop_xyz", changes=[...])- Review the first few Dreaming proposals carefully. The system learns your team’s preferences over time — if you reject certain types of consolidations, future proposals respect the pattern. After 2-4 weeks of approvals, most teams report that proposals are close enough to “always approve” that they switch off the approval gate for routine consolidations.
- Monitor agent performance before and after Dreaming via the new outcomes tracking feature (shipped same day). The expected outcomes: faster task completion (fewer redundant memory lookups), better recall on user-specific preferences, fewer repeated errors. If outcomes regress after a Dreaming pass, roll back via the dashboard.
# Outcomes tracking integration
from anthropic_agent import OutcomesTracker
tracker = OutcomesTracker(agent_id="agent_abc123")
# Built-in metrics tracked automatically:
# - task_completion_rate
# - average_session_duration
# - memory_lookup_count
# - error_rate
# - user_correction_rate
# Custom metrics
tracker.record("user_satisfaction", value=0.85, session_id=...)
tracker.record("revenue_attributed_usd", value=1250.00, session_id=...)
# Compare across dreaming passes
report = tracker.compare(
baseline="pre-dreaming",
candidate="post-dreaming-2026-05-15"
)How Claude Dreaming compares to other agent-memory approaches
| Capability | Claude Dreaming | OpenAI Agent Memory | Google Vertex Agent Memory | LangChain / DIY |
|---|---|---|---|---|
| Automated consolidation | Yes — scheduled Dreaming passes | Limited — embedding-based dedup | Limited — session-scoped | Self-built |
| Human approval gate | Yes — diff-and-approve workflow | No | No | Self-built |
| Pattern detection across sessions | Yes — recurring mistakes, preferences | Implicit via embeddings | Implicit via embeddings | Self-built |
| Outdated info pruning | Yes — Claude detects supersession | Manual | Manual | Self-built |
| Schedule control | Nightly / weekly / monthly / on-demand | Not applicable | Not applicable | Self-built |
| Audit trail of memory changes | Full diff history | Limited | Limited | Self-built |
| Integration cost | Toggle in Managed Agents | SDK-level | SDK-level | Engineering investment |
| Pricing | Included in Managed Agents (token cost during Dreaming) | Per-token | Per-token | Self-managed compute |
Claude Dreaming’s clearest differentiators are the explicit consolidation schedule and the human-approval workflow. Competing memory systems either run consolidations continuously (with no audit), depend on the developer to implement custom logic, or treat memory as a passive embedding store without active reorganization. For enterprise teams that need traceable memory mutations, Dreaming is the first turnkey solution.
The trade-offs. Dreaming costs tokens — the consolidation pass is itself an LLM operation reviewing transcripts and producing new memory entries. For high-volume agents with thousands of daily sessions, nightly Dreaming on 24h of transcripts can run hundreds of thousands of tokens per pass. Anthropic prices this at standard Claude Sonnet 4.6 rates; expect $5-50/day for the Dreaming pass on a typical mid-volume agent. The benefit: those tokens replace the engineering time previously spent on manual memory curation.
What’s next for Claude Dreaming and agent memory
Three threads to watch over the next quarter. First, the move from research preview to GA. Dreaming is currently in research preview; Anthropic has signaled GA targeting Q3 2026. The transition usually means tighter SLAs, better tooling, and expanded availability across more Claude plan tiers. Expect Dreaming to become a default feature of Managed Agents rather than an opt-in.
Second, broader pattern detection. Today’s Dreaming consolidates memory but doesn’t explicitly tune agent behavior beyond what’s in memory. The next step is meta-learning: Dreaming proposing prompt adjustments, tool-use changes, and even agent topology modifications based on observed patterns. Anthropic has hinted at this direction in recent blog posts; expect concrete features in late 2026.
Third, competitive responses. OpenAI’s Codex platform has explicit memory features but lacks the consolidation pass. Google’s Vertex Agent Builder relies on Cloud-managed embeddings. Expect both to announce similar capabilities — the pattern is too obvious not to copy. The differentiation will likely shift to the approval-gate design, the quality of consolidation, and the integration depth into the broader platform.
Frequently Asked Questions
Is Claude Dreaming available to all Claude users?
No. It requires the Managed Agents add-on, which is part of Claude Teams ($30+/seat/month, includes Managed Agents at certain tier) and Claude Enterprise plans. Pro and Free tier users can use Claude conversationally but don’t have access to Managed Agents or Dreaming. Anthropic has indicated some Dreaming-like memory features may be exposed in lower tiers later, but no timeline has been published.
What happens to the original session data after Dreaming consolidates it?
Original session transcripts and the pre-Dreaming memory store are preserved unchanged. Dreaming produces a new reorganized memory layer; the original inputs are retained for audit and rollback. If a developer rejects a Dreaming proposal, the existing memory continues to be used. If they accept, the new layer replaces the old one going forward but the old one remains in the audit trail.
Can Claude Dreaming be exploited for memory poisoning attacks?
This is the question security teams ask first. The approval-gate is the primary defense — a malicious memory mutation would have to pass human review before deployment. Beyond that, Anthropic explicitly flags Dreaming as one place where indirect prompt injection (chapter 4 of the Red Teaming LLM Systems eguide) can attempt to influence memory; the auth + audit + approval design closes most attack paths. For high-risk deployments, keep approval mandatory and have a security-trained reviewer on the approval workflow.
How much does Dreaming cost?
Two cost components. First, the Managed Agents add-on (priced per seat in Teams plans, or per managed agent in Enterprise plans). Second, the tokens consumed during each Dreaming pass — billed at standard Claude Sonnet 4.6 rates ($3/M input, $15/M output). For a typical mid-volume agent with ~500K tokens of session transcripts per day, a nightly Dreaming pass costs $5-15/day. For very high-volume agents, the cost is higher; for low-volume agents, weekly schedules keep the cost trivial.
Can I use Dreaming without the human approval step?
Yes, with a config toggle. After 2-4 weeks of approvals where you build confidence in the proposal quality, you can switch to auto-approve for routine consolidations while retaining the gate for high-risk changes. Anthropic’s recommendation: start with mandatory approval for the first month, then graduate to auto-approve with periodic spot checks. Some regulated industries (finance, healthcare) will keep mandatory approval permanently as a compliance control.
How does Dreaming interact with multi-agent orchestration?
Multi-agent orchestration (also shipped May 6) lets multiple Claude agents coordinate on shared tasks. Each agent has its own memory and can be Dreaming-enabled independently. There’s also a shared-memory pattern where multiple agents read from and contribute to a common knowledge base; Dreaming on shared memory is supported but requires more careful approval because the consolidation affects multiple agents. Anthropic recommends running Dreaming on shared memory less frequently and with more conservative approval policies.