Mem0 vs Zep vs Kika: agent memory tools compared
Search for "AI agent memory" and you get a list: Mem0, Zep, Letta, LangMem, Graphiti, a dozen more. They get compared on benchmark scores and GitHub stars, in posts that treat them as interchangeable options for the same job.
They are not interchangeable, and most of the comparisons miss the split that actually decides which one you want. It is not accuracy. It is who the memory is about, and who is expected to build it.
Two questions sort the entire field, and you can answer both in about a minute.
Question one: are you building an agent, or using one?
This is the split that matters most and gets written about least.
Mem0, Zep, Letta and LangMem are infrastructure. They are SDKs and APIs. You import them into an agent you are writing, you decide what to store and when, you own the retrieval logic, and you ship the result to your users. The buyer is an engineer with an agent to construct.
Kika is a product. Two commands into agents you already have - Claude Code, Cursor, ChatGPT. There is nothing to build. The buyer is a developer with client work to do.
If you are building a customer support agent that needs to remember its users, you want the first group, and this post will not help you choose between them. Go and read the benchmarks; they are the right thing to read.
If you are a developer who is tired of re-explaining your own project to Claude every Monday, the first group is not a shorter path to that. It is a longer one: you would be building the product yourself, on top of them.
We should be straight about our own position here, because it is an odd one. Kika runs on Graphiti, which is Zep's open-source engine. We are not competing with the graph. We are the application on top of it, and we chose that engine because it was the best one available for what facts do over time.
Question two: is the memory about a person, or about a project?
Here is where the products genuinely differ, and it is structural rather than a feature anyone can add.
Mem0's memory is scoped to a person. Its published model is
user_id / agent_id / run_id / app_id. Memory attaches to a user and follows
them. That is exactly right for personalisation - remembering that this customer
prefers email, that this user works in TypeScript, that they asked about billing
twice last month.
Kika's memory is scoped to an engagement. The unit is the project, and several people plus all of their agents read and write the same one. Your colleague connects their own Claude Code on Thursday and it already knows what was decided on Monday, by someone else, in a conversation they were not part of.
That difference is not a setting. A memory built around a user_id cannot be
made shareable by adding a flag, any more than a single-player game becomes
multiplayer with a checkbox. It is a different shape underneath.
Which you want depends on a question worth asking honestly: is the thing you keep forgetting about yourself, or about the work? If your agent keeps forgetting your preferences, personal memory is the fix. If it keeps forgetting that you already ruled out DynamoDB and why, that is the project's memory, and it should not live in your user profile.
What the benchmarks say, and what they do not
For completeness, since this is what most comparisons are made of. These are published third-party numbers, not ours - we have not re-run them and you should treat them as directional:
- On LongMemEval, Zep is reported at 71.2% against Mem0's 49%.
- On LOCOMO, the ordering reverses and Mem0 leads.
- Mem0 has the larger community by a wide margin - around 55k GitHub stars as of mid-2026 - and the faster path from install to working.
The disagreement between those two benchmarks is the interesting part. They measure different things. LongMemEval leans on temporal reasoning - what was true when - which is what a bi-temporal graph is built for. LOCOMO leans on retrieval over long conversations, which rewards speed and simplicity.
What neither measures is whether the memory can be shared by four people. There is no benchmark for that, because until recently nobody was building for it.
Where each one is the right answer
Choose Mem0 if you are building an agent for end users and you want it to personalise. Biggest ecosystem, quickest to integrate, and personalisation is what it is optimised for.
Choose Zep or Graphiti if you are building something where when a fact became true matters - compliance, case management, anything where "Alice owned the budget until February" has to be a real query rather than a string-similarity guess. Also choose it if you want to own the graph yourself.
Choose a plain CLAUDE.md file if your project is small and stable and one
person works on it. Genuinely. A file you edit by hand costs nothing, has no
failure modes, and if it is enough then everything on this page is overhead you
do not need. It stops being enough when the file gets long, when it goes stale
because updating it is a chore nobody does, or when a second person joins.
Choose Kika if you run client work: several engagements, more than one person on them, and the thing that hurts is that every new chat window starts from zero and every new colleague starts from a handover doc nobody wrote.
What we do not do
Worth saying plainly, since you will find out anyway:
- Kika is not a library. There is no SDK to build your own agent on. If you want programmatic control over storage and retrieval, you want Zep or Mem0.
- Kika does not personalise. It will not learn that you prefer tabs. That is deliberate - it is the other axis - but if personalisation is what you came for, it is the wrong tool.
- Kika is not self-hostable today. The graph runs on our infrastructure. Zep and Mem0 both have open-source paths; we do not.
- Kika needs the meetings to be at their best. The decisions worth keeping are usually said out loud and never written anywhere, which is the part no code-reading tool can reach - but if you never talk to anyone about the work, you are giving up the thing Kika is best at.
The short version
Mem0 and Zep are what you build memory with. Kika is memory you install. Their memory is about a person; ours is about a project. Both are reasonable things to want, and they are not the same product in two colours.
If the second one is what you are after, it is two commands and it is free:
claude plugin marketplace add usekika/kika-plugin
claude plugin install kika@kika
Then /mcp, choose kika, approve in the browser. What it costs:
nothing. How it works.