Playbooks · Coding tasks
Pick a memory server for your coding agent
Written November 7, 2026
Your agent forgets everything between sessions. Mem0, Zep, Supermemory, Letta, Cognee — what each stores, what it costs, and whether you can read it yourself.
The problem
A coding agent starts every session knowing nothing about your project beyond what is in the prompt. The facts it learned last week — which module is fragile, what the team decided, why a workaround exists — are gone unless something stored them. A memory server is that something: a store the agent writes to and reads back through, usually over MCP. The field is crowded, every vendor claims the top benchmark score, and the two comparisons below were both written by sellers in the field. Read them for the checkable facts, not for the ranking.
Two comparisons, and who wrote them
The main comparison is InfraNodus's Agent Memory Tools Compared, dated October 24, 2026, covering ten tools. InfraNodus sells a memory product of its own, and the comparison ends by recommending it for the use case it is built for — a readable graph you can audit. Its prices, licenses, and limits are stated as taken from each vendor's own pricing page, documentation, or GitHub repository, and the prices in the table below are from the vendor pages linked in Sources.
The second is the total-agent-memory vs-competitors matrix by ausduns, dated April 2026. It promotes its own local-first server for coding agents, and its feature table marks its own row as the best on nearly every line. Treat its verdicts the same way: useful for the shape of the field, not a neutral ranking.
What each one stores, what it costs, whether you can read it
Prices are monthly list prices from the vendor's own pricing page. Where a vendor does not state something, the table says so.
| Tool | What it stores | Licence | Hosting | Starting price | Can you read it yourself |
|---|---|---|---|---|---|
| Mem0 | Vector store + BM25 keyword search, with an entity graph ("Graph Memory") on the platform | Apache-2.0 for the library; the managed platform adds proprietary optimizations | Self-hosted library or Cloud Platform | Free Hobby tier (10,000 adds, 1,000 retrievals a month); paid plans from $19 a month, Pro $249 | Partly: the platform dashboard, or the vector store you run when self-hosting |
| Zep + Graphiti | Temporal knowledge graph: facts with validity windows, old facts marked invalid rather than deleted | Graphiti Apache-2.0; Zep's license is not published | Graphiti self-hosted; Zep Cloud or in your own cloud | Free (10,000 credits a month); Flex $125 a month; Flex Plus $375 | Yes for Graphiti, if you query the graph database (Neo4j, FalkorDB, Neptune) |
| Letta | Memory blocks pinned in the context window, a vector archive, and full message history | Apache-2.0 | Letta Cloud or your own letta server | Free $0 (3 agents, 5 MiB per memory repo); Pro $20 a month (20 agents, 50 MiB) | Yes: the memory blocks are plain text you and the agent edit |
| Cognee | Knowledge graph + vector index + relational store (SQLite, LanceDB, Ladybug by default) | Apache-2.0 | Self-hosted, or Cognee Cloud | Self-hosting is free; the pricing page lists Enterprise BYOC engagements and no Cloud list prices | Through the databases you run |
| Supermemory | Graph of facts (Updates, Extends, Derives relations) + embeddings | MIT | Hosted API, or a local Docker build | Free $0 ($5 of credits a month); Pro $19 a month ($20 of credits, 3 seats); Max $100; Scale $399 | Through the API and SDKs; the local Docker build exposes the store |
| Reference MCP memory server | Small knowledge graph of entities, observations, and relations in a local memory.jsonl file | MIT | Local only, one process per client | Free | Yes: open memory.jsonl in any editor |
Start the reference server with npx -y @modelcontextprotocol/server-memory. It is the baseline everything else is measured against: a file the model writes and reads back, with no structure beyond line order and no way to ask what changed or what is missing.
Where the two comparisons disagree
- Star counts. The two comparisons were written six months apart and their star counts do not match — for example, the April matrix lists Mem0 at about 48,000 stars and the October comparison at 67,712. Star counts are a snapshot, not a property of the tool, and no star count is used as a decision input here.
- Zep's price. The ausduns matrix lists Zep Cloud from about $99 a month per seat; Zep's own pricing page lists a Free tier (10,000 credits a month) and Flex at $125 a month for 50,000 credits. The vendor page settles it.
- Supermemory's price. The ausduns matrix lists $0.01 per 1,000 tokens, usage-based; Supermemory's own pricing page lists credit plans — Free with $5 of credits a month, Pro $19 with $20 of credits. The vendor page settles it.
- Cognee Cloud. The InfraNodus table lists a Cloud free tier and a per-token Standard price. Cognee's pricing page now shows only the open-source engine (free) and Enterprise BYOC engagements, with no Cloud list prices. Those Cloud figures are not carried here.
Do not rank by benchmark score
Every vendor leads with a benchmark number, and the numbers do not travel between setups. Mem0 reports 94.4 on LongMemEval and 92.5 on LoCoMo; Zep reports 90.2 and 94.7. An independent LongMemEval run in 2025 scored Mem0 at 49.0 and Zep at 63.8. The same benchmark, different setups, different numbers — which is why no benchmark score is a column in the table above. The ausduns matrix adds its own numbers, including a 96.2% recall figure for its own server on LongMemEval, measured by its own authors. None of these settles which store fits your agent.
The decision rule
Pick by storage model, hosting, and whether you can read your own data — not by benchmark rank:
- If fact history matters — what was true last quarter, what changed and when — pick a temporal graph: Zep, with Graphiti as its open engine.
- If the agent should manage its own notes — editable memory it can see and rewrite — pick Letta, whose memory blocks are plain text.
- If you want the graph in your own database and are willing to integrate it yourself — pick Cognee, which is free to self-host.
- If you want a memory API for many users through an SDK — pick Mem0, with a free tier of 10,000 adds a month.
- If you want a personal second brain whose preferences fade and strengthen over time — pick Supermemory.
- If you want the simplest thing that works on one machine — pick the reference MCP memory server, and open the file to see what the agent recorded.
After a month, the test is whether the agent's answers got better — and only a readable store lets you trace which learnings did that. A vector store returns the nearest entries; a graph returns the subgraph around the query; a flat file is reread whole, so its token cost grows with its length. That is the cost no monthly price shows.
Limits
- This page is a comparison read. No memory server was installed here and no retrieval was measured.
- Prices and licenses come from the vendor pages linked below. Vendors change pricing pages without notice; the vendor page is the authority, not this table.
- Benchmark figures are reported as their sources report them. No benchmark was run here, and none is presented as independent.
- Both comparisons this page draws on were written by sellers in the field. Their framing is reported with that interest stated, not adopted.
Related playbooks
- Apify MCP Server 0.21.8 hardens the bridge
- AWS MCP server let deny lists silently fail
- Claude agents now dream: memory that consolidates
- Coding-agent traces in advisory fixes
Sources
- Agent Memory Tools Compared: Mem0, Zep, Letta, Cognee, MCP — InfraNodus
- total-agent-memory vs the field — ausduns / claude-total-memory
- AI Memory Pricing — Mem0
- Pricing — Zep
- Pricing — Letta Docs
- Pricing — Cognee
- Pricing — supermemory
Back to: Coding playbooks hub · Also: Codex memory v2: import memories from other agents · Run claude-mem on your own plan, redaction on · Agent Skills has a neutral home — and still no security story