Claude's 'Dreams,' accurately — what Anthropic actually shipped, and what the '6x' coverage got wrong

When Anthropic unveiled “dreaming” at Code with Claude on May 6, the coverage wrote itself: AI agents that sleep, dream, and wake up smarter; one outlet led with a customer seeing task completion jump “6x.” It’s a great story. It’s also, in three important ways, not what Anthropic shipped. Since this site’s whole job is to check the claim against the primary source, here’s the accurate version.

What it actually is (from the docs, not the press)

The official feature is called Dreams — “dreaming” is the process — and per Anthropic’s documentation it’s one specific thing: “A dream reads an existing memory store alongside past session transcripts, then produces a new, reorganized memory store: duplicates merged, stale or contradicted entries replaced with the latest value, and new insights surfaced.”

Mechanically, it’s an asynchronous API job: you pass in one existing memory store plus 1 to 100 sessions, and it returns a separate new store. The single most important line, which almost no coverage mentioned: “The input store is never modified, so you can review the output and discard it if you don’t like the result.” It’s steerable (an optional instructions field — “Focus on coding-style preferences; ignore one-off debugging notes”), observable (you can stream the dream’s session to watch what it reads and writes), and it runs on claude-opus-4-8, 4-7, or sonnet-4-6, typically taking minutes.

That’s a clean, useful primitive. It is not the thing the headlines described.

Three things the coverage got wrong

1. It is not an automatic background process. The recurring press line — “a scheduled process that runs between agent sessions and writes new memory the next session can use” — describes a daemon on an idle timer. The actual API is developer-invoked: you call it, it runs once, you review the output. There’s no “while you sleep” scheduler in the docs. The dreaming metaphor (run a consolidation pass “overnight”) is real as a usage pattern; the automatic part is press embellishment.

2. It is not in Claude Code. Dreams lives only in Claude Managed Agents — the cloud agent platform — behind beta headers, as a research preview you request access to. There is no Dreams page for the Claude Code CLI in Anthropic’s docs. If you’ve seen a /dream command or an “auto-dream” skill for Claude Code, those are community reverse-engineering of an unreleased capability — their own authors describe them as “currently unreleased” / “not officially announced.” Don’t mistake a third-party skill for a shipped Anthropic feature.

3. The neuroscience framing is press, not Anthropic. “Anthropic compares dreaming to hippocampal memory consolidation” appears across blog coverage, but it’s the writers’ analogy. Anthropic’s own docs use flat, accurate verbs — “reflect,” “curate,” “consolidate.” The only Anthropic-side nod to the metaphor is the product name.

The “6x” number: treat it as an anecdote, not a result

The stickiest claim is that legal-AI firm Harvey saw “task completion rates rise roughly 6x in internal testing” after enabling dreaming. We tried to source it and couldn’t, in the ways that matter:

• It is not in Anthropic’s documentation.
• It is not in Simon Willison’s contemporaneous keynote live blog — the most detailed real-time record of what was actually said on stage. That absence is the tell: a 6x headline number, if announced, would be in the keynote notes.
• It traces to VentureBeat’s coverage, with no named Anthropic or Harvey spokesperson, and no published benchmark behind it.

This is exactly the pattern our benchmark guide warns about: a clean multiplier with no methodology, repeated until it sounds official. Dreaming may well help — directionally, deduping and reconciling an agent’s memory is obviously useful. But “6x task completion” is an unattributed internal anecdote, not a controlled result, and you should file it accordingly.

The part that actually matters: memory becomes an attack surface

Strip the hype and the real story is a security one. A consolidation pass that re-reads an agent’s entire memory and rewrites it amplifies a risk Anthropic itself documents. From the agent memory docs: a read-write memory store exposed to untrusted input means “a successful prompt injection could write malicious content into the store. Later sessions then read that content as trusted memory.”

Dreaming raises the stakes because it re-ingests everything and synthesizes a new store — so a single poisoned note can be laundered into a confident, consolidated “insight” the next session treats as fact. This is the agent-memory analog of the rules-file attacks we keep flagging on instruction files: anything auto-loaded and auto-trusted is an injection target. (Security researchers point to MINJA-style memory-record injection as the named version of this; that’s their analysis, not Anthropic’s.)

The mitigations are real and worth knowing precisely because they’re design choices, not afterthoughts: the input store is never mutated, the output is reviewable and discardable, every write is a versioned audit entry, and the dream session is streamable. In other words, the safe way to use dreaming is to treat its output as a proposal to review, not a change to trust — which, notably, is the opposite of the “agent improves itself while you sleep” framing.

Want the effect in Claude Code today? Do it manually

Since Dreams isn’t in the CLI, here’s the honest version of “dreaming for Claude Code” — built from primitives that actually exist:

• Claude Code already has auto memory. It maintains a MEMORY.md index under ~/.claude/projects/<project>/memory/ and you inspect it with /memory. That’s the store a consolidation pass would operate on.
• There’s no official auto-curation — so schedule your own. A scheduled routine (or a Stop-hook) that periodically asks Claude to “read my memory files, merge duplicates, drop anything stale, and flag contradictions — output a revised copy for me to approve” reproduces the useful 80% of dreaming, with the review step built in.
• Keep the human gate. The whole point of the primary-doc design is that you review before you trust. A DIY version should too — consolidate into a copy, read the diff, then promote it. That’s also how you keep a fleet of agents’ memory from drifting.

The one-line version: Anthropic shipped a careful, reviewable memory-consolidation API for its cloud agents, gated as a research preview. The internet shipped a story about dreaming robots that get 6x better overnight. Build on the first one.

Companion reading

• AI agent benchmarks: separating signal from marketing — why the “6x” gets the skeptic’s treatment.
• Running a fleet of long-lived agents — keeping agent memory clean without dreaming.
• Claude Code’s /loop and scheduled work — the primitive for a DIY consolidation pass.
• CLAUDE.md vs AGENTS.md — the instruction-file side of the same auto-loaded-and-trusted risk.