Claude Agent Memory Explained: How Anthropic’s “Dreaming” Fixes What Claude Remembers

Claude agent memory is Anthropic’s answer to one of the oldest problems in artificial intelligence: how does an AI assistant remember what it learned yesterday? On November 6, 2026, Anthropic published a detailed engineering post, “The components of agent memory,” that explains how Claude keeps knowledge between sessions — and introduces a process the company calls dreaming, in which Claude rereads its own logs while idle, corrects notes that turned out to be wrong, and builds linked wiki pages from what it has learned.

This guide explains what Claude agent memory is, how the four layers of the system work, what the test results actually show, and how developers and Claude Code users can put the ideas to work today.

What Claude Agent Memory Is

Claude agent memory is the knowledge Claude gains from experience — from working with users and completing tasks — that it keeps between sessions in files it can read again later. That definition matters, because Anthropic is careful about what counts as memory and what does not. Memory is not a change to the model’s weights, the internal parameters set during training.

It is not in-context learning, the knowledge a model picks up inside a single conversation. And it is not compaction, the summary Claude writes to replace older turns so it can keep working in a new context window. Claude agent memory is something more practical: a folder of files that persists after a session ends, so the next session can start from what the last one learned.

The problem this solves is easy to see in everyday use. Without memory, every new session starts from zero. An agent that spent an hour learning your codebase, your naming conventions, or the quirks of your database has to relearn all of it the next time you talk to it.

With memory, the lessons survive. A rule discovered on Monday — “this table stores dates as text, not timestamps” — is still there on Friday, ready to be used without being rediscovered. That is the promise of Claude agent memory, and it is also the risk: a wrong lesson, written down once and trusted forever, can mislead every future session until something corrects it.

Anthropic’s post, written by Lance Martin and published on the company’s engineering blog on November 6, 2026, is the most complete public account of how the company thinks about this problem. It describes the four-layer stack, reports benchmark results from a database task and a months-long Pokémon Red run, and tests a wiki-building experiment on a corpus of roughly 350,000 internal files.

Every figure in the post comes from Anthropic’s own experiments — there is no independent evaluation yet — so this guide labels the numbers as company-reported throughout. What makes the post valuable is not the size of the gains but the honesty about where the system works, where it fails, and which design choices made the difference.

Claude agent memory — a developer working late at night with code on multiple screens

The Four Layers of Claude Agent Memory

Anthropic organises Claude agent memory into four layers, stacked from the rawest record at the bottom to the most distilled knowledge at the top. Each layer trades detail for density: the lower layers keep everything, the upper layers keep only what has earned its place.

Understanding the stack is the key to understanding everything else in Claude agent memory, because dreaming — the offline process at the heart of the system — is mostly about moving information between these layers and keeping each one honest. Anthropic has been building out Claude’s ability to run many agents at once, as our guide to Claude dynamic workflows explains, and memory is what lets those agents carry knowledge from one session to the next instead of starting over.

Layer 1: Transcripts — the Raw Record

At the bottom of the stack sit the transcripts: the unprocessed record of everything an agent said, saw, and did in a session. Every tool call, every file read, every answer given, in order. Transcripts are the source of truth for Claude agent memory, because they are the only layer that records what actually happened rather than what the agent concluded about it.

They are also the layer Claude searches when it needs to check whether a note is still true. The cost of transcripts is obvious — they are long, they grow with every session, and reading them all would burn through a context window fast. So transcripts are kept as a record to consult, not as something loaded by default.

Layer 2: Memory Notes — Distilled Observations

Above the transcripts sit memory notes: short, distilled observations the agent writes during a session. A note might record a verified fact (“the staging database resets every night at 2 a.m.”), a rule learned from a mistake (“never run migrations without a backup — the last one failed”), or a warning about a trap (“the API returns 200 even when the request fails — check the response body”). Notes are written in the moment, when the agent judges something salient.

That judgment is the hard part. As Anthropic puts it, a note is a prediction: by writing down a rule, the agent predicts that the pattern it describes will be relevant again. A good prediction saves future work. A bad one — a guess recorded as fact, or a rule that was true once and never again — becomes a liability that later sessions will trust.

Layer 3: Representations — Wikis and Other Structures

The third layer holds representations: structured knowledge built from many notes and sessions. The main example in the post is a wiki — a collection of linked pages, written and maintained by Claude, that gathers what it knows about one subject and connects it to related notes. Links between pages act as a map, letting Claude move through its memory efficiently instead of searching blindly.

A wiki is more useful than a pile of notes when knowledge spans many documents: instead of re-reading dozens of files to answer a question, Claude can follow the wiki’s links to the pages that matter. But a wiki also costs compute to maintain, and — as the experiments show — it can grow so detailed that it stops abstracting anything at all.

Layer 4: Injected Context — What Loads Every Time

At the top of the stack is injected context: a small block of notes and wiki entries that loads automatically at the start of every session, without any retrieval step. This is the most valuable real estate in Claude agent memory, because it is always there — Claude does not need to know something exists before it can use it.

It is also the most dangerous, because an incorrect note promoted to this layer travels into every session, and because every token loaded here costs tokens in every session. The post’s central design rule is that this layer must stay small. In Claude Code, the equivalent is the auto-memory file MEMORY.md: only its first 200 lines or 25 KB load at session start, serving as an index that points to the rest.

Claude agent memory — a data centre corridor with rows of server racks

Dreaming Explained: Why Claude Sleeps on Its Notes

The most striking idea in Anthropic’s post is dreaming: an offline process in which Claude, between sessions, rereads its logs, tests its notes against the original transcripts, fixes mistakes, builds new representations such as wikis, and decides which notes deserve promotion to the always-loaded layer. The name is deliberate.

In the human brain, the hippocampus captures experiences quickly as they happen, but only some are consolidated into long-term knowledge — and much of that consolidation appears to happen while we sleep, when the hippocampus replays recent experiences and gradually distils them into the neocortex. Anthropic opens its post with Kierkegaard’s line that life can only be understood backward but must be lived forward, and the parallel is exact: an agent lives forward, writing notes in the moment, and understands backward, when dreaming gives it time to look at what it actually did.

The idea of using idle time this way is not Anthropic’s invention. Researchers at Letta and UC Berkeley proposed “sleep-time compute” — using the gaps between interactions to reorganise a model’s existing context — and Anthropic credits them in the post. What Anthropic adds is a working system and a set of measurements.

Dreaming became available as a research preview on Claude Managed Agents in May 2026, and the November post pairs that release with benchmark data and experimental evidence from a months-long Pokémon Red trial and a 350,000-file company corpus. Developers trigger dreaming through the Dreams API, using two beta headers, and the output goes to a separate output store so the original memory is never overwritten blindly. Dreaming is billed at the standard token rate of the model used, and it is not eligible for zero-data-retention or HIPAA workloads — a practical limit for regulated industries.

In the Claude agent memory system, dreaming performs three distinct jobs. First, it extracts new memory notes from recent sessions — observations about user preferences, recurring patterns, errors the agent made, and corrections it received. Second, it builds or updates wiki entries by synthesising information across the notes and session histories accumulated so far.

Third, it promotes selected notes and wiki entries to injected context, so the most reliably useful knowledge reaches the top layer and loads at every future session start, with no retrieval overhead. Each job matters on its own, but the first is the one with the clearest payoff: a note written in the moment can be wrong, and only a later pass against the transcript can catch it.

The Test Results: What Claude Agent Memory Actually Improved

The headline numbers for Claude agent memory in Anthropic’s post come from CL-Bench 1.0, a Continual Learning Benchmark that tests an agent’s ability to absorb rules from past errors and apply them correctly in a long-horizon task. In the database task Anthropic used, Claude answered a series of questions by looking up information in a database. After each answer it was told the correct solution and could write a memory to help with future questions.

Each question started in a fresh session, with one exception: a persistent memory directory carried over from one session to the next. The question was simple — how much does memory help, and which models use it well?

The answer was that memory helped every model tested, but the size of the gain depended on how well the model used it. Claude Opus 5.5 rose from a mean reward of 0.655 without memory to 0.838 with it. Claude Sonnet 5.5 went from 0.644 to 0.833.

Claude Opus 5, which started lowest at 0.564, reached 0.828 — the largest jump of the three. These are Anthropic’s own figures, from its own benchmark, and they should be read as evidence that the memory loop works in this controlled setting, not as a guarantee of the same gain on real work.

Anthropic has been publishing this kind of self-measurement across its research programme — see our coverage of the METR report on AI accelerating AI research for the wider picture — and the pattern here is instructive: the models that gained most were the ones that closed the learning loop — recording a rule, noting how they knew it was true, and adding warnings about traps they had found.

Earlier models did not close that loop. Claude Sonnet 4.6 generated theories about why an answer was wrong, but its memory folder ended up as a scattering of files, each listing several untested guesses. Claude Opus 4.7 did better, consolidating its notes into a single reference document and marking which facts it had checked and which were still unconfirmed.

Claude Sonnet 5 marked each answer as confirmed after the grader had checked it and wrote a correction when it had answered wrong. Claude Opus 5 was the first to do the whole job: most of its entries included a rule, the evidence for the rule, answers to earlier questions, and clear warnings about traps discovered along the way. Opus 5.5 and Sonnet 5.5 closed the loop too, scoring about the same as Opus 5 with memory, though their starting scores without it were slightly higher.

Anthropic also tested how much steering helps. The most useful line in the whole post is a design rule, not a benchmark: “We’ve found that it helps to tell Claude what memory is for, but not how to use it.” When the team gave models specific rules about what to write down — one rule per test — the results were revealing. Telling Opus 5 and Opus 4.7 to “record only failures” cost them much of the performance boost memory had given them.

Fixed rules about what to save weakened the strongest models, because they took away the judgment that made memory useful. Steering helped older models the most. Sonnet 4.6 often failed to read its memory files at all and did not test its theories; prompting it to read memory before answering and then explicitly test its theories nearly doubled its benchmark score.

Sonnet 5, by contrast, read its memory before answering 9 times out of 10 without being prompted, while Sonnet 4.6 did so less than half the time. The lesson for anyone building agents is direct: give the purpose, not a checklist — and give weaker models more explicit prompts to consult what they have already learned.

Pokémon Red: The Test That Shows Judgment Matters

The most entertaining experiment in the Claude agent memory post is also the most revealing. Anthropic had Claude play Pokémon Red, the classic Game Boy game, as a test of long-horizon judgment — specifically, judgment about what is worth saving to memory. Each model started with a folder of memory files it could read from and write to while it played. The comparison, at about 10,000 steps into the game, could hardly be starker.

Claude Sonnet 3.7 wrote 413 memory files across 225 folders and earned one badge. Claude Fable 5 wrote nine files in two folders, plus a single top-level file called global.md, and earned four badges. Opus 5.5 kept a small folder of goals and next steps, rewrote it as it played, and beat the game.

The difference was not effort but judgment. Sonnet 3.7 assumed everything might matter and wrote to memory indiscriminately — a separate file for each battle fought, each item found, each character met. The problem was that the game state changes constantly, so its detailed record went out of date almost as fast as it was written. Around step 10,000, Sonnet 3.7 started its fourth folder of “master” memory files; over the next 17 steps it created six files, deleted nine others, and took no actions in the game itself.

It was spending its turns maintaining notes instead of playing. Fable 5, by contrast, saved memory for things the game did not tell it directly. How much money the player has, or where the player is on the map, can be read off the screen every turn, so storing that is redundant.

Strategy, plans, and tested rules exist only if Claude works them out — and they disappear unless it writes them down.

Fable 5 organised its memory accordingly. Its global.md acted as a dashboard, holding the current goal, a prewritten plan for tackling gyms — the challenges where badges are won — and the model’s own rules for using memory. A locations folder held plans for navigating particular routes, and a gameplay folder held strategies based on what it had learned about how the game works.

One example shows the quality of the learning: after seven Poké Balls in a row failed to catch a Magikarp, one of the easiest Pokémon to catch, Claude wrote, “If 3+ balls fail in a row, VARY the timing (insert extra ‘wait’ presses between menu steps) — the catch landed right after doing this.” That is a tested rule, with its evidence attached — exactly the kind of note the CL-Bench results showed the strongest models writing.

The Pokémon comparison is one run per model, not a statistical result, and Anthropic says so. But as a demonstration of what good memory judgment looks like — save the conclusions, not the raw data — it is hard to beat.

Claude agent memory — an open notebook with handwritten notes and coffee on a wooden desk

How Dreaming Fixes Wrong Memories

The strongest case for dreaming comes from a single mistake. In the Pokémon run, Claude had to get through Mt. Moon, a cave system with its entrance on the west side of the map and its exit on the east. Near the entrance is a trap: a one-way ledge that drops the player back onto the route they came from, with no clear way to climb back up.

Claude was using the PokéCenter, a building at the mountain’s entrance, as a landmark — so whether it walked off the ledge depended on which side of the mountain it thought the PokéCenter was on. At one point Claude wrote down, incorrectly, that the PokéCenter was on the east side. Walking out, it announced “Mt Moon is behind me” and updated its notes: “Mt Moon DONE.” But Mt. Moon was not behind it.

A few actions later Claude went over the ledge and landed back on the route it had come from. Its navigation tool did not show the drop, so Claude concluded it had overshot far west and had been on the correct side all along. It had not.

In the run with the uncorrected note, Claude dropped back onto that earlier route three times. After the third failure it seemed to give up, writing, “I’m going to stop rather than keep looping.” Its setup’s automatic reply told it to continue, so it did — all the way back to Pewter City, the town before the mountain, where it hoped to heal and restock. The run ended without Claude ever reaching Cerulean City.

Then Anthropic ran dreaming on the memory folder that contained the wrong location. Claude checked the note against the session transcript, caught its error, and rewrote it. The transcript gave Claude a ground truth to validate its memory against. With the corrected note, Claude went straight back into Mt. Moon and eventually reached Cerulean City.

That is the case for dreaming in one story: a note written in the moment can be wrong, and a later session will trust it — unless an offline pass checks the note against what actually happened.

The same principle applies far beyond a game. In real Claude agent memory deployments, a wrong note is worse than no note, because the agent acts on it without re-checking. A database credential recorded with a typo, a deployment step remembered in the wrong order, a client’s preference noted backwards — each one gets replayed in session after session until something catches it.

Dreaming is Anthropic’s answer: keep the transcript, because the transcript is the record that lets an offline pass test memory against reality. It is also a reminder that memory systems need maintenance, not just storage. Writing notes is only half the job; the other half is going back, checking them, and fixing the ones that drifted.

Wikis: When Claude Agent Memory Helps — and When It Does Not

The second major experiment in the post tested whether a wiki — the third layer of Claude agent memory — actually helps Claude answer questions about a large body of documents. Anthropic used a corpus of internal documents, about 350,000 files and roughly 420 million tokens, from Stainless, a software company it acquired in May 2026. It created an evaluation set of 25 questions about this corpus, gave Claude a search tool to explore it, and also instructed Claude to build a wiki from the files using dreaming.

Over 128 sessions, Opus 5 agents explored the files, wrote or corrected linked wiki pages, merged duplicates, and checked claims against the sources, coordinating through a shared log. Each session built on the progress of the ones before it, like a new employee gradually learning the company — and, Anthropic notes, like a seasoned employee as the wiki grew richer.

The results were strong but not unconditional. Using the wiki alone, Claude’s score on the 25 questions grew from 13% of graded criteria after two dreaming sessions to 48% after 128. The wiki helped most when paired with search: search plus wiki rose from 54% to 61% as the wiki grew, compared with 53% for search alone, and using both saved about 20,000 tokens per question.

On merger questions that needed information from several documents, the wiki scored 87% against 73% for search alone. But the wiki did not always help. On one legal-brief task in the Harvey LAB benchmark, where most criteria could be found in a single document, it showed no clear gain over search.

And on another LAB task the wiki grew larger than the documents themselves — Anthropic compares it to the mapmakers in Borges’s short story “On Exactitude in Science,” who drafted a map so detailed it was as large as the empire it represented. A wiki that abstracts nothing is not a representation; it is a copy.

The most instructive part of the Claude agent memory wiki experiment was what happened when several agents wrote to it at once. One LAB task simulated a company acquisition and asked Claude to generate a legal brief graded on whether it correctly described the contract terms. While the wiki was being built, several agents wrote to a shared table of contract terms at the same time.

The result was a wiki missing key facts: when Claude generated a brief from it, only 41 of the 57 facts — 72% — were included. The shared table summarised the contract terms poorly and missed some altogether, because agents had overwritten one another’s work. Anthropic then ran a loop in which Claude reflected on its failures, proposed a change to the instructions, and rebuilt the wiki.

The improved version gave each contract its own page, written by a single agent, quoting the terms word for word rather than summarising them into a shared table. The brief generated from that wiki met 100% of the criteria, up from 72%. The lesson generalises well beyond wikis: when several agents share memory, structure matters more than volume. Give each writer its own page, quote the source rather than summarising it, and let reflection fix the instructions when the output is wrong.

Dreaming also filled gaps that a single session could not see. When building wikis for the LAB benchmark, Claude sometimes linked to pages that had not yet been created. A second dreaming pass closed many of these gaps: on one task it found nine links to a missing page and repointed them to an existing page for the same document, and added three new pages, including an index, to improve the wiki.

This is the quiet, unglamorous work that makes a memory system usable over months rather than days — repairing links, merging duplicates, pruning what is stale. None of it requires a smarter model. It requires time between sessions and a process that spends that time on the memory itself.

Claude agent memory — a team collaborating around a whiteboard covered in notes

Keep the Top Layer Small: The Claude Code MEMORY.md Rule

For most readers, the most immediately useful part of the Claude agent memory post is not the benchmark table but the rule about the top layer. Dreaming can promote notes up the memory hierarchy, and the agent harness can load them into Claude’s context at the start of every session — so Claude does not need to search for them, or even to know there is something to search for. That sounds like pure upside, and it is not.

Promoting a memory into a new session is a form of context injection, and it must be done carefully. Injected memories use up valuable tokens, and an incorrect note can be carried into every session. Loading a note also does not guarantee Claude acts on it: Anthropic’s own documentation warns that longer instruction files reduce adherence.

So the top layer of the memory hierarchy has to stay relatively small, and much of dreaming’s work is keeping it that way — moving some details down the hierarchy and leaving links behind.

Claude Code’s auto memory follows the same rule, and it is the part of the system ordinary users can see directly. Claude maintains its auto memory during the session, but it does not load all of it into every session’s context window. It loads only the first 200 lines or 25 KB of MEMORY.md. That header works as an index, showing Claude what it knows and where to find it.

The practical advice follows from the design: put the most important facts, rules, and pointers at the top of your MEMORY.md, and keep the detail in linked files below. A bloated top layer does not just waste tokens — it makes Claude less likely to follow the instructions that are actually in there. If you use Claude Code, this is the single most actionable finding in the whole post.

Treat the top of your memory file as a dashboard, not an archive: current goal, next steps, the handful of rules that must never be forgotten, and links to everything else.

The same logic explains why Anthropic’s steering advice matters. Telling a strong model exactly what to write down weakens it, because fixed rules replace judgment. But telling it what memory is for — so that future sessions can pick up where this one left off, without relearning what has already been learned — gives it a purpose to optimise for.

The models that performed best in the tests were the ones given freedom to judge salience for themselves, with the guardrail that their notes would be checked later by dreaming. That combination — freedom in the moment, correction afterwards — is the design pattern the whole post points toward.

How to Use Claude Agent Memory Today

So what can a reader actually do with Claude agent memory, on November 15, 2026? The honest answer depends on which Claude surface you use, because dreaming is not a general Claude feature yet. It is a research preview on Claude Managed Agents, available by request, with beta headers, and it is not available in the consumer Claude app.

The November post describes research setups on Managed Agents and Claude Code’s auto memory; it does not announce dreaming as a product for everyone. That said, the ideas in the post are usable right now in three places, and the post’s own cookbooks — for getting started with dreaming and for building knowledge wikis — are the starting point for developers.

If you build on Claude Managed Agents, memory stores and dreams are the surfaces to explore. Memory stores hold the notes and transcripts between sessions; the Dreams API runs the offline pass that extracts new notes, builds or updates wiki entries, and promotes the best of them to injected context.

You will need the two beta headers (managed-agents-2026-04-01 and dreaming-2026-04-21), and you should know the costs up front: dreaming is billed at the standard token rate of the model you pick, so a large memory store costs real money to dream over, and neither memory stores nor dreams are eligible for zero-data-retention or HIPAA workloads. Start small — one agent, one memory store, a handful of sessions — and watch which notes dreaming promotes before you scale up.

If you use Claude Code, the system is already in your hands, in the form of auto memory. Claude Code agents now do genuinely long-horizon work — Claude itself found the critical Xen hypervisor vulnerability XSA-523 — and memory is what lets that kind of multi-session investigation keep its findings. Claude writes to MEMORY.md during your sessions, and the first 200 lines or 25 KB load at the start of each new one.

The post gives you a clear playbook: keep that header short and current, put your project’s durable facts and hard rules at the top, and let the rest live in linked files. When you correct Claude, say so plainly — a correction is the raw material of a good memory note. And when something important changes, update the note yourself rather than waiting for the system to notice.

Claude Code’s memory is a collaboration: the model maintains it, but you are the editor-in-chief.

If you use Claude Duet, the personal assistant Anthropic has been building, memory is organised around the person it helps — and dreaming can be tuned to build memory in service of a particular goal, such as knowing your preferences, your projects, and your recurring tasks. Duet is the product where this research is most likely to reach ordinary users first, because a personal assistant that forgets everything between conversations is barely an assistant at all.

The post mentions Duet explicitly as the case where goal-shaped memory matters most, and it is worth watching whether dreaming ships there next.

Whichever surface you use, the post’s four practical lessons carry over to any agent that works across many sessions. First, give the purpose, not a checklist: tell the agent what memory is for and let it judge what to save. Second, keep the record: dreaming only works because the transcript exists to check memory against, so do not delete logs you may need to validate notes.

Third, keep the top layer small and link downward: what loads every time should be an index, not an archive. Fourth, structure shared memory: if several agents write to one store, give each its own page and quote sources rather than summarising them into a shared table.

Claude agent memory — a developer wearing headphones working on a laptop in a dim office

What Dreaming Cannot Do Yet

For all its promise, the Claude agent memory post is candid about what is not established — and a fair guide should be too. First, product availability is limited. Dreaming is a research preview on Managed Agents, gated by a request form, and the post does not announce it as a general feature. Claude Code users get auto memory, not dreaming.

Second, cost is unmeasured. The post gives no figures for how much offline compute dreaming uses per session, and on a large memory store the bill could be significant — the 350,000-file corpus experiment ran 128 dreaming sessions, which is a lot of tokens. Third, all comparisons are between Claude models. There is no head-to-head with another lab’s memory system, so the results say Claude’s approach works for Claude, not that it is the best approach in the industry.

There are deeper open questions too. One is when Claude should create memory at all. Writing notes in the moment captures salience at the source and makes important details immediately available — but it draws Claude’s attention away from its main task, as the Pokémon run showed when Sonnet 3.7 spent 17 steps maintaining files instead of playing. Dreaming can push memory creation to the background, but its outputs may not be immediately accessible.

Another question is how to keep memory reliably up to date. Claude can write rules that are wrong from the start, and memory can drift as the environment changes. Dreaming is one way to fix these mistakes, but it requires compute, and continuously checking every memory may not be practical. Anthropic suggests focusing dreaming on information that is likely to change, and tuning its cadence based on how often memories are accessed.

A third question is whether transcript search should be the foundation of memory after all. Combining representations like wikis with search can be effective, but maintaining those representations costs compute and risks accumulating errors or hallucinations. The post ends where good research should: with the admission that memory systems will evolve as Claude gets more capable, and that there is still a lot to learn about designing them.

It is also worth stating plainly what dreaming is not. It does not give Claude a human-like memory, and it does not mean Claude “learns” in the way a person does. The model weights do not change. What changes is a folder of files that Claude reads at the start of a session.

That is a real capability with real limits — and the limits are part of the story. A wiki that scored 48% after 128 sessions still got 52% wrong. A memory system that needs 128 offline passes to build a useful wiki is not free. And a note that dreaming promotes to every session can still be wrong. The honest framing is that Claude agent memory is a practical engineering system with measured gains and known failure modes, not a solved problem.

Claude Agent Memory vs Other Approaches

It helps to place Claude agent memory beside the alternatives developers already use. The most common is retrieval-augmented generation — RAG — where an agent searches a vector database or document store at query time and pulls in whatever looks relevant. RAG is powerful and well understood, but it has a weakness the Anthropic post highlights indirectly: the agent must know what to search for.

Injected context, the top layer of Claude agent memory, solves that problem by loading the most important knowledge without any retrieval step at all. The wiki experiment shows the two working best together — search plus wiki scored 61% against 53% for search alone and used about 20,000 fewer tokens per question. Memory and search are complements, not substitutes.

Fine-tuning is the other alternative: baking knowledge into the model weights themselves. It is expensive, slow, and hard to undo — a wrong lesson baked into weights is far harder to correct than a wrong note in a file. Claude agent memory is the opposite bet: keep the model fixed, keep the knowledge in files, and let dreaming revise the files. That makes memory editable, auditable, and cheap to fix.

The trade-off is that file-based memory depends on the model’s judgment about what to save and what to retrieve, and that judgment is imperfect — as the Sonnet 3.7 Pokémon run showed in embarrassing detail. Other approaches exist too, including dedicated agent-memory products such as vector databases built for agents, but Anthropic’s contribution is not a new database. It is a design: four layers, a dreaming pass that maintains them, and measurements showing which parts earn their keep.

The Verdict

Anthropic’s November 6 post does something rare for a company blog: it explains a real system, shows its working, admits where it fails, and gives readers something they can use on Monday morning. The four-layer model — transcripts, notes, wikis, injected context — is a clear mental map for anyone building agents that work across sessions.

Dreaming is the genuinely new idea: an offline pass that treats memory as something to maintain, not just store, and that can catch a wrong note by checking it against the transcript that recorded what actually happened. The numbers, all company-reported, are encouraging without being miraculous: CL-Bench gains of roughly 0.18 to 0.26 in mean reward, a wiki that went from 13% to 48% over 128 sessions, and a Pokémon run that turned one corrected note into the difference between reaching Cerulean City and giving up in Pewter City.

The most useful takeaway is not a feature but a discipline. Keep your transcripts, because they are the only ground truth your memory can be checked against. Tell your agent what memory is for, not how to use it, and let the strongest models judge salience for themselves. Keep the always-loaded layer small — 200 lines or 25 KB in Claude Code — and let it be an index, not an archive.

And when several agents share a memory, give each its own page and quote the source. Dreaming may still be a research preview, but those rules work today, in any agent system, with any model. That is why this post matters: it is not just a description of how Claude remembers. It is a manual for how any agent should.

FAQs About Claude Agent Memory

What is Claude agent memory?

Claude agent memory is the knowledge Claude gains from experience that it keeps between sessions in files it can read later. Anthropic organises it into four layers: raw session transcripts, distilled memory notes, structured representations such as wikis, and a small block of injected context that loads at the start of every session. It excludes changes to the model’s weights, knowledge gained within a single conversation, and compaction summaries.

What is dreaming in Claude agent memory?

Dreaming is an offline process in which Claude rereads its session logs between sessions, tests its memory notes against the original transcripts, corrects mistakes, builds or updates wiki pages, and promotes the most useful notes to the always-loaded layer. It became available as a research preview on Claude Managed Agents in May 2026 and is billed at the standard token rate of the model used. It is not available in the consumer Claude app.

How does Claude Code use agent memory?

Claude Code maintains an auto-memory file called MEMORY.md. Only the first 200 lines or 25 KB load at the start of each session, serving as an index that points to the rest of the memory. The practical advice from Anthropic’s research is to keep that header short and current — current goal, next steps, hard rules, and links to detail — rather than letting it become an archive.

How much did Claude agent memory improve benchmark scores?

On Anthropic’s CL-Bench 1.0 database task, Claude Opus 5.5 rose from 0.655 to 0.838 in mean reward with memory, Sonnet 5.5 from 0.644 to 0.833, and Opus 5 from 0.564 to 0.828. In the wiki experiment on a 350,000-file corpus, scores rose from 13% to 48% of graded criteria over 128 dreaming sessions, and search plus wiki reached 61% against 53% for search alone. All figures are Anthropic’s own, from its own evaluations.

Is Claude agent memory available to everyone?

Not yet in full. Memory stores and dreaming are in research preview on Claude Managed Agents, available by request with beta headers, and are not eligible for zero-data-retention or HIPAA workloads. Claude Code users already have auto memory through MEMORY.md. Anthropic has not announced a date for dreaming to become generally available, and the November 2026 post describes research setups rather than a product launch.

Sources: Anthropic, “The components of agent memory,” engineering blog, November 6, 2026 (anthropic.com); Claude platform documentation on Dreams. All benchmark figures are Anthropic’s own, from its own evaluations, and are labelled as such in this article.

Leave a Comment

Your email address will not be published. Required fields are marked *