WritingNovember 10, 2026
Claude's Best Models Did Worse Under Anthropic's Own Memory Rule

Anthropic built a rule telling Claude exactly what to keep in memory. Its most capable models followed the rule — and scored worse for it.
Every agent that runs longer than one sitting hits the same wall: context resets, and whatever it learned yesterday is gone unless something wrote it down first. Most teams solve this by renting a bigger context window or bolting a vector database onto the side. Anthropic's November 6 research post skips both. It splits memory into four layers — transcripts, notes, wikis, and a small injected index — and adds a maintenance step it calls "dreaming," where Claude rereads its own session logs offline and corrects what it got wrong. The headline isn't the architecture itself. It's what happened when Anthropic tried to make that memory more disciplined: the better the model, the worse a fixed rule made it perform.[1] If you run Claude Code on anything longer than one session — a client engagement, a recurring report, an ongoing audit — this is the mechanism deciding what it remembers about your work.
The four layers Claude actually writes to
On Anthropic's own benchmark, giving Claude memory at all lifted its strongest model's score from 0.655 to 0.838 on a database question-answering task.[1] The architecture below is what that memory is actually built out of — a stack a session reads from and writes to, kept honest by a background pass.
Source: Anthropic — The components of agent memory
| Layer | What it holds | Who writes it | Size limit |
|---|---|---|---|
| Transcripts | Raw event log of the session | The session itself | None — full history |
| Memory notes | Salient facts Claude chooses to record | Claude, live, during the session | Grows with use |
| Memory representations (wikis) | Linked pages built from the notes | Claude, during dreaming | Scales but stays navigable — 103 pages/766 links after 2 sessions, 222 pages/12,893 links after 128[1] |
| Injected context | Curated index pointing into the layers below | Claude, during dreaming | Capped — 200 lines / 25KB in Claude Code[1] |
Only the bottom layer is passive. Everything above it is Claude's own editorial judgment about what's worth keeping — and that judgment is exactly what the research went on to test.
"Dreaming" is maintenance, not metaphor
Anthropic calls the offline pass "dreaming" because that's functionally what it does: no user waiting, Claude rereading its own transcripts, fixing notes that turned out wrong, restructuring the wiki layer. In one test run, Claude playing Pokémon wrote a bad note — "PokéCenter was on the east side" — when it was actually west. Without a dreaming pass to catch it, the agent repeated the same navigation failure and fell off a one-way ledge three times, never reaching Cerulean City. With dreaming turned on, a later pass caught the contradiction against the transcript, corrected the note, and the next session reached Cerulean at action 1,935.[1]
sequenceDiagram participant S1 as Session 1 participant Notes as Memory notes participant Dream as Dreaming pass participant S2 as Session 2 (raw memory) participant S3 as Session 3 (memory + dreaming) S1->>Notes: Writes "PokéCenter is on the east side" (wrong) S2->>Notes: Reads the wrong note S2-->>S2: Falls off the ledge 3x, never reaches Cerulean Dream->>Notes: Replays the transcript, catches the contradiction Dream->>Notes: Corrects note to "west side" S3->>Notes: Reads the corrected note S3-->>S3: Reaches Cerulean City at action 1,935
This isn't Anthropic's idea in isolation
The "dreaming" bet — reason offline, before anyone's waiting on an answer — has independent grounding outside Anthropic. A "sleep-time compute" paper from Letta and UC Berkeley-affiliated researchers showed that letting a model pre-process likely-relevant context offline cut test-time compute roughly 5x on modified reasoning benchmarks, with accuracy gains up to 18% as more offline passes were allowed.[2] Anthropic's dreaming pass applies the same bet to memory specifically: do the expensive thinking when nobody's waiting on the answer.
The failure mode dreaming is built to prevent also has a name in the literature. A separate paper this year documented the "compaction cliff" — the point where context compression gets aggressive enough that an agent loses information it actually needed, and performance doesn't degrade gradually, it drops off a cliff.[3] Anthropic's layered approach is one way to avoid hitting that cliff: transcripts never get compressed or thrown away, they just become harder to reach without the index layers built on top of them.
The rule that made the best model worse
Anthropic tried giving Claude a fixed instruction: only record failures, not successes. For a weaker model, that's close to neutral — Sonnet 4.6 dropped a negligible 0.020 points on the benchmark. For the two strongest models tested, the same rule was actively harmful: Opus 4.7 lost 0.150, Opus 5 lost 0.234 — the single biggest swing in the whole study.[1] The better the model got at judging on its own what mattered, the more a rule written in advance got in its way.
That inverts the instinct most operators have about delegating judgment to a model: more structure should mean more consistency. It doesn't, past a certain capability floor. A junior hire benefits from a checklist. A senior one, forced onto the same checklist instead of using judgment, gets worse at the job — same shape of problem, now showing up as a benchmark number instead of an annual review.
The expensive part of agent memory was never storage. It's deciding what's worth keeping — and past a certain model capability, Claude is better at that call than the rule you wrote for it.
Wikis beat plain search by 14 points on real legal work
On Harvey's LAB benchmark — a legal-research task requiring synthesis across multiple documents — Claude answering from a wiki it built itself hit 87% accuracy versus 73% from search alone; combining search with the wiki also saved roughly 20,000 tokens per question versus search alone.[1] The gap isn't "memory helps." It's "structured memory helps more than raw retrieval," against the identical underlying documents. A flat search index finds relevant passages. A wiki the agent already built encodes which passages relate to which, so the model isn't re-deriving the connections on every query.
That's worth separating from the dreaming result above: dreaming corrects memory. Wiki-building structures it. Anthropic's internal-corpus test needed 128 dreaming passes to grow a wiki from 103 pages and 766 links to 222 pages and 12,893 links — and accuracy against graded criteria nearly quadrupled over that growth, from 13% to 48%.[1] This isn't a one-pass feature. It compounds with reuse, the same way a well-maintained internal wiki compounds for a human team and a neglected one doesn't.
What this means for operators
If you run Claude Code on anything spanning more than one sitting, you're already relying on some version of this stack, whether you designed it or not. Claude Code's own memory feature is effectively the injected-context layer: a small file, capped in size, loaded automatically into every session.[1] What Anthropic's research argues is that the file alone isn't the system. The system is that file plus a maintenance habit — periodically having the agent review what it wrote, correct what turned out wrong, and promote what's actually load-bearing into the index.
A minimal version of that index, for a client engagement, looks something like this:
# Memory index (keep under 25KB — this loads into every session)
## Verified facts
- Client's Shopify webhook retries 3x before failing silently — see /notes/webhook-retry.md
## Open questions
- Unconfirmed: does their ERP dedupe on SKU or on order ID?
## Pointers
- Full incident history: /wiki/integration-failures.md
You don't need Anthropic's dreaming infrastructure to get the benefit. You need the discipline it's modeling: don't let notes pile up unreviewed, and don't hand-write a rule for what to remember if the model is good enough to judge that itself. That's the same audit discipline I run on long client engagements — the file isn't the control, the review habit behind it is.
The honest reading of this research isn't that Anthropic solved agent memory. It's narrower and more useful: more structure isn't free, and past a certain model capability, a fixed rule costs you accuracy instead of buying consistency. I've run engagements where what the agent got right in week one still has to hold months later — the Palmer's migration had every AI-touched record logged and re-verified at every stage for exactly that reason, not because the model couldn't be trusted, but because nobody should trust an unreviewed memory, human or AI. Anthropic just gave that instinct a benchmark.
Sources
[1] Anthropic — The components of agent memory — anthropic.com [2] Lin et al., UC Berkeley — Sleep-time Compute: Beyond Inference Scaling at Test-time — arxiv.org [3] Zerhoudi, Mitrovic, Granitzer — The Compaction Cliff in Long-Running AI Agent Memory — arxiv.org
The short version
- Anthropic splits Claude's memory into four layers — transcripts, notes, wikis, and a capped "injected context" index — maintained by an offline "dreaming" pass.
- Dreaming caught and fixed a wrong note in a Pokémon test run that had cost three failed ledge attempts; the corrected run reached Cerulean City at action 1,935 where the uncorrected one never did.
- A fixed memory rule ("only record failures") hurt the strongest models most — Opus 5 lost 0.234 points, more than 10x Sonnet 4.6's 0.020 drop — evidence that more structure isn't free once a model is good enough to judge salience itself.
- On a legal-research benchmark, Claude answering from a self-built wiki hit 87% accuracy vs. 73% from search alone; combining search with the wiki also saved roughly 20,000 tokens per question.
- Claude Code's existing memory feature is effectively the injected-context layer — the research argues the file needs a review habit behind it, not more rules in front of it.
Drafted with Claude, reviewed and edited by Bryan before publish.
