Mem0 vs Zep vs Hakuya: what actually matters in agent memory

If you're adding memory to an AI agent in 2026, you have real options — Mem0, Zep, a vector database wired up by hand, and Hakuya, among others. They're often lumped together, but they're not solving the same problem. This is an honest attempt to map the landscape, including where we fit and where we don't.

A note on bias up front: we build Hakuya. We've tried to keep the comparisons factual and to be clear about what the other tools genuinely do well. If you catch us being unfair, tell us and we'll fix it.

The category is wider than it looks

"Agent memory" gets used for two different jobs that happen to share a name:

1. Storage and retrieval — put facts somewhere, get the relevant ones back. This is the job a vector database does, and the core of what Mem0 and Zep are built around.
2. Governance — prove where a belief came from, keep it current, show what the agent knew and when, and erase a subject on demand.

Almost everyone does the first job. Very few do the second. That gap is the whole reason Hakuya exists, so keep it in mind as we go.

Vector databases (Pinecone, pgvector, and friends)

A raw vector store is the most flexible option and the most work. You control everything, which means you build everything: extraction, deduplication, contradiction handling, confidence, decay, multi-tenant isolation. The database stores and searches embeddings; every behavior that makes those embeddings feel like memory is yours to write.

Good when: you have unusual requirements and the engineering time to own the whole stack. Painful when: you wanted memory and signed up to build a memory engine.

Mem0

Mem0 made a smart bet: an easy, developer-friendly memory layer that extracts salient facts from conversations and serves them back. It's popular for a reason — it's quick to add and it does the core extract-and-retrieve loop well, with a hosted option so you're not running infrastructure.

Where it stays deliberately light is governance. Provenance, a verifiable audit trail, per-subject cryptographic erasure, confidence dynamics you can inspect — those aren't the emphasis. For a lot of consumer-grade apps that's exactly the right tradeoff. For a regulated or high-stakes one, it's the part you'll end up building yourself.

Zep

Zep leans further toward structure, with a temporal knowledge graph at its center. Modeling how facts relate and change over time is genuinely valuable, and Zep does more here than a plain vector store — it's a serious option if a graph is what your use case needs.

The distinction from Hakuya is emphasis. Zep's center of gravity is the knowledge graph and retrieval quality. Ours is provable governance — the tamper-evident audit chain, provenance on every belief, and verified erasure — sitting on top of a cognitive engine that also does hybrid vector-plus-graph retrieval. Different priorities, and which one matters depends on whether your hardest problem is relating facts or accounting for them.

Hakuya

Here's what we optimize for, stated plainly so you can hold it against your needs:

• Provenance on every belief — source, evidence type, and confidence on each memory, so you can always answer why the agent believes something.
• A tamper-evident audit trail — a per-tenant, SHA-256 hash-chained log of every change, verifiable in one call and exportable as a signed record for SOC 2 or HIPAA review.
• Verified per-subject erasure — cryptographically shred everything about one customer, patient, or guest and keep proof you did, built for GDPR Article 17 and the EU AI Act.
• Self-cleaning memory — confidence decay and competition-aware suppression so the store gets cleaner with use instead of accumulating junk.
• A real cognitive engine underneath — semantic, episodic, procedural, and working memory; belief dynamics; hybrid retrieval at sub-10ms p95; multi-subject isolation for one agent serving thousands of users.

And it's open source under Apache-2.0, self-hostable with one Docker Compose command, no runtime dependency beyond Postgres.

How to actually choose

Skip the feature grids. Ask one question: what happens when your agent is confidently wrong in front of someone who matters?

If the answer is "we shrug and move on," you probably want the lightest thing that ships — Mem0, or a vector store if you like control. If your use case is fundamentally about how facts relate and evolve, look hard at Zep's graph.

But if the answer is "someone asks us to prove what the agent knew, why it believed it, and that we erased the person who asked" — that's the governance job, and it's the one we built Hakuya to do. Storage you can buy anywhere. Memory you can prove is a different product.

The honest summary: these tools overlap less than the shared label suggests. Match the tool to your hardest problem, not to the longest feature list.

Want to pressure-test the claims? Hakuya is open source — clone it, break it, and tell us where we fall short.