Start on Postgres. Agent memory is being sold as a category, but at the scale most enterprise teams actually run, it is a table with an embedding column and a delete statement — and the evidence that a dedicated memory store retrieves better is currently a fight between two vendors, each of whom has published a correction of the other's numbers.
That is not a reason to never buy one. It is a reason to know exactly what you are buying, because the thing being sold — retrieval quality — is the one claim on the page that nobody outside the vendors has confirmed.
Here is the comparison at a defined workload: 10,000 monthly active users, 20 assistant turns each per month — 200,000 memory writes and 200,000 memory reads, roughly 350 bytes per stored turn, about 50 retained memories per user. All prices checked on the vendors' own pricing pages on 19 September 2026.
| Zep Cloud | Mem0 Platform | Letta Cloud | Postgres + pgvector | |
|---|---|---|---|---|
| What it stores | Bitemporal knowledge graph of extracted entities and edges | LLM-extracted facts, optionally graph-linked | Stateful agent memory blocks and files | The rows you wrote, plus an embedding |
| Metered on | Bytes ingested (1 credit per 350 bytes) | Add operations and retrieval operations, separately | Active agents per month | Compute-hours and storage |
| Cost at this workload | $375/mo (Flex Plus, exactly at quota) | $249 Pro tier — but 4x over its retrieval quota | ~$1,020/mo before LLM tokens | ~$163–$332/mo all-in |
| Self-host path | Graphiti only; bring your own graph database | Apache 2.0, minus the platform's optimisations | Apache 2.0, self-hostable server | Yes, it is your database |
| SOC 2 Type II | Certified company-wide; the report and HIPAA BAA are Enterprise-only | Not stated on the pricing page | Not stated | Whatever your Postgres provider holds |
| Right to erasure | One API call deletes user, threads and graph | Delete APIs per memory and per user | Per-agent; cascade to memory blocks undocumented | DELETE ... WHERE user_id = $1 |
| Verdict | Buy for temporal fact invalidation | Buy as a library, self-hosted | Skip at 10,000 users | Start here |
What Each Product Actually Means By "Memory"
The word "memory" names four different products, and the differences decide your architecture before pricing does.
Zep stores a bitemporal knowledge graph. Every extracted fact carries both when it was true in the world and when the system learned it, so when a user changes employer the old edge is invalidated rather than overwritten — the architecture is described in the team's 2025 paper. The open-source engine underneath is Graphiti, Apache 2.0, which requires you to bring a graph database — Neo4j 5.26, FalkorDB 1.1.2, or Amazon Neptune, with Kuzu marked deprecated.
Mem0 stores extracted facts. On every write it sends the messages through an LLM that, per its own documentation, "pulls out key facts, decisions, or preferences to remember," then stores them additively. The package is Apache 2.0. Read the README carefully, though: the published benchmark scores "reflect Mem0's managed platform, which includes proprietary optimizations not available in the open-source SDK."
Letta stores agent state — memory blocks and a filesystem the agent edits with tools, descended from MemGPT.
Postgres stores what you put in it. A messages table, a memories table with a vector column from pgvector, and retrieval is a query you wrote and can read.
The first three make an LLM call on the write path. The fourth does not. That distinction is where both the cost and the failure modes come from.
The Retrieval Quality Claim Does Not Survive Cross-Examination
No independent party has confirmed that a commercial memory store retrieves better than a competent baseline, and the two market leaders have each published a correction of the other's numbers.
In May 2025, Mem0's co-founder and CTO filed an issue against Zep's own papers repository arguing that Zep's published 84% LoCoMo accuracy was inflated by roughly 25.56 percentage points — Zep had excluded the adversarial question category from the denominator while keeping its correct answers in the numerator. The corrected figure in that issue is 58.44% ± 0.20. The issue was closed on 19 May 2025.
Zep's reply post argues Mem0 ran Zep wrong: a single-user graph with both speakers assigned the user role, timestamps appended to message text instead of the dedicated created_at field, and sequential rather than parallel searches inflating the latency comparison. Re-run properly, Zep reports 75.14% ± 0.17 against Mem0's ~68%, and p95 search latency of 0.632s — against the 0.778s Mem0 had published for Zep, and Mem0 graph's own 0.657s.
Now read the line in Zep's own post that neither vendor's marketing quotes: a simple full-context baseline scored about 73% — beating Mem0's best result outright. And Letta's evaluation put LoCoMo transcripts in plain files with grep and open tools and scored 74.0% on GPT-4o mini, above the 68.5% Mem0 reported for its top graph variant. Letta's conclusion is the uncomfortable one: "agent capabilities matter more than the tools." Discount it for interest, though — Letta sells agent memory, and a filesystem the agent searches with tools is close to a description of its own product, so this is less a plain baseline than a competitor's architecture in a baseline's clothes.
Mem0 now reports much higher figures — 92.5 on LoCoMo and 94.4 on LongMemEval at a 200-memory retrieval budget, using under 7,000 tokens per query against full-context's 25,000-plus. Token efficiency is a real and defensible win. Accuracy at that level is a claim measured on a benchmark that the vendor itself warns can be "materially improved by aggressive retrieval strategies, larger context windows, or frontier models."
The honest reading of the scoreboard is Mem0's own benchmark guide, which reports BEAM — 1M and 10M-token conversations — at 64.1 and 48.6. At realistic scale, no memory architecture is close to solved.
The nearest thing to a disinterested read comes from the University of Edinburgh, whose systematic evaluation ran memory architectures against full-context prompting on the same LoCoMo transcripts and found they "reduce token usage by over 90% while maintaining competitive accuracy" — competitive, not better, with episodic memory pulling clearly ahead on exactly the adversarial questions this whole dispute started over. It tested research designs, not Zep or Mem0 or Letta. So the fair summary is narrower than either vendor's: the architecture is defensible and the token savings are real, while the products remain unaudited by anyone without a stake. It is also worth knowing that the ruler is bent — an audit of LoCoMo by Penfield Labs, itself a memory vendor, reports 99 score-corrupting errors in 1,540 questions and an LLM judge that accepted 62.81% of deliberately wrong answers. Treat every second decimal place above accordingly.
And then there is the failure mode that only the extraction-based designs have. HaluMem, an operation-level hallucination benchmark published in November 2025 covering Mem0, Mem0-graph, Memobase and Supermemory — its authors deferred Zep to future work on grounds of evaluation speed — found extraction recall below 60%, memory accuracy below 62%, correct update rates below 26%, and end-to-end QA accuracy below 55%. The LLM that extracts the fact can fabricate the fact, and the fabrication is then stored as something the agent knows.
Read that one with its interest stated, too: HaluMem comes out of China Telecom Research Institute and MemTensor, which sells a memory system of its own, and it measures four competitors while deferring the fifth.
A row containing the verbatim message the user sent cannot hallucinate. That is the strongest argument for the boring option — and notice that nearly everyone currently making it, HaluMem's authors and Letta included, is selling a memory system too.
What It Costs At 10,000 Users
At the defined workload, Postgres undercuts Zep at $163–332 against $375, and runs a sixth the price of Letta — and the gaps widen as conversation volume grows, because every managed store meters the write path.
Zep. Its pricing charges 1 credit per 350 bytes ingested, with storage and retrieval unmetered. 200,000 turns at 350 bytes is exactly 200,000 credits — the Flex Plus tier at $375/month. Double the average turn length to 700 bytes and you need 400,000 credits: $375 plus five overage blocks at $75 each, $750/month. The metering is clean and predictable, and it scales with exactly the thing that grows.
Mem0. Its pricing separates adds from retrievals, and the Pro tier at $249/month includes 500,000 adds but only 50,000 retrievals. Our workload uses 200,000 of each. The adds fit with room to spare; the retrievals are four times over quota. That ratio is worth pausing on: Pro budgets ten writes for every read, and production agents read far more than they write. The binding constraint on the published tier is the one nobody checks, and clearing it means a conversation with sales.
Letta. Its pricing is $0.10 per active agent per month on the API plan, plus a $20 base and $0.00015 per second of tool execution. One agent per user at 10,000 users is $1,020/month with the base fee, before a single LLM token. Per-agent pricing is coherent for a few hundred long-lived agents and the wrong shape for a consumer-scale user base.
Postgres. On Neon, pgvector is included on every plan. Two compute units running continuously on the Scale plan is 2 × 730 × $0.222 = $324/month; on Launch at $0.106/CU-hour it is $155. Storage for 500,000 memories at the 20–25 KB per vector that ClickHouse's engineering guide reports for real HNSW deployments is about 12.5 GB — round to 20 GB at $0.35/GB-month, $7. Embeddings for 400,000 calls at roughly 100 tokens each is 40M tokens of text-embedding-3-small, which OpenAI prices at $0.02 per million: 80 cents. Total: $163 to $332/month. Supabase Pro is $25/month with 8 GB included and $0.125/GB after, though its Micro instance will not hold that index in RAM — size up before you quote yourself the $27.
One number that matters if you plan to self-host Mem0 rather than buy it: you pay the extraction LLM yourself. At one call per add, ~1,500 input and ~300 output tokens on gpt-4o-mini at $0.15/$0.60 per million, 200,000 adds is about $81/month. Self-hosted Mem0 lands at $244 to $413 all-in on the Postgres numbers above — competitive, and you keep the data.
Graphiti self-hosted is the one I cannot price for you. Its README documents no per-episode call count, and a temporal graph doing entity extraction, edge extraction, deduplication and invalidation plausibly makes several calls per message. Measure it on your own traffic for a week before you commit — and note you are also provisioning and operating a graph database.
The column this table does not contain is engineering time. Two weeks to build the Postgres version and someone who owns it afterwards is real money, and at a loaded rate it exceeds a year of Zep Flex Plus. That is the honest case for buying, and it is stronger than anything in the benchmark fight.
Deletion Is Where The Managed Stores Actually Win
Right to erasure is the one dimension where a dedicated memory store is clearly better than the table you would have written, and it is the reason a regulated buyer should take the category seriously.
The problem is derived data. A user asks you to delete their data under GDPR Article 17. You delete the messages. But the memory layer already ran an LLM over those messages and stored an extracted fact — "works at Acme, allergic to penicillin" — in a different table, possibly in a graph node with edges to other users' facts. Deleting the source does not delete the inference. If you build this yourself and do not design for it, you will ship that bug, and you will find it during an audit.
Zep handles it explicitly: per its documentation, deleting a user removes all threads, all thread artifacts including messages and metadata, and "the entire user graph and all knowledge extracted from conversations" in a single call, named in the docs as the Right To Be Forgotten path. That is a genuine product, and reproducing it correctly over a graph you built yourself is a week of careful work plus a test suite that nobody enjoys writing.
The catch is which tier you have to be on to use it under a compliance obligation. Zep is SOC 2 Type II certified as a company — but its pricing table checks that row for Enterprise only, because the SOC 2 report and supporting documentation, a HIPAA BAA, audit logs and DPA support for EU customers are all Enterprise-only at Zep. The control environment is the same on every tier; the evidence your auditor asks for is not. A buyer who needs a BAA cannot use the published $125 or $375 prices at all — those tiers exist, but not for you. Supabase, for contrast, gates SOC 2 and ISO 27001 behind its $599 Team plan; the published number is higher and it is a published number.
The second catch is the exit. Zep ended support for its self-hostable Community Edition in April 2025, concentrating open-source effort on Graphiti. The repository stays available under Apache 2.0; it gets no further updates or support. So the self-host path is now Graphiti plus a graph database you operate — a different system with different performance, not a downgrade of the one you were paying for. Price the migration before the first renewal, not after.
When The Postgres Version Stops Working
Agent memory is a small-data problem wearing a big-data costume, and most teams will not hit pgvector's ceiling — but the ceiling is specific enough to plan against.
At our workload, 500,000 memory rows is comfortably inside what ClickHouse's guide calls the band where "naive implementations often succeed," roughly one million vectors. Ten million is where "quantization, partitioning, and strict memory tuning tend to matter more." Ten million memories means every one of your 10,000 users holding a thousand retained facts; if you are there, you have a retention policy problem before you have a database problem.
Three concrete things break, in this order:
- The index stops fitting in RAM. Real deployments land at 20–25 KB per vector with HNSW graph metadata. Once the index exceeds available memory, every graph hop hits disk and sub-millisecond searches become multi-second. The fix is
halfvecquantization — halving the column at a recall loss the guide calls "often minimal," though it varies by embedding model and dataset — before it is a bigger instance. - Filtered search silently loses recall. This is the trap, because it produces no error. Ask for ten nearest neighbours, post-filter by
user_id, and if nine candidates fail the filter you return one result and the agent confidently says it does not know. pgvector 0.8's iterative scans fix it by pulling more candidates until enough rows pass. Setmaintenance_work_memto 8–16 GB for large index builds, or the graph stops fitting in memory partway through and pgvector warns that building "will take significantly more time." - You reinvent fact invalidation badly. This is the real ceiling, and it is not about scale. A highly-retrieved memory about a user's employer is correct until they change jobs, then confidently wrong forever. Bitemporal invalidation is a hard design problem; Zep sells a solved version. When your team starts writing
valid_fromandvalid_untilcolumns and a conflict resolver, you have arrived at the buy decision honestly.
Who Should Not Buy Each One
Zep is wrong for you if you need a HIPAA BAA on a published price — the BAA, the SOC 2 report, audit logs and EU DPA support all sit behind the Enterprise upsell, so the sticker is not yours. It is also wrong if a credible self-host exit matters, because the one that existed was discontinued and the replacement is a different system.
Mem0 Platform is wrong for you if your agent reads far more than it writes, because the Pro retrieval quota binds four times before the add quota does. Its open-source package is wrong for you if you are buying on the published benchmark scores — those are the managed platform's, with optimisations the SDK does not include.
Letta is wrong for you at consumer user counts, because per-active-agent pricing multiplies by your user base. It is right when you run tens or hundreds of durable agents and want the state model as the product.
Postgres is wrong for you if nobody owns it. The DIY version has no vendor to page, and a retrieval quality problem in a system you wrote is your on-call rotation. It is also wrong if you need temporal invalidation on day one and have no appetite to build it.
And the loser at this workload is the managed middle tier generally — paying $250 to $750 a month for a hosted extraction pipeline whose accuracy claims are contested by its nearest competitor, whose HIPAA paperwork requires a different tier anyway, and which will happily store a hallucinated fact it invented on the write path. Either self-host the Apache 2.0 version and keep the data, or buy Enterprise and get the audit evidence. The middle buys neither.
The Decision In Four Questions
Answer these in order and stop at the first yes.
This week:
- Do facts about your users change and matter? Employment, entitlement, medication, contract tier. If a stale fact creates a wrong action rather than a wrong pleasantry, temporal invalidation is a product requirement and you are buying Zep. If not, you are storing preferences, and a table holds those.
- Does a deletion request have to reach derived data? Write the query that deletes a user's extracted facts, today, on paper. If you cannot write it, you do not have a memory architecture — you have a liability.
This month:
- Measure your read-to-write ratio in production. It decides which vendor's meter you are on the wrong side of, and every published tier assumes a ratio that may not be yours.
- Run the full-context baseline as a control. Before you buy retrieval quality, measure what stuffing the last N turns into the context window scores on your own eval set. Both Zep's post and Letta's evaluation show simple baselines competitive with paid systems on the public benchmarks. On your data the answer may differ — but you should know it, and it costs a day.
The Bottom Line
This is the 2013 NoSQL argument with new logos. A genuinely new workload appeared, specialist vendors shipped first because Postgres had not caught up, and then Postgres caught up — and most teams discovered they had been running a specialist database to hold a few million rows they could have kept next to their users table, with transactions, joins, backups and a DELETE that actually deletes.
Agent memory is at the same point. The specialists are ahead on temporal reasoning and on erasure, and those two things are worth real money to a regulated buyer. They are not ahead on retrieval in any way an independent party has confirmed, and they charge on the write path that grows fastest.
Start on the table you already own. Instrument it, run the baseline, and let the memory store win the argument on your data.
Buy it when you can name the column you could not write.
Continue Reading
- Pinecone vs Weaviate vs pgvector: Stay on Postgres
- Vector Database Pricing: Only pgvector Publishes a Rate
- Self-Host the Vector DB for Residency. Not for the Bill.
- RAG Build vs Buy: Buy the Index. Build the Eval Set.
- What RAG Actually Costs: $1,308 a Month at 10M Tokens/Day
- JPMorgan Ranked 62 Retrievers for $800. Pool the Judgments.
- Best RAG Platforms for Regulated Industries: Permissions First
- Toyota Ships an Agent in 4 Days. One Review Covers 50.