Agent Memory in 2026: Four Tools, Four Different Meters
Mem0 bills add and retrieval requests, Zep bills credits, Letta bills active agents and seconds of tool execution, Cognee bills tokens ingested. All four are Apache-2.0, so the meter matters more than the feature list.
Agent projects hit the same wall in week three. The demo works, someone closes the chat, opens a new one, and the agent has no idea who they are. A larger context window does not fix it. Context is what the model can see in this turn; memory is what survives the session ending.
So you go looking for a memory layer and end up with four tabs open: Mem0, Zep, Letta, Cognee. They all say “persistent memory for agents” and they are not the same product. Two of them are a service you call, one is an agent runtime you build inside, and one is a pipeline that turns documents into a graph. They also bill on four incompatible units, which is the part that decides what this costs you at scale.
Prices below came off each vendor’s pricing page on 22 August 2026.
What a memory layer does, and the part that is hard
Three jobs: decide what is worth keeping from a conversation, store it durably, and pull the relevant piece back when it matters. Storage is the easy third. Any vector store holds embeddings.
The hard parts are extraction and retrieval. Extraction has to know that “actually, make it dairy-free” replaces “add extra cheese” rather than sitting next to it. Retrieval has to surface that two weeks later when the same user orders again, and not surface the version that was overwritten.
That second problem is worth drawing, because it is the one that separates these tools more than any feature list does.
Account status, subscription tier, project phase, deal stage, a patient’s symptoms: all of it changes, and an undated fact eventually produces a confident wrong action rather than a clumsy sentence.
The four, by what they actually are
Mem0 is an API. You post conversation turns, it decides what to keep, you query it in natural language and get memories back. Two calls, add() and search(), and you have a memory layer. Underneath it mixes vector, graph, and key-value storage, and you do not have to care until you need the graph.
Zep is a temporal knowledge graph, built on Graphiti. Every fact carries a validity window, so a change invalidates the old edge instead of overwriting or duplicating it. That is the lower half of the diagram, as a product.
Letta, formerly MemGPT, is not a memory service. It is an agent runtime where memory works the way an operating system handles RAM and disk: core memory sits in context and the agent rewrites it, recall memory is searchable history just outside context, archival memory is cold storage reached through tool calls. The agent pages its own state in and out. That is the most interesting design of the four and the most expensive to adopt, because you are adopting its agent model, not attaching memory to the agent you already wrote.
Cognee is a pipeline for documents. It ingests a corpus, extracts entities and relationships, and builds a graph with embeddings layered on. It is the wrong tool for remembering a user’s name and the right one for reasoning across a thousand policy PDFs where provenance matters.
Four products, four meters
This is where the decision usually gets made, and where the numbers move fastest.
| Billed on | Free tier | Next tier | |
|---|---|---|---|
| Mem0 | add and retrieval requests | 10,000 adds, 1,000 retrievals/mo | Starter $19/mo: 50,000 adds, 5,000 retrievals |
| Zep | credits | 10,000 credits/mo, no rollover | Flex $104/mo: 50,000 credits, then $25 per 10,000 |
| Letta | agents and execution time | limited agents, bring your own keys | API plan $20/mo + $0.10 per active agent + $0.00015 per second of tool execution |
| Cognee | tokens ingested | 1M tokens, 1 workspace | $2.50 per 1M tokens, $5 per extra workspace |
Two things in that table are worth more attention than the headline prices.
Mem0’s graph memory, the entity linking and multi-hop querying that makes the architecture interesting, is gated to the Pro plan at $249 a month. The step from Starter is 13x, and it lands the moment your use case turns relationship-shaped. Plan for that boundary before you build on it, because “we will add the graph later” is a pricing decision, not a technical one.
Zep’s numbers moved a lot this year, and in the same direction as everyone else’s: the current page shows Flex at $104 a month for 50,000 credits with overage at $25 per 10,000, and Flex Plus at $312 for 200,000. A credit is not a request, so you cannot compare that row to Mem0’s without running your own traffic for a week and reading the counter. That is the honest answer for any credit-metered product.
All four are Apache-2.0, which changes the question
Mem0, Graphiti, Letta, and Cognee all ship under Apache-2.0, checked on GitHub on 22 August 2026. Self-hosting is a real option in every column, so the SaaS bill is buying operations rather than access. That is a different question from “which is cheapest,” and it is the one worth asking, because the temporal graph in particular is more work to run than a vector store.
Project health, from the same check: Mem0 sits around 63.8k stars, Graphiti and Cognee both around 30k, Letta around 24k, and every repository had commits within the last week. On PyPI, last month’s downloads run graphiti-core at 1.39M, zep-cloud at 352k, cognee at 217k, and letta at 200k. Letta’s most recent tagged release is 0.16.8 from 14 May 2026 while the repository keeps moving, so if you need a version you can pin, check the tag date before you promise a rollout schedule.
What is not verifiable is the accuracy claims. Every vendor here publishes its own benchmark showing it ahead on LOCOMO or LongMemEval or ConvoMem, none of it is independently replicated, and the leaderboards reshuffle with each release. Those numbers are marketing until someone else runs them.
Picking one
If you are storing preferences and facts about users so a chatbot recognizes them next week, Mem0 is the shortest path and its free tier covers a real prototype. If a stale fact would cause a wrong action rather than an awkward sentence, that is the temporal problem and Zep is built for it. If you are starting a new agent from scratch that will run for weeks and manage its own state, Letta’s model is the one designed for that, and the cost is that it wants to be your framework. If your memory is really a document corpus, Cognee is a knowledge-graph pipeline and the other three are not.
Then run your own evaluation before committing, because retrieval quality on your data is the only number that transfers. An afternoon is enough: wire the free tier of whichever one fits into what you are building, feed it a real conversation, and compare what it chose to remember against what you would have kept. The gap between those two lists tells you more than any comparison table, this one included.