On May 6, 2026, at the Code with Claude developer conference in San Francisco, Anthropic shipped a feature it calls "Dreaming" — a scheduled background process that lets Claude Managed Agents review their own past sessions, extract durable patterns, and rewrite their persistent memory before the next conversation begins. The headline number came from Harvey, the $11B legal-AI startup: task completion rates rose roughly 6x in internal testing once Dreaming was turned on. The failure mode it fixed is the one every enterprise team building agents has hit — agents forgot filetype quirks and tool workarounds between sessions, so the same job failed in the same way over and over again.

That single benchmark is worth your attention if you run any production agent workload, but it is not, by itself, a buying decision. Dreaming sits inside a beta product, requires a specific managed runtime, and disqualifies you from Zero Data Retention and HIPAA Business Associate Agreement coverage today. This piece walks through what shipped, why it matters for both CTOs and CFOs, how it lines up against OpenAI and Google's competing memory stacks, and gives you two practical frameworks — an ROI calculator across three deployment sizes and a 12-point pre-deployment checklist — so your team can take a defensible position before competitors lock in early access.

What Anthropic Actually Shipped

Dreaming is one of three features Anthropic released as part of the May 6 Managed Agents update. The other two — outcomes-based evaluation and multi-agent orchestration — are now in public beta. Dreaming itself remains gated behind a research preview request form and runs only on the Claude Managed Agents API, not on the direct Messages API. To use it today, you need two beta headers: managed-agents-2026-04-01 and dreaming-2026-04-21. Supported models are Claude Opus 4.7 and Claude Sonnet 4.6.

Technically, Dreaming is a three-phase pipeline that runs between agent sessions. In the Read phase, it accepts an existing memory store plus up to 100 past session transcripts, with optional instructions of up to 4,096 characters. In the Curate phase, it identifies three pattern types — recurring mistakes, workflows that multiple agents converged on independently, and preferences shared across a team of agents — then merges duplicates, resolves contradictions by favoring recent values, and surfaces new cross-session insights. In the Output phase, it produces a separate, reviewable memory store without overwriting the original. The status lifecycle is straightforward: pending → running → completed (or failed/canceled). Duration runs from minutes to tens of minutes depending on the input volume. Billing is standard API token rates, scaling linearly with session count and length.

The biological analogy Anthropic leans on is hippocampal memory consolidation — the way a human brain replays the day's events during sleep and decides what is worth keeping. That framing is useful but also marketing, because Dreaming does not modify model weights. It performs structured note-taking against an external persistent store, condensing stale information and promoting load-bearing insights. The underlying model is unchanged. This distinction matters: Dreaming is not a new training paradigm or a fine-tune. It is a memory operations layer with a smart consolidation policy.

The companion features amplify the value. Outcomes evaluation lets you specify a success rubric for an agent task. A separate grader, running in its own context window to avoid bias, evaluates the agent's output. If the grader fails the work, it specifies what needs to change and the agent re-runs. Multi-agent orchestration lets a lead agent decompose work and delegate to specialist agents in parallel on a shared filesystem; Netflix has deployed this pattern for its platform team. Each specialist gets its own model, prompt, and tools, but all events are persistent so the lead can check in mid-workflow. Together, the three features promote what were previously DIY infrastructure problems — long-term memory, automated grading, and parallel subagent dispatch — into first-class platform primitives.

Anthropic also expanded the eligible runtime footprint. Claude Managed Agents now ships on AWS Bedrock with some feature differences, and supports self-hosted sandboxes for execution inside your own infrastructure, plus MCP tunnels for connecting to private MCP servers. Production customers already running on the platform include Notion, Rakuten, Asana, Sentry, and Netflix. Rakuten reported shipping specialist agents across product, sales, marketing and finance within roughly a week each.

Why This Matters

For CTOs and CIOs, Dreaming addresses one of the three or four hardest problems in production agent systems: memory management. Build your own and you spend months wiring up a vector database, designing schemas, writing consolidation jobs, debugging staleness, and reconciling contradictions across sessions. The published state of agent memory research shows just how much craft this requires — the 2026 Mem0 benchmark report lists six features that production memory actually needs: async writes, reranking, metadata filtering, timestamp accuracy, configurable depth and exclusions, and structured exception handling. Most teams reinvent these badly. Dreaming bundles a credible default policy with the runtime.

The architecture implications are real. If you adopt Dreaming, your memory layer is no longer something your team owns end-to-end. Anthropic's curation policy decides what gets kept, what gets discarded, what contradictions get resolved. The "reviewable memory store" output gives you a checkpoint, but most teams will not staff a human-in-the-loop for memory review at any meaningful volume. You are trading control for velocity. That trade is correct for most teams, but it is not a free trade.

Three concrete things to wire into your architecture early. First, memory scope discipline — Dreaming consolidates within whatever scope you define, so user/session/agent/org scope decisions are now load-bearing in a way they were not before. A leaky scope leaks preferences across customers. Second, audit and rollback — because Dreaming can promote a misinterpretation into a confidently wrong memory entry, you need a way to inspect what changed and a way to revert. The reviewable output store helps; a real rollback policy is on you. Third, eviction and compliance — Managed Agents is not currently eligible for Zero Data Retention or HIPAA BAA coverage. For regulated workloads, this is a gating constraint, not a footnote.

For CFOs and business leaders, the financial picture has three layers. The first is the headline ROI signal. Harvey's 6x lift on task completion compounds in two directions: fewer redo cycles per task (lower cost per output) and higher agent reliability (more tasks attempted). The Mem0 report's token-efficiency data backs the directional claim — token-efficient memory architectures run roughly 6,956 tokens per retrieval call versus 26,000 for a full-context baseline, which translates directly into inference cost reductions at production volume.

The second layer is vendor concentration. Adopting Dreaming today commits you more deeply to Claude Managed Agents, on Anthropic models, with a specific memory contract. The 6x lift number comes from one customer (Harvey) on a specific workload (legal drafting) — it is a strong directional signal, not a guarantee for your domain. Independent analysts caution that the technique reduces to scheduled memory pruning and pattern extraction, which is replicable in principle by other vendors. Lock-in math should account for replicability of the capability, not just availability today.

The third layer is the broader production economics. Deloitte's 2026 tech trends data puts the enterprise AI agent failure rate at 88%, with 78% of enterprises running at least one pilot but only 14% successfully scaled to organization-wide use. The infrastructure cost multiplier from pilot to production runs 5-10x. Features that close the pilot-to-production gap — memory persistence, automated grading, orchestration — are precisely the things that make your existing pilot spend pay off. If Dreaming moves your agents from "demo well, fail in production" to "ship reliably," the relevant comparison is not its incremental cost. It is the rescue value of the pilots you have already paid for.

Market Context

The competitive map clarifies the bet Anthropic is making. OpenAI ships its own memory primitive inside the Responses API and ChatGPT, recently expanded to workspace agents in ChatGPT that maintain a persistent folder for notes, drafts, and outputs across sessions. Google's Vertex AI Agent Builder ships a managed runtime with 200+ foundation models, persistent memory, and governance bundled together. Both competitors have memory features in research preview, and both will close the consolidation gap eventually. What none of them ships today is the combination of (a) persistent memory with scheduled consolidation, (b) outcomes-based self-grading with a separate grader context, and (c) parallel subagent dispatch on a shared filesystem, in a single platform. That stack is the actual moat — not Dreaming on its own.

The third-party memory ecosystem is also instructive. Mem0, Zep, and a handful of memory-as-a-service vendors have moved from RAG-style retrieval to first-class memory layers with their own benchmark suite — LoCoMo, LongMemEval, and the BEAM 1M-token benchmark. Top scores on LoCoMo now hit 92.5 with roughly 6,956 tokens per retrieval. The same report flags the still-open production gaps: a 25% performance drop moving from 1M to 10M token contexts, identity resolution failures with mixed auth flows, and memory staleness where high-relevance outdated facts (your user's former employer, a customer's resolved support issue) remain confidently wrong. Dreaming addresses the staleness problem head-on. It does not, by itself, solve identity resolution or 10M-token-scale temporal abstraction.

Analyst commentary is appropriately mixed. The bullish read: three previously manual capabilities became first-class primitives in a managed runtime, which reduces operational complexity for teams adopting Claude. The bearish read: this is structured note-taking on an external store and any competent vendor can ship a similar consolidation policy in the next two quarters. The honest read is somewhere between. Anthropic is not winning on a fundamental research advance. It is winning on integration — Managed Agents + memory + outcomes + orchestration in one platform, with the runtime and tooling already in production at Notion, Rakuten, Asana, Sentry, and Netflix. That bundle is the bet.

Framework #1: The Dreaming ROI Calculator

Pricing is straightforward — Dreaming runs at standard API token rates. The harder question is whether the productivity lift justifies the move to Managed Agents and the operational work to instrument memory properly. Here is a framework for three deployment sizes. Numbers are illustrative but grounded in publicly observed metrics; substitute your own.

Scenario 1 — Pilot Team (1 agent, 1,000 tasks/month)

• Baseline: Direct Messages API with custom memory layer
  • Engineering: 0.5 FTE to maintain memory schemas, consolidation jobs, staleness fixes = ~$12,500/month
  • Inference: ~26,000 tokens per task (full-context baseline) × 1,000 tasks = $4,160/month at Opus 4.7 rates
  • Failure cost: 40% redo rate × 1,000 = 400 wasted runs = $1,664/month
  • Total: ~$18,324/month
• With Dreaming + Managed Agents:
  • Engineering: 0.1 FTE to manage Managed Agents, memory review = ~$2,500/month
  • Inference: ~7,000 tokens per task (consolidated memory baseline) × 1,000 = $1,120/month
  • Dreaming consolidation jobs: ~50 runs/month × ~$1.50 each = $75/month
  • Failure cost: 7% redo rate (6x lift estimate) × 1,000 = 70 wasted runs = $291/month
  • Total: ~$3,986/month
• Net savings: ~$14,338/month. ROI: 360% in month one.

Scenario 2 — Production Team (10 agents, 50,000 tasks/month)

• Baseline: Custom memory + bespoke evaluation
  • Engineering: 2 FTE = ~$50,000/month
  • Inference: $208,000/month
  • Failure cost: 40% redo = $83,200/month
  • Total: ~$341,200/month
• With Dreaming + Managed Agents + Outcomes:
  • Engineering: 0.5 FTE = ~$12,500/month
  • Inference: $56,000/month
  • Dreaming + outcomes overhead: ~$8,000/month
  • Failure cost: 7% redo = $14,560/month
  • Total: ~$91,060/month
• Net savings: ~$250,140/month. ROI: 275%. Payback: under one week.

Scenario 3 — Enterprise (100 agents, 1M tasks/month)

• Baseline: Full memory + grading + orchestration platform built in-house
  • Engineering: 10 FTE platform team = ~$250,000/month
  • Infrastructure: $80,000/month
  • Inference: $4.16M/month
  • Failure cost (40% redo): $1.66M/month
  • Total: ~$6.15M/month
• With Dreaming + Managed Agents + Outcomes + Orchestration:
  • Engineering: 3 FTE = $75,000/month
  • Infrastructure: $20,000/month (lighter footprint, hosted runtime)
  • Inference: $1.12M/month
  • Dreaming + outcomes overhead: ~$150,000/month
  • Failure cost (7% redo): $291,200/month
  • Total: ~$1.66M/month
• Net savings: ~$4.49M/month. ROI: 270%. Payback: ~9 days.

A few caveats. The 6x failure-rate improvement is anchored on Harvey's legal-drafting workload, which has unusually high tool-quirk sensitivity. Plain Q&A or summarization workloads may see a 1.5-2x lift, not 6x. Re-run the numbers with your domain's redo rate. The Managed Agents runtime is not free — you trade per-token margin for managed infrastructure. At very high volumes, self-hosted may still pencil out. And the savings assume you would actually staff the platform team you are no longer building; if you would not, the engineering savings are notional.

Framework #2: Pre-Deployment Checklist for Dreaming

Before you turn Dreaming on for a production workload, walk this list. Each item kills a specific failure mode that production memory systems hit.

Technical readiness (5 items):

1. Memory scope defined and audited. User, session, agent, and org scopes are explicit. No cross-tenant leakage path exists. Test with two synthetic tenants to confirm.
2. Rollback capability. A documented procedure to revert a corrupted memory store to a prior reviewable snapshot. Tested end-to-end at least once.
3. Beta header pinning. managed-agents-2026-04-01 and dreaming-2026-04-21 are explicitly set in all client code, with a deprecation alert subscribed.
4. Model commitment. Workload tested on Claude Opus 4.7 and Sonnet 4.6 with documented latency and quality deltas, so you can switch under cost pressure.
5. Consolidation schedule defined. Frequency calibrated to workload — high-volume support agents may consolidate every few hours; research agents weekly. Schedule documented and instrumented.

Organizational readiness (4 items):

6. Memory review owner identified. A named person reviews dreaming output for at least the first 90 days. Not a team. A person.
7. Failure-mode runbook. Documented response for (a) confidently wrong memory entry, (b) consolidation job failure, (c) memory bloat. Each with an owner and an SLA.
8. Cross-functional sign-off. Security, legal, and compliance have reviewed the data flow and have a written position on residency, retention, and audit access.
9. Vendor exit strategy. A documented migration path off Claude Managed Agents — including export format, target runtime, and re-implementation cost — that you have actually estimated, not handwaved.

Compliance and evaluation (3 items):

10. HIPAA / ZDR / sovereign data review. Confirmed that the workload does not require HIPAA BAA or Zero Data Retention coverage. If it does, route to a different stack.
11. Outcomes rubric written. The success criteria for the agent's tasks are documented and a grader implementation exists. Without an outcomes contract, "6x better" is unmeasurable in your context.
12. Baseline metrics captured. Pre-Dreaming task completion rate, redo rate, token-per-task, and cost-per-task are measured and stored. Without a baseline you cannot prove ROI to your CFO.

Hit fewer than 10 of these and you should pilot, not deploy.

Case Study: How Harvey Got the 6x

Harvey is a $11B legal-AI startup that runs agentic workflows across drafting, research, and document analysis for top-tier law firms. The failure pattern that Dreaming fixed is illustrative because it generalizes. Harvey's agents were drafting and editing legal documents that came in a wide range of file types and formatting conventions, each with quirks — embedded tables that broke on round-tripping, redline conventions that varied by jurisdiction, citation styles that needed to be preserved exactly. The agents would learn the workaround in one session, fail to carry it forward, and stumble on the same quirk in the next session. Identical jobs failed identically.

With Dreaming, the workarounds stuck. The consolidation process surfaced the recurring failure patterns from past sessions, wrote them as durable memory entries, and the next session loaded them automatically. Internal testing showed roughly a 6x jump in task completion rates. Harvey's deployment is broader than just Dreaming — they also use the outcomes evaluation feature to grade legal drafts against a written rubric — but Dreaming was the single largest contributor.

Three lessons travel out of the legal domain. First, the failure mode that Dreaming fixes is workflow-shaped, not capability-shaped. Your model is not failing because it lacks reasoning. It is failing because it forgets context-specific operational learning between sessions. If your agents fail in this pattern, Dreaming is high-value. If they fail because the underlying task is beyond the model's capability, Dreaming will not help. Second, the 6x number is anchored on a workload with unusually high tool-quirk sensitivity. Legal drafting hits a perfect storm of file-format edge cases, jurisdiction-specific conventions, and inflexible quality bars. Customer support or general Q&A workloads will show a smaller lift. Third, the gain is back-loaded. Dreaming requires accumulated session history to consolidate from. The first month after enabling it will look modest; the compounding shows up at month three and beyond. Plan your evaluation window accordingly.

Anthropic is doubling down on the legal vertical. On May 12, 2026, the company launched Claude for Legal — a packaged plug-in for law firms with Westlaw integration and pre-built legal workflows — directly extending the Harvey playbook to mid-market firms that cannot build their own agent stack.

What to Do About It

For CIOs and CTOs: Run a four-week pilot on a workload that matches the Harvey pattern — high tool-quirk sensitivity, recurring inter-session forgetting, well-defined success criteria. Capture baseline metrics before turning Dreaming on. Define memory scopes explicitly. Identify the memory review owner. If your pilot hits a 2x lift, the architecture work is justified. If it hits 4x or better, you have a green light to expand. If it hits less than 1.5x, the failure mode in your workload is not what Dreaming solves — go diagnose what is actually breaking before you spend more.

For CFOs and finance leaders: The ROI math at production scale is compelling enough that the question is not "should we test this?" but "what is our exposure if we don't?" Approve a four-week pilot budget with explicit success criteria — completion-rate lift, redo-cost reduction, cost-per-task delta — and a kill switch if the numbers do not move. Hold the line on the kill switch. Budget for the engineering pull-down (fewer FTE on bespoke memory work) but do not bank the savings until you have actually rerouted those people.

For business and operations leaders: Memory is the unsexy infrastructure problem that determines whether your agents work in week one and still work in week twenty. Treat your team's memory architecture as a strategic decision, not a tactical one. If your AI agent program is stuck in pilot purgatory — and statistically, 88% of agent programs are — the memory layer is one of the few interventions that has been shown to compound over time. Pair the technology decision with two non-technical investments: a clear outcomes rubric for each agent task, and a named owner accountable for whether the agent gets better month over month.

The next 90 days will sort vendors who ship Dreaming-style memory consolidation from those who don't. Make your evaluation discipline now, before the marketing fog settles in.

---

Continue Reading

• Claude Managed Agents: Anthropic's Enterprise Infrastructure Bet
• Why 88% of AI Agents Die in Production: The Observability Gap
• Anthropic Managed Agents: 10x Faster Deployment for Enterprise AI
• MCP vs LangChain vs OpenAI Functions: Enterprise Agent Comparison
• OpenAI's 3-Year Compute Commit: Discount or Trap?