Letta vs Mem0 vs Zep: Three Different Answers to Agent Memory

Letta vs Mem0 is less a contest than a choice between two shapes of product, and Zep adds a third. Letta is an open-source agent harness: you run Letta agents, and each one keeps its own long-term memory as files in a git repository it edits itself. Mem0 is a memory layer: you keep your own agent, call Mem0 to store facts after a conversation and to search them before the next answer. Zep is a context layer for enterprise data: it turns conversations, documents and business records into temporal graphs and puts access policy and audit around them. Choose Letta if you want the agent, Mem0 if you want memory for an agent you already have, and Zep if governance over company data is the hard part. Everything below is from each vendor’s own documentation as of October 8, 2026.

Letta: the agent owns its memory

Letta describes itself as an AI research lab building machines that learn, and Letta’s site↗ (opens in a new tab) says it was founded by the creators of MemGPT at UC Berkeley’s Sky Computing Lab. Its product is the Letta harness, formerly Letta Code, with a CLI, a desktop app, a web app and an Agent SDK for embedding agents in your own application. A Letta agent is a persistent identity with its own memory, model settings, tools and conversations, and you return to the same agent across sessions and machines.

Memory lives in MemFS. The MemFS documentation↗ (opens in a new tab) describes a git repository that belongs to the agent and is checked out wherever it runs. Files at the root, such as persona.md, load into the system prompt on every turn; folders with their own MEMORY.md index stay out of context until needed. Every edit is a commit, so memory has version history. There is no vector index by default; agents find memory with ordinary file search, and a search add-on is available.

• You teach it directly: /remember always use pnpm in this repo, and the agent decides where the lesson belongs.
• Dreaming: background subagents review recent conversations and consolidate what was learned, without asking you for approval.
• Shared memory: on Letta Cloud, several agents can attach the same git-backed repository for team conventions and plans.
• Self-hosting: agents can run entirely on your machine with no Letta account, with state kept on-device.

Mem0: memory your app calls

Mem0 sits between your application and the model. Its explanation of how Mem0 works↗ (opens in a new tab) has two calls: add after a useful interaction, which extracts facts, deduplicates and embeds them, and search before the next model call, which ranks memories on semantic, keyword, entity and time signals. Memories are scoped by user_id, agent_id, run_id and, on the managed Platform, app_id. There is a managed Platform and an Apache 2.0 open-source version; graph memory, webhooks and export are Platform-only. A hosted MCP server lets coding tools use it too.

The key difference from Letta: Mem0 does not run your agent. It works with whatever agent or framework you already have, and its integration list runs from LangGraph and CrewAI to the OpenAI Agents SDK and Vercel’s AI SDK.

Zep: governed context graphs

Zep calls itself the unified context layer for enterprise data. It keeps context in temporal Context Graphs, where facts carry valid-from and valid-until times, so when new information contradicts an old fact, the old one is invalidated but its history kept. Zep’s agent memory guide↗ (opens in a new tab) describes the model: one Zep user per application user, threads for conversations, business data added as episodes, and a Context Block retrieved before the next model call. The same graphs can hold shared context for a customer account, a product or a business domain.

What sets Zep apart is governance. Its governance documentation↗ (opens in a new tab) covers role-based access for people in the dashboard, attribute-based policies that limit what each agent’s API key can retrieve, tracing facts back to their source, audit logs and API logs. Zep lists SOC 2 Type II for its cloud, HIPAA agreements for enterprise customers, bring-your-own-key encryption and deployment in your own cloud. The graph engine underneath, Graphiti↗ (opens in a new tab), is open source.

The comparison

                Letta                   Mem0                     Zep
What it is      agent harness           memory layer             context layer
Who runs agent  Letta                   you                      you
Memory unit     Markdown files in git   extracted facts          temporal graph facts
Who writes      the agent itself        model, via your add()    model, via ingest
History         git commits             per-memory history       fact validity ranges
Governance      tool approvals          orgs, projects, roles    RBAC, ABAC, audit logs
Open source     harness                 Apache 2.0 version       Graphiti framework

One changed fact, three behaviors

A user who said they live in Austin now says they moved to Seattle. The way each product handles that sentence shows its design better than any feature list.

• Letta: the agent decides the old line in its memory file is out of date, edits it and commits. The old version is in the git history, and you can read the diff.
• Mem0: automatic extraction is additive, so the new fact is stored without silently rewriting the old one. Your code calls update or delete to correct it, and on the managed Platform, Dream supersedes outdated facts in the background.
• Zep: the new fact invalidates the old one, which keeps its validity range, so you can ask what is true now or what was true at a given time.

If someone on your team must be able to see and explain why the agent believes something, that preference alone may decide between files, an API and a graph.

Which one fits

• Pick Letta if you want a long-lived agent, a coding agent, a personal assistant or an AI coworker on Slack, and you like memory you can open as files and roll back with git.
• Pick Mem0 if you already have an agent or an app, and you want it to remember each user with a few lines of code, managed or self-hosted.
• Pick Zep if your agents draw on company data and the questions you must answer are who may see what, where a fact came from, and what was true last March.

All three are stronger than a hand-kept record at what infrastructure does well: scale, retrieval speed and, in Zep’s case, compliance. They overlap least where it matters most, so a short proof of concept on your own data will settle the choice faster than any feature table. The general criteria are in choosing an agent memory system.

What none of them is

Each of these remembers on behalf of an agent or an app. None is meant to be the place where people on a team, and every AI app they use, keep the same record of work: what is being built, what was decided and why, and where the last session stopped. Letta’s memory belongs to a Letta agent; Mem0’s and Zep’s are read by your code.

fenbs is a web app for that record. Projects, tasks, Decisions and rules, lessons learned and Where we left off sit on one board that people can see and edit, and ChatGPT, Claude, Claude Code, Codex, Cursor and others read and update it over MCP, so changing app or model does not mean starting over. People make the rules; an assistant can write a decision down, but the decider is always a person, and only a person can pre-approve a task for AI. History records every change and who made it. It is for people and teams who use AI for work, not for building agents, which is exactly where Letta, Mem0 and Zep shine.