Mem0 vs Zep vs Supermemory vs Letta: which agent memory tool should I use?

Short answer

Pick Mem0 for a memory API that extracts facts per user or agent, Zep when facts change over time and you need to know what was true when, and Supermemory for a usage-priced memory and retrieval API with plugins for coding tools. Pick Letta if you are building the agent itself. All four are developer platforms first, though each now also connects to some existing AI clients.

How each one remembers

The four tools solve the same problem, giving AI agents memory beyond the context window, with four different ideas about what memory is.

Aspect Mem0 Zep Supermemory Letta
Core idea Extract facts from messages, return the relevant ones Temporal knowledge graph (“Context Graphs”) Memory and retrieval API with a memory graph per user Platform for stateful agents with their own memory
How memory is scoped user_id, agent_id, run_id, metadata User graphs, plus shared graphs that administrators grant per user or group Per user Per agent; Teams Pro shares agents with access controls
Handling change Extraction when you add; consolidation on the Custom plan Older fact marked invalid with a timestamp; source kept per fact Not detailed in our sources The agent updates its own memory
Connects to AI clients OpenMemory: MCP layer for Cursor, VS Code, Claude and other MCP coding agents Context MCP server and plugin for Claude, ChatGPT, Claude Code, Codex, Cursor Plugins for Claude Code, Cursor and others Not covered in our sources
Run it yourself Open-source version Bring your own cloud on Enterprise supermemory local, at no cost up to 10,000 documents Not covered in our sources

A closer look:

  1. Mem0 works in three steps: you add messages, Mem0 extracts and stores facts with linked entities, and on retrieval it returns only the relevant memories. It comes as a managed platform and as open source. OpenMemory, its MCP layer, captures a developer’s preferences and patterns and hands the relevant ones to their coding agent.
  2. Zep stores facts with time. When new data contradicts an earlier fact, that fact is marked invalid with a timestamp, so you can tell what was true when, and every fact keeps its source. Its Context MCP server lets existing clients search the same graph, and a user’s in-house agent and personal MCP client can share one user graph.
  3. Supermemory is a memory and retrieval API that builds a memory graph per user and ships plugins for coding tools.
  4. Letta is an agent platform more than a memory service: you build stateful agents that keep and update their own memory, stored per agent in a memory repository.

Prices, as of November 2026

Tool Entry Paid tiers
Mem0 Free: 10,000 adds and 1,000 retrievals per month with model calls for the first 30 days; with your own LLM key 50,000 adds and 10,000 retrievals per month, and you pay your model provider for those calls Custom on request (graph memory, user profiles, SSO, audit logs, on-prem). No fixed self-serve price listed
Zep Trial, 10,000 credits per month Flex $125/month (50,000 credits, 5 projects, 5 MCP seats); Flex Plus $375/month (200,000 credits, 10 projects, 15 MCP seats); Enterprise on request
Supermemory Free $0 ($5 credits, 1 seat) Pro $19/month ($20 credits, 3 seats); Max $100/month ($130 credits); Scale $399/month ($600 credits, SOC 2, HIPAA BAA, self-hosting); Enterprise on request
Letta Free $0 (3 stateful agents, 5 MiB per memory repository, no model usage included: bring your own API keys or a coding plan, or buy credits) Pro $20/month ($20 credits, 20 agents, 50 MiB per memory repository); Teams Pro $20 per seat per month; Enterprise custom

Zep charges 1 credit per episode of up to 350 bytes; retrieval and storage cost no credits. Supermemory charges $0.005 per 1,000 tokens of memory (text), $0.001 per 1,000 tokens for SuperRAG and $0.005 per 1,000 search queries. Check the pricing pages before you commit; these change often.

How to choose

  1. You are adding personalization to your own app: Mem0 or Supermemory. Mem0 if you want fact extraction with fixed monthly limits, Supermemory if you prefer to pay per token and query.
  2. Your facts change and history matters (customer status, contract terms, who owns what): Zep, because of the temporal graph and per-fact source.
  3. You are designing the agent itself and want memory to be part of its architecture: Letta.
  4. You want memory inside Claude Code or Cursor for yourself: Mem0’s OpenMemory, Supermemory’s plugins or Zep’s Context MCP server.

Test them in an afternoon

A comparison table does not tell you how a tool handles your data. Run the same small test on each candidate:

  1. Write ten facts about one customer, including one that changes (“contact is Anna” and a week later “contact is now Ben”).
  2. Add them through the API or MCP connection in the order they happened.
  3. Ask, from a fresh session, “who is the contact?” and “who was the contact before?”.
  4. Ask from a second user or client that should have access, and from one that should not.
  5. Note which tool returns the current fact, keeps the old one as history, respects the access boundary and shows where each answer came from.

The misunderstanding

These comparisons are usually read as “which memory should our team use?”. All four are now more than a raw API: Zep and Mem0 connect to existing clients through MCP, and Zep and Letta have shared access for teams. But each still holds only what you put into it. None of them reads the knowledge that already sits in your mail, documents and repositories unless you build that pipeline, and you still decide per tool and per person what is connected. For the conceptual background, see What are the types of memory in AI agents? and Is RAG the same as AI memory?.

What this means for a team

If your team builds its own agents, one of these may well be the right component. If the question is how the AI tools people already use can share what the team knows, you still have work to do: connecting each tool, permissions, importing existing knowledge, and deciding which fact is current. See How can a team share one AI memory?

Where Bombos fits

Bombos starts from the team instead of the application. It is a plugin that gives Claude, Claude Code, ChatGPT, Copilot, Grok, Codex, Cursor and your own agents one shared memory, with team knowledge, learned rules and what already sits in mail, documents and repositories, and each answer shows what it rests on. It runs in our cloud or on your own server, and one developer can try it first for their own agents.

Related questions

Which of these can I self-host?

Mem0 has an open-source version next to its managed platform. Supermemory can run locally with supermemory local, at no cost up to 10,000 documents, and offers self-hosting on its Scale plan. Zep offers bring-your-own-cloud on Enterprise.

Which is cheapest to start with?

All four have a $0 entry point. Mem0's free tier has fixed monthly limits, Zep has a trial of 10,000 credits per month, Supermemory's free plan includes $5 in credits, and Letta's free plan includes no model usage, so you bring your own API keys or buy credits.

Can these share memory between agents or people?

Yes, if you set it up. Mem0 scopes memory by user_id, agent_id and run_id, Zep lets administrators grant users access to shared Context Graphs, and Letta's Teams Pro plan lets teammates share agents with access controls.

Do these work with ChatGPT or Claude?

Some do. Zep's Context MCP server and plugin work with Claude, ChatGPT, Claude Code, Codex and Cursor. Mem0's OpenMemory is an MCP memory layer for Cursor, VS Code, Claude and other MCP coding agents. Supermemory ships plugins for tools like Claude Code and Cursor.

Sources

  1. Mem0 pricing
  2. OpenMemory (Mem0)
  3. Concepts (Zep docs)
  4. Context MCP server (Zep docs)
  5. Supermemory pricing
  6. Pricing (Letta docs)
The first half hour · free

What does your AI forget?

  1. 01You tell us which AI you use and where it keeps starting over.
  2. 02We show what a shared memory changes there, on your own examples.
  3. 03You keep the plan, with or without Bombos.
Piet Baudoin
Piet BaudoinYou talk to Piet, from the Bombos teamDutch team from Utrecht and Nijmegen · data in Europe
We reply the same working day.