10 Files Beat 413: What Anthropic’s Dreaming Agents Teach Us About Memory
Anthropic ran its Claude models through Pokémon recently, with persistent memory attached. The current Fable 5 earned four gym badges carrying 10 memory files. An older Sonnet 3.7 managed one badge while hauling 413 files behind it.
Ten files, four badges. Four hundred thirteen files, one badge. And Opus 5.5, the strongest of the three, finished the whole game.
If you build anything with agents, or run a RAG pipeline, or just take notes for a living, that contrast should bother you in a productive way. Anthropic’s new research post on the components of agent memory explains what is going on, and the short version is that memory stopped being a storage problem. It became a judgment problem.
The part everyone missed: agents that dream
The headline finding is that Claude agents now use idle time between sessions to replay their own work logs, catch mistakes in their notes, and reorganize what they know. Anthropic calls it dreaming, and the borrow from neuroscience is deliberate. In the brain, the hippocampus captures experience in the moment, but consolidation into long-term knowledge happens offline, during sleep. Nothing is being learned while you sleep. Something is being filed.
Agent memory now runs on the same division of labor. The transcript of a session is raw experience. Memory notes are the distilled residue. And the filing step works better when the agent is not simultaneously trying to answer you, which is why it happens between sessions rather than during them.
The idea is not entirely new. Sleep-time compute, from Letta and UC Berkeley researchers, pushed the same insight: give a system offline cycles to reprocess what it saw. What Anthropic added is production plumbing. They shipped cookbooks for dreaming workflows and knowledge wikis on their platform, so this is infrastructure you can wire up today, not a paper you wait three years for.
Self-audit, not surveillance
Here is the design choice I find genuinely interesting. When Claude’s memory runs, it checks its own past notes against logs of actual work. The agent catches its own errors. Nobody scans your conversations to build a profile of you, which is how ChatGPT’s memory tends to feel from the outside.
That difference matters more than it sounds. Self-audit means the memory belongs to the agent. It is working material the agent maintains and corrects. A user profile is something maintained about you. Those are different products, and only one of them gets better on its own.
Anthropic also reports that newer models have gotten much better at judging what is worth saving in the first place. The Pokémon numbers are the proof. Fable 5 did not win because it remembered more. It won because it remembered the right ten things.
Why-beats-what, the finding builders should steal
One experiment in the post deserves its own section. Anthropic compared two ways to get a model to keep good notes: handing it rules about what to write, versus explaining to it why memory matters at all.
Explaining why won. Reasoning about the purpose of memory outperformed compliance with instructions about its content.
I have seen this pattern in human teams constantly. Give someone a checklist and you get checkbox-shaped output. Explain the goal and you get judgment that generalizes. Apparently the same holds for language models, which is awkward for everyone building elaborate prompt rulebooks around their agent memory systems. The rules were never the mechanism. The model’s understanding of the job was.
If you take one operational lesson from this post, that is the one. Rewrite your memory instructions as explanations. “Save API quirks that cost us time” will age better than a twenty-line schema nobody updates.
The memory stack, briefly
For reference, the hierarchy Anthropic describes has four layers, and knowing them helps you debug your own setup:
- Transcripts. The raw record of what happened. Cheap to keep, expensive to load.
- Memory notes. Distilled facts and corrections, written during or after sessions.
- Representations. Structured knowledge, like a wiki the agent maintains about its domain.
- Injected context. Whatever gets loaded into the next session’s prompt.
Most agent setups I see in the wild live entirely at layer 1 and wonder why context windows cry for mercy. The dreaming work is essentially about moving knowledge up that stack automatically, during hours the agent would otherwise spend doing nothing.
Stop hoarding, start curating
Zoom out and the principle applies well past agents.
Human note-takers know this failure mode. The archive of 4,000 highlights you never reread. The second brain that became a second attic. Information you collect but never consolidate is not memory, it is storage, and storage does not help you in a gym battle.
RAG pipelines have the same disease. Teams index everything, retrieve top-k, and then act surprised when the model drags stale, contradictory chunks into every answer. Curation, deduplication, and periodic rewrites of what is actually in the store do more for answer quality than another point of recall. Anthropic’s own numbers say as much: a well-kept 10-file memory beat a neglected 413-file one, badly.
Curation is also now a model capability in its own right, and it is improving fast. The gap between Fable 5 and Sonnet 3.7 on the same task is a capability gap in knowing what to keep, not in knowing more. Model choice increasingly decides memory quality even when the memory system is identical.
What to do now
Three concrete moves, ranked by effort.
First, if you run agents with persistent memory, schedule idle-time consolidation. Replay recent session logs, have the agent flag notes that contradict what actually happened, and rewrite them. Anthropic’s dreaming cookbook is a working reference implementation on their platform.
Second, audit your memory store by size. If your agent or pipeline carries hundreds of entries, ask what each one has done for you lately. A small store the model actually maintains beats a big one it merely tolerates. Prune toward the ten files that earn badges.
Third, convert your memory rules into explanations. Strip the schema down to intent. Tell the system why the memory exists and let the model figure out the what. That single change is the closest thing to a free upgrade this research offers.
Idle time used to be dead time. Now it is when the filing happens. An agent that dreams is just an agent whose memory keeps working after the conversation ends.
Source: Anthropic, “Components of Agent Memory,” November 2026. Pokémon benchmark figures as reported by Anthropic.
