# recall vs Zep

Zep runs an LLM pipeline over every message to extract entities and facts into a bi-temporal graph on its cloud; Graphiti is the open-source engine under it. recall indexes the chats your coding agents already keep, with no model calls, and keeps memory as markdown notes in git.

Checked 17 Oct 2026 · recall 0.5.1 · [Zep on GitHub](https://github.com/getzep/graphiti)

## At a glance

Zep is built for products with many users: each gets a graph of entities and facts with the times they held, so an agent can ask what was true when. recall is built for one developer and their coding agents: an index over every chat Claude Code, Codex and Cursor have saved, and a few notes a night that every agent loads at session start.

One is a hosted service you integrate; the other is a tool you install.

| | recall | Zep |
| --- | --- | --- |
| Runs | On your machine | Zep Cloud, or your VPC on Enterprise; Graphiti self-hosts on a graph DB |
| Licence | MIT | Graphiti Apache 2.0; Zep is a service, Community Edition deprecated |
| Model calls to store a chat | **0** | **Several per episode**: extract, date, dedupe, invalidate, summarise, embed |
| A search takes | **11 ms** local, 47 with embeddings | **162 ms** p95, its own LongMemEval run |
| Price | **Free** | 10,000 credits free; $125 and $375 a month; Enterprise |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to Zep Cloud and its LLM pipeline |
| Claude Code, Codex, Cursor | MCP, skill, session hook | Remote MCP server and skill, per-user sign-in |

## Where both were measured

The benchmark both report is LongMemEval. Zep's paper scored 71.2% with GPT-4o; its research page now reports 90.2% with gpt-5.4 answering and judging, on 4,408 tokens a question. recall 0.4.1 scores 88.4% with the smaller Claude Haiku 5.5 as both, on all 500 questions. Different models and judges, so read the ranking loosely; recall's retrieval alone finds an answering session in the top five 98.7% of the time.

The difference in context is real: Zep hands the model a few thousand tokens of extracted facts, recall hands it chats, ~44k tokens for ten of them. recall spends tokens at read time rather than model calls at write time. Zep has not been measured on a coding benchmark; on SWE-ContextBench recall finds the past fix in its top five 80% of the time.

**Fig 1. recall 0.5.1 and Zep** LongMemEval: answers correct, context handed to the model, and retrieval latency, as each reports it.

| Measure | System | Figure | Note |
| --- | --- | --- | --- |
| Answers correct | Zep · site | 90.2% | its research page, gpt-5.4 answering and judging |
| Answers correct | recall 0.4.1 | 88.4% | Claude Haiku 5.5 answering and judging, reading the top 10 chats |
| Answers correct | Zep · paper | 71.2% | its January 2025 paper, GPT-4o answering and judging |
| Context a question | Zep · site | 4.4k | its research page |
| Context a question | Zep · paper | ~1.6k | graph facts, as reported |
| Context a question | recall 0.4.1 · top 10 | ~44k | ten whole chats, scoring 88.4% |
| Context a question | recall 0.4.1 · windows | ~17.5k | matched windows of the top 5, scoring 84.2% |
| Retrieval latency, p95 | Zep · site | 162 ms | a hosted graph, its own run |
| Retrieval latency, p95 | recall 0.4.1 · keywords | 69 ms | a local index on a laptop, no model in the path |
| Retrieval latency, p95 | recall 0.4.1 · hybrid | 87 ms | with the local embedding model's ranking |

LongMemEval_S · Zep's 2025 paper and its 2026 research page · recall 0.4.1, all 500 questions Zep's paper used GPT-4o answering and judging; its research page gpt-5.4 for both. recall used Claude Haiku 5.5 for both. Latency: Zep's p95 on its hosted run; recall's p95 over one LongMemEval history on a laptop.

## Cost

Zep meters what you store: a credit per 350 bytes of episode, 10,000 free a month, 50,000 on the $125 Flex plan, 200,000 on Flex Plus at $375. Retrieval is unmetered. Behind each credit is an LLM pipeline of several calls. A day of coding-agent transcripts runs to megabytes.

recall meters nothing. Indexing and search make no model calls; the nightly notes use the model you chose, free through a local one, covered by a subscription, or at batch prices on an API key.

| | recall | Zep |
| --- | --- | --- |
| Model calls to store a chat | **0** | **Several per episode**: extract, date, dedupe, invalidate, summarise, embed |
| Price | **Free** | 10,000 credits free; $125 and $375 a month; Enterprise |
| To take in 300 sessions | **$0**, no model calls | Credits: one per 350 bytes stored |
| Cost of memory | One nightly run, your model | A credit per 350-byte episode |

## Latency

Zep reports a p95 of 148 to 168 ms for retrieval across graphs of ten thousand to a hundred million nodes, and 162 ms on its LongMemEval run: a round trip to a hosted graph, with writes queued behind the pipeline.

recall's search runs on the machine: a p95 of 69 ms over a LongMemEval history with keywords, 87 ms with embeddings, and a median of 11 ms on ~2,800 real chats. There is no write path to wait on.

| | recall | Zep |
| --- | --- | --- |
| A search takes | **11 ms** local, 47 with embeddings | **162 ms** p95, its own LongMemEval run |
| Wait at write time | **None**: reads saved chats | The LLM pipeline, per episode |

## Privacy

Zep is a cloud service: your messages go to its infrastructure and through its LLM pipeline. It holds SOC 2 Type II, offers a HIPAA BAA and EU residency on request, and runs in your own VPC on Enterprise. Graphiti keeps the graph on your database but still sends every episode to an LLM, OpenAI by default; the Community Edition that once self-hosted Zep itself is no longer supported.

recall keeps the index, the notes and their git history under your home folder, reads chats read-only, redacts secrets, sends no telemetry and never pushes. With a local model through Ollama, nothing leaves.

| | recall | Zep |
| --- | --- | --- |
| Runs | On your machine | Zep Cloud, or your VPC on Enterprise; Graphiti self-hosts on a graph DB |
| Licence | MIT | Graphiti Apache 2.0; Zep is a service, Community Edition deprecated |
| Chat text leaves your machine | **No**, with a local model | **Yes**: to Zep Cloud and its LLM pipeline |
| Compliance | Nothing to certify: no service | SOC 2 Type II; HIPAA BAA and EU residency on request |
| Telemetry | **None** | A cloud account |

## How memory is built

Zep's memory is a graph: each episode kept whole, and from it entities and the facts between them, each fact carrying when it became true, when it stopped and when Zep learned it. A contradicting fact closes the old one rather than deleting it.

recall's memory is files you can open. The index holds every chat; the notes are markdown in git, each naming its project, its type and the chats it came from. A nightly run extracts candidates and consolidates them rule by rule, superseding what changed, one commit a night; `git log` shows what memory learned and `git revert` undoes it.

| | recall | Zep |
| --- | --- | --- |
| Captured by | Reading the agents' own chat files | Your app adding episodes |
| Memory is | Markdown notes in git, plus an index of every chat | Entities and dated facts in a graph |
| Retrieval | Full-text index, five rankings fused; optional local embeddings | Semantic, BM25 and graph, with time filters |
| You can edit it | **Yes**, and the edit wins | Through the API |

## Which to pick

**Pick Zep if**

- You run a product with many users and want each one's facts in a graph you can query by time.
- You want a managed, compliant service and the per-episode credits fit your volume.
- Your memory comes from your application's messages, not from coding-agent transcripts on disk.

**Pick recall if**

- You want Claude Code, Codex and Cursor to share one memory of your own work, with nothing to integrate.
- You want search with no model in the path and no credits to count.
- You want the memory on your machine, readable and revertible, with no cloud account.

## Questions

**Is Zep open source?**

The engine is: Graphiti is Apache 2.0 and self-hosts on Neo4j, FalkorDB or Neptune with an LLM key. Zep itself is a cloud service; its Community Edition was deprecated in April 2025. recall is MIT and runs entirely on your machine.

**Which has the better LongMemEval score?**

Zep's 2026 research page reports 90.2% with gpt-5.4 answering and judging; its 2025 paper reported 71.2% with GPT-4o. recall measures 88.4% with Claude Haiku 5.5 doing both. Treat the three as a range, not a ranking. recall's retrieval alone finds an answering session in the top five 98.7% of the time.

**Does recall build a knowledge graph?**

No. recall keeps the chats themselves in a full-text index and distils them into markdown notes with links between notes and to their source chats. The evidence it found for graphs on retrieval benchmarks was thin, and a coding agent's questions are mostly answered by finding the right chat.

**Can Zep read my Claude Code history?**

Not by itself: Zep stores what your code or its MCP plugin sends it, so a coding agent has to save memories as it goes. recall reads the transcripts Claude Code, Codex and Cursor already write, including everything from before you installed it.

## Sources

- Graphiti on GitHub: https://github.com/getzep/graphiti
- Zep: how graph creation works: https://help.getzep.com/v4/how-graph-creation-works
- Zep research: LongMemEval and LoCoMo figures, latency, tokens: https://getzep.com/research
- Zep pricing: https://www.getzep.com/pricing
- Zep security and compliance: https://help.getzep.com/security-compliance
- Zep: a temporal knowledge graph architecture for agent memory, Rasmussen et al., 2025: https://arxiv.org/abs/2501.13956
- recall's chat benchmark runs, with the other systems' figures: https://github.com/alirng/recall/blob/main/docs/research/retrieval-benchmarks.md