Anthropic Reveals Claude's Four-Layer Memory Architecture with Dreaming Correction

Anthropic's research team has publicly released "The components of agent memory," the first systematic disclosure of Claude's internal long-term memory architecture. For teams building long-horizon agents, cross-session state persistence and memory durability remain the most critical bottlenecks. Common engineering approaches — either appending full prior conversations to context or dumping chunked history into a vector database — quickly fill context with trivial details and can mislead models with their own erroneous notes, causing infinite loops.

Two Defects of Traditional External Memory

1. Recording Every Detail Drags the Model Down

Many developers assume more detailed memory yields stronger agents. In long-horizon dynamic environments this assumption fails. Anthropic ran a striking contrast experiment using Pokémon Red . Early model Sonnet 3.7 recorded every wild battle, item pickup, and NPC dialogue as separate files. By ~10,000 steps it had created 413 files across 225 folders, consuming 977,930 characters. This massive memory became a liability: as the game environment evolved, fine-grained records rapidly expired. Around step 10,000 Sonnet 3.7 created its 4th main memory directory; in the next 17 steps it created 6 files and deleted 9, spending all compute and context on note-keeping with zero effective game actions , ultimately earning only 1 gym badge.

In contrast, the more mature Fable 5 kept only 10 files (43,406 characters) and earned 4 badges; subsequent Opus 5.5 used a similarly compact strategy and cleared the game. Memory is never a free asset — it is a high-interest liability. Unfiltered logging burns tokens and dilutes attention, trapping agents in a "note-taking for note-taking's sake" deadlock.

2. One Wrong Note Triggers Cascading Session Collapse

The second sin of online recording: generated notes inevitably contain subjective bias or factual errors. In the Mt. Moon mission, a one-way ledge near the cave entrance drops the player back to the start. In one session Claude incorrectly noted "Pokémon Center is on the east side of the cave." Exiting the cave, it trusted this false note, concluded Mt. Moon was complete, jumped off the ledge, and reset. Worse, navigation tools couldn't perceive elevation change, so Claude doubled down on the error. In subsequent sessions, every new agent unconditionally trusted the corrupted note, causing three consecutive falls at the same ledge before abandoning the task entirely. This phenomenon — cascading collapse of erroneous memory — shows how a single uncorrected long-term memory entry can infect all future independent sessions like a virus.

What Should Agents Actually Remember?

1. Record Only Latent Rules, Not Volatile Facts

Anthropic draws a critical distinction: Volatile Facts (Ephemeral Facts) — e.g., current NPC coordinates, remaining potions, current DOM structure — are visibly on screen and constantly refreshing. Storing them in long-term memory adds no value; re-observing the screen is cheaper and more accurate than retrieving potentially stale records. Latent Rules & Strategy Models (Latent Rules) — e.g., "never jump the right ledge after exiting this cave," "this API requires a lock under concurrency," "this class of errors stems from a missing env var" — cannot be read from a single frame; they must be distilled from multi-session exploration, collision, and failure. True long-term memory should carry only the second category.

2. Don't Constrain Strong Models with Rigid Prompts

Many teams enforce rigid prompt rules like "never record coordinates" or "only record failures." CL-Bench experiments reveal a counter-intuitive warning: such rigid rules hurt strong models. When researchers imposed strict restrictive prompts on powerful Opus 5 (forcing it to record only failures), average reward plummeted from 0.828 to 0.594 — a net loss of 0.234 . Conversely, giving directional guidance (prompt to read memory then verify hypotheses) nearly doubled scores for weaker early model Sonnet 4.6, while stronger models like Sonnet 5 autonomously accessed memory at high frequency without prompting. This reveals a core architectural philosophy: the stronger the model, the less the system should lock down its recording behavior with hard-coded rules. Strong models excel at weighing contextual salience; engineering should provide layered storage containers and post-hoc self-healing pipelines, not make decisions for the model.

Claude's Four-Layer Memory Pyramid

After solving "what to record," the core question becomes storage structure. Anthropic formally discloses Claude's internal memory layering model — not a flat vector store but a strict four-layer pyramid :

Bottom Layer: Raw Execution Transcripts — Lossless record of full conversation history, tool calls, parameters, execution results, and environment feedback. The sole ground truth of the system, supporting keyword and full-text search.

Second Layer: Memory Notes — Salient events autonomously tagged or written by Claude during each session. Records local lessons from a single task, typically as flat Markdown notes.

Third Layer: Knowledge Map & Network (Wiki / Knowledge Representation) — The most productive layer. Offline compute abstracts, generalizes, and cross-links fragmented notes into a structured Markdown Wiki network.

Top Layer: Injected Context at Session Start — Ultra-lightweight summary preloaded into context at new session launch. Contains no massive detail; serves as top-level metadata navigation.

This layering radically improves memory utilization efficiency. In the Stainless codebase benchmark, letting agents search tens of thousands of raw transcripts often consumed 10,000+ tokens per query with unstable recall. Anthropic had Claude continuously distill learned patterns into a structured Markdown Wiki over 128 interactions. The Wiki evolved from a few isolated pages into a multi-level directory with bidirectional cross-links and explicit architectural specs. Quantitatively: when agents consulted this compact Wiki with search tools, cross-corpus QA accuracy rose significantly while average per-query blind retrieval cost dropped by ~20,000 tokens.

Offline Dreaming: The Agent's Nightly Correction Mechanism

Even with the four-layer pyramid, a single erroneous note can still cause collapse (as in the Mt. Moon disaster). During online interaction the model expends all compute on the immediate task, lacking capacity for global review and prone to recording biased conclusions under local pressure. To close the loop, Anthropic introduces "Offline Dreaming" — a self-auditing and evolution engine inspired by cognitive neuroscience: human hippocampus performs high-frequency offline replay during slow-wave and REM sleep, replaying, pruning, and denoising daytime short-term memories into cortical long-term structures.

Dreaming provides three indispensable engineering properties:

1. Overturn Online Errors Against Bottom-Layer Transcripts

Online notes are merely a perishable secondary cache . During Dreaming, a dedicated judge model pulls the raw, unadorned execution transcripts. After the Mt. Moon failure, researchers triggered Dreaming; the judge compared actual movement coordinate transcripts with upper-layer notes and immediately caught the contradiction: "Notes claim Pokémon Center east of cave, but transcripts prove exiting east leads to cliff reset." Dreaming deleted the false note and rewrote it: "After crossing Mt. Moon, do NOT jump right cliff; must return into cave and proceed north." In subsequent long-horizon testing on Cerulean City, the Dreaming-corrected agent crossed Mt. Moon at step 1,935 and reached Cerulean City; the uncorrected control group fell three times at the same ledge, retreated to Pewter City, and failed.

2. Automatic Topological Repair & Deduplication

Beyond factual correction, Dreaming acts as "knowledge map gardener." As the Wiki expands, broken links and orphan pages inevitably appear. In a second Dreaming pass, the model traverses the entire Markdown Wiki, scans all referenced but uncreated filenames, auto-generates missing pages from history, merges repeatedly validated temporary lessons into general specs, and prunes expired temporary records.

Claude Code Production Deployment Practices

Many papers describe lavish architectures that collapse in production under latency, token cost, and fragile context management. Anthropic shares real engineering decisions when deploying this architecture to production tools like Claude Code.

1. Load Only First 200 Lines: Top Layer as Index, Bottom Layer as Warehouse

Developers often stuff accumulated memory files into the system prompt. In production, overlong preloaded instructions cause cliff-like drops in core task adherence and multiply first-token latency and cost. Claude Code uses a hardcore truncation design: at session start it never loads the full MEMORY.md ; instead it strictly loads only the first 200 lines or 25 KB of text . These 200 lines serve purely as a table of contents — telling the model which module knowledge it possesses and where details reside in the bottom-layer warehouse. When the model later needs a specific spec, it uses the index to launch on-demand retrieval via local tools. Top layer does indexing, bottom layer does storage — resolving the tension between context capacity and information completeness.

2. Three Engineering Trade-offs in Production

Write-timing trade-off (online capture vs. offline curation) : Online recording captures salient events in the moment but consumes precious context bandwidth; offline Dreaming shifts curation cost to background but requires extra offline compute and cannot feed back into the current turn.

Memory drift & obsolescence maintenance (periodic pruning vs. full accumulation) : Long-term memory is not a write-only cold store. As business environments and codebases evolve, stale notes mislead future agents. Systems cannot endlessly full-scan history; they need access-frequency and confidence-decay mechanisms to periodically anneal and evict obsolete memories.

Retrieval vs. representation balance (lightweight index vs. deep knowledge graph) : Pure raw-transcript search loses models in massive fragments; maintaining a perfectly structured Wiki demands continuous heavy Dreaming compute. Anthropic's practical compromise: lightweight Markdown index combined with bottom-layer chunked retrieval, balancing accuracy and engineering overhead.

The essence of production-grade agent memory is not building an all-swallowing trash can, but performing precise subtraction at every stage.

Three Foundational Principles for All Developers

Never blindly trust intermediate memory; always preserve the raw ground truth. Memory notes are a fragile secondary cache. No matter how upper structures change, the unprocessed raw execution transcripts must be archived losslessly — they are the only self-healing handle when cascading collapse occurs.

Top layer does indexing, bottom layer does warehousing. Don't fantasize about injecting all experience into initial context. Top layer holds only a refined miniature index; concrete rules and knowledge sink to the bottom, retrieved on-demand via the index.

Give strong models goals, not rigid hard-coded rules. Strong models excel at complex contextual understanding and salience weighting. Instead of constraining what they should or shouldn't record with brittle hard-coded rules, invest energy in building stable layered storage and offline auditing loops.