Every AI coding agent on the market ships with amnesia by design.
Claude Code starts each session with a blank context window. Cursor loses your architecture when you close the tab. The most capable models ever built can't recall what you said 10 minutes ago once the context fills up.
The industry's answer? A markdown file loaded at startup.
I spent the past month studying how agent memory actually works across the major systems — Claude Code's recently exposed internals, Mem0's vector store, Zep's temporal graph, Letta's OS-inspired tiers. The benchmarks are public. The architectures are documented. And every one of them is solving the wrong problem.
Three paradigms, three failure modes
1. File-based: Claude Code
Claude Code reads CLAUDE.md from your project root at session start. The entire file goes into the context window. No vector DB. No embeddings. No search.
Since v2.1.59, "auto memory" writes notes to ~/.claude/projects/<project>/memory/ — things like build commands, debugging patterns, style preferences. Still markdown. Still loaded wholesale. MEMORY.md has a hard cap at 200 lines. Anything beyond gets silently truncated.
This is intentionally simple. And for small projects it works. The failure mode is obvious: no selective retrieval. A 200-line cap on a monorepo with years of decisions means most knowledge is discarded. You either load everything or nothing.
2. Vector search: Mem0 and Zep
Mem0 (48K+ GitHub stars) decomposes interactions into facts and preferences, stores them as embeddings, and retrieves via semantic similarity. Zep builds a temporal knowledge graph — entities as nodes, relationships as edges, with timestamps tracking when facts were valid.
The benchmark data is revealing:
| System | LongMemEval | Memory per conversation | Architecture |
|---|---|---|---|
| Mem0 | 49.0% | ~1,764 tokens | Vector + Graph + KV |
| Zep | 63.8% | ~600,000 tokens | Temporal KG + Vector |
| Letta | ~83.2% | Dynamic | Tiered (Core/Recall/Archival) |
Mem0 fails to recall the right information more than half the time. Zep is 15 points better — but uses 340x more memory per conversation. The Zep team disputes the Mem0 paper's configuration, claiming a corrected score of 75.1%. Even so, the tradeoff is steep.
![Scatter plot showing accuracy vs memory footprint: Mem0 at 49% with minimal tokens, Zep at 64% with 600K tokens, Letta at 83% in between]
The deeper problem: both assume memory = retrieval. Store everything, search when needed. But retrieval accuracy is only useful if you're retrieving at the right moment. Neither system has a mechanism for deciding "does this agent need memory at all for this task?"
3. OS metaphor: Letta (MemGPT)
Letta models memory like an operating system. The context window is RAM. External storage is disk. The agent pages information in and out via explicit tool calls: core_memory_append, archival_memory_search, conversation_search.
On benchmarks, Letta leads the open-source field at ~83.2%. The agent makes nuanced decisions about what to keep in its working set. Architecturally, this is the most ambitious approach.
The cost: every memory operation burns inference tokens. The agent reasons about what to store, what to retrieve, how to organize — and that overhead compounds. Simple tasks get expensive because the agent spends a significant portion of its token budget on memory management rather than on the actual task.
The real problem nobody's solving: forgetting
Ebbinghaus mapped the human forgetting curve in 1885. We don't remember everything. We forget most things. What survives is what got reinforced — through repetition, emotional weight, or retrieval practice.
AI agents have no forgetting strategy. They either hoard everything (vector stores growing without bound) or lose everything (session boundaries that wipe the slate). There's no equivalent of "this decision from 3 months ago is probably stale" or "this debugging pattern surfaced 4 times — promote it to permanent storage."
![Chart comparing human forgetting curve with agent memory patterns: session-based drops to zero, vector stores grow unbounded, active curation follows a healthy decay]
Claude Code's source, briefly exposed via an npm packaging error on March 31, contains a hint of the right direction. A module called DreamTask runs during idle time — consolidating memories, merging duplicates, archiving stale entries. The codebase literally calls it "dreaming."
But it's primitive. A separate module memoryAge.ts calculates memory age and appends a text warning: "This memory is 47 days old. Claims may be outdated." Just a string appended to the content. The system doesn't reduce the memory's weight, doesn't trigger re-verification, doesn't decay its relevance score. The warning exists. The system doesn't act on it.
What's needed isn't better storage or retrieval. It's active curation — continuous evaluation of what's worth keeping, what should decay, and what should be promoted based on actual usage patterns.
Where it compounds: multi-agent memory
Everything above assumes one agent, one memory. Now multiply.
In multi-agent setups — Claude Code's subagents, CrewAI's role-based teams, AutoGen's collaborative agents — memory becomes a coordination problem.
A concrete scenario: Agent A decides to use the repository pattern for data access. Agent B, working on a separate module, implements raw SQL queries. Agent C reviews both and sees contradictory patterns. None of them know about the others' decisions because each agent's memory is private.
Claude Code's current solution: all agents read the same CLAUDE.md. When one writes, others pick it up on their next file read. This handles 2-3 agents. At 20+ agents making concurrent decisions, you get write conflicts, stale reads, and contradictory entries that nobody reconciles.
Research in agent-based social simulation — Stanford's Generative Agents, Tsinghua's AgentSociety, CAMEL-AI's OASIS — has been hitting these problems at scale for years. When hundreds of agents interact over time, questions emerge that single-agent memory never encounters:
Social reinforcement — If 50 agents independently store the same fact, is it more durable or just more popular?
Memory conflict — When two agents hold contradictory memories of the same event, what resolves the disagreement?
Information decay — When does a group "forget" something? When every individual forgets, or when it stops being referenced?
These aren't academic curiosities. They're the exact problems that any production multi-agent system will face once it scales past a handful of agents.
A hypothesis, not a solution
I don't have a working system to show. What I have is a hypothesis after studying all of these:
Memory in multi-agent systems is a coordination problem, not a storage problem.
Claude Code is right about simplicity. Mem0 is right about searchability. Letta is right about agent autonomy. None of them address the coordination dimension — the fact that agents need to share, negotiate, and reconcile memories, not just store and retrieve them privately.
The components that seem necessary:
Tiered personal memory — episodic (what happened) + semantic (what I know), with explicit promotion and demotion rules between tiers. Letta has the right shape here.
Shared state protocol — not a shared file, but a structured mechanism for propagating decisions across agents. Something closer to a distributed log than a wiki.
Active forgetting — relevance decay weighted by access frequency, age, and cross-agent reinforcement. Things that multiple agents reference stay. Things only one agent cares about fade.
Conflict as data — when memories contradict, maintain the disagreement as a first-class object rather than silently picking a winner.
The Meta-Harness paper (Stanford & MIT, March 2026) demonstrated that harness design alone produces a 6x performance gap on the same underlying model. Memory is arguably the highest-leverage harness component that remains wide open. The current state of the art is either "load a markdown file" or "search a vector store and hope for 49% accuracy."
There's a lot of room to do better. The agent that wins won't be the one that remembers the most. It'll be the one that knows what to forget.
What's your setup for agent memory? If you've found something that actually works across sessions — or something that failed spectacularly — I'd like to hear about it in the comments.
Top comments (0)