Mem0 is a memory layer you add messages to and search: its model extracts memories, and your code places the relevant ones in the prompt. Most alternatives differ on three questions, and answering them first narrows the list quickly:
- Who builds the prompt? You (a store you search), the vendor (it runs the agent), or the vendor for your call (it returns the request).
- What is the scope? A user across every conversation, an agent across its conversations, or one conversation.
- Who writes the memories? The vendor's extraction model, or your own agent's model.
Facts below come from each vendor's documentation, linked, as of the date above. We make Threadless AI, one of the eight options, so read its row with that in mind; we say where it is the wrong choice too.
Short answer
- Facts that change over time, and questions about what held when: Zep.
- An agent that edits its own memory, on a platform that runs the agent: Letta.
- A user's documents, files and connectors in memory: Supermemory or Cognee.
- A library inside a LangGraph app: LangMem.
- Open source you host, with a graph: Cognee, Honcho or Hindsight.
- The whole OpenAI request managed for one long conversation: Threadless AI.
- Stay on Mem0 if user-scoped memory across sessions is what you need, its free limits fit, and you are happy to build the prompt yourself.
Why teams look for a Mem0 alternative
The reasons we see, each confirmed against Mem0's own pages on the date above:
- Graph memory moved off the open-source edition. Mem0's comparison page says the open-source edition "previously connected external graph stores (Neo4j, Memgraph, Kuzu, Apache AGE)" and that "that integration was dropped when the v3 pipeline landed"; open source now has no queryable graph (platform vs OSS).
- On the hosted service, graph memory is a Custom-plan feature. The pricing page lists two plans, Free and Custom, with no published prices; graph memory, user profiles and memory consolidation appear only under Custom (pricing).
- The benchmark numbers are Mem0's own, and disputed. Mem0 reports 92.5 on LoCoMo and 94.4 on LongMemEval for its managed platform (research). Zep published a rebuttal of how Mem0's paper ran Zep (below). Neither settles how either does on your conversations.
- You still manage the context window. Retrieved memories go into a prompt whose history keeps growing. Threadless AI manages the whole request; Letta manages it by running the agent.
- Extraction misses what mattered. A separate model reading the conversation afterwards decides what to keep. Letta, LangMem's hot-path tools and Threadless AI let the model that was in the conversation write it.
- Time is a ranking hint, not a model. Mem0's recency bias is opt-in and adjusts ranking at search time (changelog). Zep puts validity dates on every fact.
At a glance
| What it is | Who builds the prompt | Scope | Who writes memories | Open source | |
|---|---|---|---|---|---|
| Zep | Temporal knowledge graph and context platform | You, with Zep's context block | User graph | Zep | Graphiti (the graph) |
| Supermemory | Memory and context engine for chat, documents and files | You, or its client wrapper | Namespaces you choose | Supermemory | SDKs |
| Letta | Platform that runs stateful agents | Letta, which runs the agent | Agent | The agent itself | Yes |
| Cognee | Knowledge-graph memory library and server | You | Datasets and sessions | Cognee's pipeline | Yes |
| LangMem | LangGraph memory library | You | Namespaces you choose | Your agent's model, or a background manager | Yes |
| Honcho | Memory that reasons about users and sessions | You, from its context call | Workspace, peer, session | Honcho | Yes (AGPL) |
| Hindsight | Memory banks with retain, recall and reflect | You | A bank per user or agent | Hindsight | Yes |
| Threadless AI | Hosted memory that returns the OpenAI request | Threadless AI, for your call | Conversation | Your agent's model, with a note tool | No |
For reference, Mem0 itself: you build the prompt, memories are scoped by user, agent, app or run (entity-scoped memory), Mem0's LLM writes them, and the open-source edition is Apache-2.0 (GitHub).
The alternatives
Zep
A context platform on Graphiti, a temporal knowledge graph whose facts carry validity dates (facts). You add messages to a user's threads and get a context block back. Stronger than Mem0 on facts that change and on point-in-time questions. Weaker if you want to self-host the whole service: Zep stopped maintaining its Community Edition in April 2025 (announcement), so self-hosting now means running Graphiti and a graph database yourself. Pricing: 10,000 credits a month free, Flex $125 a month, Flex Plus $375 (pricing). See Zep alternatives.
Supermemory
A store plus graph for chat, documents, files and connectors, with an OpenAI wrapper that injects memories into the system prompt (OpenAI integration). Stronger than Mem0 when documents and connected apps belong in the same memory. Weaker on openness: the self-hosted server is built from a non-public codebase (self-hosting). Pricing: Free with $5 of credits a month, Pro $19, Max $100, Scale $399 (billing). See Supermemory alternatives.
Letta
A platform that runs stateful agents; the agent edits its own memory files, versioned in git, and older messages are summarised near the limit (MemFS). Stronger than Mem0 when you want the context managed for you and an agent that curates its own memory. Weaker if you have your own agent loop: your agent has to run inside Letta. Pricing: Free for up to 3 agents with your own keys, Pro $20 a month (pricing). See Letta alternatives.
Cognee
An Apache-2.0 memory layer that builds a knowledge graph plus vectors, as a library, CLI, REST server or MCP server (introduction). Stronger than Mem0 if you want a graph in the open-source edition. Weaker as a drop-in: it is a pipeline you configure. Pricing: Cloud free for 1M tokens, then $1.00 per 1M tokens processed (pricing).
LangMem
LangChain's MIT-licensed library: memory tools for a LangGraph agent, plus a background manager that extracts and consolidates (LangMem). Stronger than Mem0 inside LangGraph, and the agent's own model can write memories. Weaker outside it; there is no hosted service. Pricing: none; you host it.
Honcho
An AGPL-3.0 library and managed service that reasons about each user in the background and returns "a blend of summary and messages" within a token budget, convertible to OpenAI format (get context). Stronger than Mem0 when you want history handed back, not just facts. Pricing: ingestion $2.00 per 1M tokens, context reads free (homepage).
Hindsight
Vectorize's MIT-licensed memory banks with retain, recall and reflect; recall runs semantic, keyword, graph and temporal search in parallel (docs). Stronger than Mem0 if you want an open-source server with temporal search. Pricing: Cloud retain $10.00 per 1M input tokens, recall $0.75 per 1M output tokens (billing).
Threadless AI
Hosted memory for OpenAI agents. Before every model call your agent sends what is new to decorate and gets back the whole request, ready to submit with its own key; report sends the reply afterwards. The latest messages are sent word for word. Older messages stop being sent word for word, but your model notes their key facts with a note tool and those facts stay in view, and older messages that matter come back, with their dates, when the conversation turns to them. Stronger than Mem0 when one long conversation keeps running out of context. Weaker for anything else: it does not share memory across a user's conversations, supports only OpenAI's formats, cannot be self-hosted, and has no published benchmarks yet. Prices are being finalised (pricing). See Threadless AI vs Mem0.
Pick by what you need
- Memory about a user across many conversations and apps: Zep, Supermemory, Honcho, or Mem0 itself.
- Questions about how facts changed over time: Zep, whose facts carry validity dates.
- Documents, files and connectors in the same memory: Supermemory or Cognee.
- A platform that runs the whole agent: Letta.
- A library inside a LangGraph app: LangMem.
- Open source you host yourself: Letta, Cognee, LangMem, Honcho, Hindsight, or Mem0's open-source edition (without graph memory).
- Long conversations with one OpenAI agent that keep running out of context: Threadless AI. It returns the whole request with the history managed, so there is no search step, no prompt assembly and no summariser to run.
Benchmarks, with caveats
Every figure here was published by the vendor about its own system, except Zep's figure for itself in Mem0's paper. Models, judges and metrics differ, so the rows do not rank the products against each other.
| System | Result | Who ran it | On what |
|---|---|---|---|
| Mem0 | LoCoMo 92.5, LongMemEval 94.4 | Mem0 | Its managed platform; the README notes the scores include "proprietary optimizations not available in the open-source SDK" (research, GitHub) |
| Mem0 (2025 paper) | LoCoMo 66.88% (68.44% with graph); full context 72.90% | Mem0 | GPT-4o-mini, LLM-as-a-judge (paper) |
| Zep | LoCoMo 75.14% | Zep | Zep's rerun after disputing how Mem0's paper configured it (rebuttal) |
| Zep | LongMemEval 71.2% (full context 60.2%) | Zep | gpt-4o (paper) |
| Letta | LoCoMo 74.0% | Letta | Plain file tools, GPT-4o mini (blog) |
| Cognee | LoCoMo 91.3% | Cognee | gpt-5-mini answering, gpt-5.1 judge, 224 questions excluded (benchmarks) |
| Honcho | LongMemEval-S 90.4%, LoCoMo 89.9% | Plastic Labs | gemini-2.5-flash-lite and claude-haiku-4.5 (evals) |
| Threadless AI | None yet | Runs in progress; we will publish scores with the method |
Run any candidate on a sample of your own conversations before you switch.
Migrating from Mem0
- Export your memories per user, agent or run before you change anything.
- Map the scope. Mem0's
user_id,agent_id,app_idandrun_idmap to user graphs (Zep), namespaces (Supermemory, LangMem), banks (Hindsight) or agents (Letta). For Threadless AI, a memory is one conversation. - Replace the read step. Swap
searchfor the new store's equivalent, or, for Threadless AI, replace search plus prompt assembly withdecorateand submit what comes back. - Replace the write step. Swap
addfor the new store's ingest call, or, for Threadless AI, callreportafter each reply and add the note tool. - Move durable user facts into the new store, or into your system message, which Threadless AI stores and always places first.
- Run both paths side by side on real conversations before you turn Mem0 off.
Questions people ask
What is the best Mem0 alternative?
There is no single one; it depends on what Mem0 was not doing for you. Zep for changing facts, Letta for a platform that runs the agent, Supermemory or Cognee for documents in memory, and Threadless AI for one long OpenAI conversation with the whole request managed.
Is Mem0 open source?
Yes, under Apache-2.0 (GitHub). Graph memory is no longer part of the open-source edition, and Mem0 says its published benchmark scores reflect the managed platform.
How much does Mem0 cost?
Mem0's pricing page lists a Free plan and a Custom plan with no published price (pricing). Free includes 10,000 adds and 1,000 retrievals a month for the first 30 days, and 50,000 adds and 10,000 retrievals a month with your own LLM key.
Does Mem0 have graph memory on the free tier?
No. On the hosted service, graph memory is listed under the Custom plan, not Free, and it was dropped from the open-source edition with the v3 pipeline.
Is Zep better than Mem0?
For facts that change over time, Zep's dated facts are the stronger design. For a simple user-memory API with an open-source edition, Mem0 is simpler. The two dispute each other's LoCoMo results, so compare them on your own data. See Mem0 vs Zep vs Letta.
Is there a Mem0 alternative built for OpenAI agents?
Threadless AI works only with OpenAI's Chat Completions and Responses formats, and returns the whole request for the call your code already makes. Mem0 and most others are provider-neutral stores.