Claude Agent Memory: Anthropic's Dreaming Fixes Stale Notes

Sources checked and dated on publication. See our editorial policy.

Anthropic's engineering team published a detailed study of agent memory on November 6, 2026, testing a memory directory across six Claude models on the CL-Bench 1.0 database task. The findings are concrete: a persistent memory store beat a stateless baseline for every model tested, telling the model exactly what to record made things worse, and an offline pass Anthropic calls dreaming corrected wrong notes and built wiki-style knowledge maps.

What Anthropic actually published

Related guide: Anthropic: Multi-Agent Teams Often Underperform One Agent

The post is research rather than a product launch: it announces no new model and no new generally available API. What it does is document how Anthropic's team builds and evaluates agent memory for long-running Claude deployments, and it publishes the numbers behind the design choices. The work builds directly on the Dreams endpoint in the Claude Platform documentation, which is still in research preview for Managed Agents.

The central question is narrow and practical: when an agent runs across many sessions, what should it write down, what should it load every time, and how do you stop yesterday's wrong note from steering today's actions? Anthropic's answer is a four-layer memory hierarchy plus an offline consolidation pass that mirrors the way human memory is consolidated during rest, borrowing terminology from sleep-time compute research and calling the pass dreaming.

The four layers of agent memory

Related guide: Businesses in ChatGPT: Business Hub and Business Agents

Anthropic defines agent memory as knowledge an agent gains from experience and retains between sessions, saved as context it can read later. That definition deliberately excludes weight updates, in-context learning, and compaction — summarising older turns to fit the context window is not memory in this framing.

What remains is a hierarchy with four layers:

• Transcripts — a searchable event log of the agent's sessions, the raw ground truth.
• Memory notes — salient observations the agent writes during a session, when it can only see that session's context.
• Representations — structures such as wikis, which collect what the agent knows about one subject and link pages together.
• Injected context — the material loaded into every session, which must stay small because injected memories consume tokens and a wrong note there gets carried into every run.

The top layer is the expensive one. Anthropic notes that loading a note does not guarantee the model acts on it, and that Claude Code's own documentation warns that longer instruction files reduce adherence. Claude Code handles this by loading only the first 200 lines, or 25 KB, of its MEMORY.md index into every conversation and keeping detail in separate topic files that are read on demand.

How much memory actually helped

Related guide: Claude Code 2.1.316: Ultrathink, Pooled Budgets, and What Changed in October

The main evaluation used the database task from Continual Learning Bench 1.0. Each question arrives in a fresh session, and the only thing carried over is a memory directory that persists between sessions. Anthropic reported mean reward for a stateless baseline against the same run with a memory store:

• Opus 5.5: 0.655 stateless, 0.838 with memory.
• Sonnet 5.5: 0.644 stateless, 0.833 with memory.
• Opus 5: 0.564 stateless, 0.828 with memory.
• Opus 4.7: 0.383 stateless, 0.700 with memory.
• Sonnet 5: 0.306 stateless, 0.610 with memory.
• Sonnet 4.6: 0.330 stateless, 0.364 with memory.

Sonnet 4.6 is the instructive failure case. Anthropic says it often did not read files from its memory directory and failed to test its theories about why an answer was wrong. Prompting it to read its memory before answering and then explicitly test its theories nearly doubled its score, to 0.641. The practical lesson is blunt: a memory directory the model never opens is just disk usage, so if an older model looks unmoved by memory, check whether it reads its notes before discarding the idea.

Why fixed memory rules backfired

Related guide: Claude Fable 5.2 and Mythos 5.2: pricing, benchmarks, access

The result most likely to change how you prompt agents is a negative one. Anthropic tested rules about what the model should write down, one rule per test. The rule "record only failures" — which sounds like sensible engineering discipline — cut the memory gain for Opus 5 by 0.234 and for Opus 4.7 by 0.150. Stronger models did better with freedom to judge salience than with fixed rules written in advance.

Anthropic's summary is that it helps to tell Claude what memory is for, but not how to use it. With frontier models, the team says it typically gives simple guidance to create memory notes when a person asks for one or when something is clearly worth remembering, and leaves the judgement to the model. Steering helped older models most: Sonnet 4.6 went from 0.330 to 0.364 with memory alone, and to 0.641 with a refined instruction.

Dreaming corrects what the session got wrong

Related guide: Anthropic's IPO Filing: $895B of Compute Commitments

Because notes are written from a single session's context, they can be wrong from the start or drift as the environment changes — and a later session will read them and trust them. Dreaming is the offline pass that tests notes against the original transcripts.

Anthropic's example comes from a Pokémon Red run on Managed Agents. Claude wrote that a PokéCenter was on the east side of the map, then navigated over a one-way ledge three separate times and eventually gave up. Running dreaming over the memory folder checked the note against the session transcript, caught the error and rewrote it; with the corrected note Claude went back into Mt. Moon and reached Cerulean City at action 1,935, while the raw-memory run never got past the mountain.

Dreaming also fills structural gaps. On one wiki build, a second dreaming pass found nine links pointing to a page that did not exist, repointed them to the correct page, and added three new pages including an index. On another task, changing the build instructions so each agent wrote its own contract page instead of a shared table lifted graded contract facts from 41 of 57 to all 57, because agents were no longer overwriting each other.

Wikis: when a knowledge map beats raw search

Related guide: Nemotron 3.5 Super VL: NVIDIA's 120B Open Model Runs Your Agents Locally

Representations earn their cost only when they help. Anthropic tested a wiki built by dreaming over roughly 350,000 files and about 420 million tokens from an acquired software company's internal documents, with a 25-question evaluation set. As the wiki grew from two dreaming sessions to 128, graded criteria rose from 13% to 48% when the wiki was used alone, and from 54% to 61% when it was combined with a search tool, against 53% for search alone. Using both also saved about 20,000 tokens per question.

On a merger task where most criteria required combining several documents, the wiki scored 87% against 73% for search alone. On a legal-brief task where most criteria could be retrieved from a single document, the wiki showed no clear gain — and in one case the wiki grew larger than the source corpus, 203 KB of pages for a 115 KB corpus, abstracting nothing. Anthropic quotes Borges's mapmaker as the warning about maps that become as big as the territory they describe.

What it means if you run long-lived agents

Related guide: Claude Marketplace and the plugin directory: what changed for MCP builders this week

If you run agents that persist across sessions, the study supports a specific set of moves. Give the agent a memory store, but tell it what the memory is for rather than dictating rules about what to record. Make sure it actually reads the memory before answering, especially on older models. Keep the always-injected layer small and use it as an index into detail held elsewhere. Run a consolidation pass against transcripts rather than trusting notes to stay true, and schedule it — Anthropic notes that dreaming requires compute and that cadence may need tuning, for example by how often memories are accessed.

The Dreams endpoint is the closest thing to a ready-made implementation. It is an asynchronous job that takes a pre-existing memory store and 1 to 100 past sessions, and produces a new output store with duplicates merged and stale or contradicted entries replaced. The input store is never modified, so the output can be reviewed and discarded. It requires the dreaming-2026-04-21 beta header, is billed at standard token rates for the model you select, and typically takes minutes to a few hours depending on how many transcripts you feed it.

Two caveats worth carrying forward. Dreaming output is a synthesis pass, not a text editor — instructions like "fix line X" generally do nothing, so targeted edits belong on the output store's API. And an agent that judges salience poorly will still write notes worth discarding, which is why the research preview label matters: this is a mechanism worth watching, not a settled answer.

Prices and benchmark figures are standard published rates as of November 12, 2026 and can change without notice. Some outbound links may be affiliate links — see our disclosure. Found an error? Tell us and we'll correct it in public.