Mem0 alternatives: 11 agent memory layers compared

Updated October 8, 2026 · 12 min read

The closest Mem0 alternatives are Zep, Supermemory and Hindsight: hosted memory APIs that, like Mem0, pull facts out of conversations and return the relevant ones for each user. Letta and LangMem build memory into an agent framework instead, Cognee turns documents into a knowledge graph, and Basic Memory and Dexio keep memory as markdown pages a person can read. We checked every product below on its pricing page, docs and GitHub repository on 1 October 2026. We have not benchmarked any of them.

What is Mem0 best at?

Mem0 is a memory layer for apps and agents. You send it messages; it extracts facts, preferences and decisions, stores them per user, and returns the relevant ones when you search. It comes three ways:

• As a library: pip install mem0ai (or npm install mem0ai), call Memory(), and memory runs inside your own process. Apache-2.0.
• As a self-hosted server: a Docker Compose stack with a dashboard, per-user API keys and a request audit log, on Postgres with pgvector. Its default LLM is OpenAI’s gpt-5-mini.
• As the hosted Platform (pricing). Hobby is free with 10,000 add requests and 1,000 retrieval requests a month. Starter is $19 a month (50,000 and 5,000). Pro is $249 a month (500,000 and 50,000, unlimited projects, graph memory). Enterprise is custom and adds on-prem deployment. Every plan allows unlimited end users.

The mem0 repository has 66,411 stars, more than any other project on this page, with a commit and a release on 25 September 2026.

Stay with Mem0 if you are adding per-user memory to an app, want an Apache-2.0 library you can run in-process now and a hosted API later, and find search over extracted facts good enough.

Look elsewhere if you need graph memory below $249 a month, facts that change over time, an agent that manages its own memory, or memory your team can open and read. Each alternative below says which of these it answers.

Which Mem0 alternatives are there?

Which hosted memory APIs are closest to Mem0?

1. Zep and Graphiti: facts that change over time

Zep stores memory as a knowledge graph in which facts carry time, so the graph records when something changed. Its engine, Graphiti, is Apache-2.0 (31,344 stars, v0.30.2) and you can run it yourself with a graph database and your own LLM key.

Zep’s free tier gives 10,000 credits a month for prototyping. Flex is $125 a month for 50,000 credits (then $25 per 10,000), Flex Plus is $375 for 200,000, and Enterprise is custom, with deployment in your own VPC. You pay when you send data: an episode costs 1 credit per 350 bytes. Retrieval, storage and users cost nothing.

Zep beats Mem0 when facts change and you need to know what was true when, or when you want graph memory without a $249 plan. Mem0 is better when you want a cheap paid tier: Zep’s first paid plan is $125 a month against Mem0’s $19.

2. Supermemory: memory and document search in one API

Supermemory keeps a memory graph per user (its pricing page describes profiles and fact hierarchies) and also stores documents for search, so one service covers memory and RAG. Pricing is credits: Free includes $5 a month; Pro is $19 ($20 of credits, 3 seats); Max is $100 ($130 of credits); Scale is $399 ($600 of credits, unlimited seats, a self-hosted option); Enterprise is custom. Memory costs $5 per million tokens of plain text, and only unique content is billed. It quotes a 187 ms median recall time, a vendor-published number.

Its GitHub repository (SDKs, plugins and the MCP server) is MIT with 31,048 stars. The memory server itself, including a local binary that is free for individual developers within a license limit, is built from a non-public codebase. Its MCP server is in our MCP memory servers roundup.

Supermemory beats Mem0 when you want memory and document search from one API, or built-in connectors. Mem0 is better when you want a fixed request quota per plan rather than metered credits.

3. Hindsight: everything free to self-host

Hindsight comes from Vectorize. It has three operations: retain (store), recall (retrieve) and reflect (find patterns in what it has stored), and its docs describe observations and mental models it builds from what it retains. The self-hosted version is MIT, runs with one Docker command on embedded PostgreSQL, and includes all four of its memory networks and an MCP server. The repo has 44,119 stars and a release on 29 September 2026.

Hindsight Cloud has no monthly fee: retain costs $10 per million tokens and recall $0.75 per million, and signing up with GitHub gives $5 of credit. Its site reports 94.6% on LongMemEval-S against 74.0% for the next best system it tested. That is a vendor-published benchmark.

Hindsight beats Mem0 when you want every feature self-hosted at no cost, or memory that reflects on past work as well as recalling it. Mem0 is better when you want a flat monthly price with included requests.

4. Honcho: memory about people and agents

Honcho, from Plastic Labs, models peers (users, agents, game characters, groups) and the relationships between them. New messages trigger reasoning about each peer, and you ask questions with .chat() at five levels priced per query: Minimal $0.001, Low $0.01, Medium $0.05, High $0.10 and Max $0.50. Startups that have raised under $5M can apply for $1,000 of credits. The core is AGPL-3.0 with 7,424 stars.

Honcho beats Mem0 when conversations have several participants (group chats, agents with subagents) or you want conclusions drawn about a user on top of the stored facts. Mem0 is better when you want a plain add and search API with a monthly quota.

5. Memori and MemOS

Memori stores agent and conversation memory in a database you bring. The SDK and MCP server are free to self-host (the repo has 17,037 stars and an Apache 2.0 license file). Cloud Free covers 5,000 memories created and 15,000 recalled; production plans start at $60K a year (Team) and $150K (Business), with Enterprise in your VPC or on-prem. It suits companies that need memory in their own database with audit logging.

MemOS calls itself a memory OS for LLMs and agents, with hybrid retrieval and skill reuse across tasks. It is Apache-2.0 with 11,668 stars; its cloud free plan lists 50,000 adds and 20,000 searches a month.

Which alternatives build memory into the agent?

6. Letta: agents that keep their own memory

Letta (formerly MemGPT) is a platform for stateful agents, not a layer you call from another framework. Its memory blocks are, in the docs’ words, “structured sections of the agent’s context window that persist across all interactions”: always visible, with no retrieval step. Archival memory holds the rest. The letta-ai/letta repo (Apache-2.0, 24,994 stars) now points to letta-code for current source:

npm install -g @letta-ai/letta-code
letta          # terminal UI
letta server   # App Server for local or self-hosted agents

Pricing: Free with your own API keys, limited to 3 stateful agents; Pro is $20 a month; the API plan is $20 a month plus $0.10 per active agent; Teams Pro is $20 a seat a month.

Letta beats Mem0 when you are building the agent itself and want memory to be part of its context, managed by the agent. Mem0 is better when you already have an agent stack and only need a memory API beside it.

7. LangMem: memory for LangGraph apps

LangMem is a library from LangChain. It gives agents tools to save and search memory during a conversation (“in the hot path”), plus a background manager that extracts, consolidates and updates what the agent knows. Memories live in LangGraph’s long-term memory store.

pip install -U langmem

MIT, 1,692 stars, last commit 9 September 2026, no tagged releases on GitHub.

LangMem beats Mem0 when you already run LangGraph, since it adds no new service and no new bill. Mem0 is better when you are not on LangGraph, or want a hosted API with a dashboard.

Which alternative builds memory from documents?

8. Cognee

Cognee turns documents, code and conversations into a knowledge graph your agents can search. Apache-2.0, 31,260 stars, v1.6.2 on 29 September 2026. With no LLM key set, it extracts the graph with a local GLiNER model and local embeddings. From its README:

uv pip install "cognee[gliner]"
cognee-cli remember "Marie Curie was born in Warsaw." -d local_quickstart
cognee-cli recall "Where was Marie Curie born?" -d local_quickstart

The cloud is free for 1 workspace and 1 million tokens; Standard is $1.00 per million tokens processed plus $5 a month per extra workspace, with Slack, Notion, Linear and Google Drive connectors.

Cognee beats Mem0 when memory should come from a body of documents, or must run entirely on your own machines. Mem0 is better when memory is mostly what users said in chat.

Which alternatives keep memory a person can read?

Every product above stores memory you query through an API. If the question is “what do our agents actually know?”, you want memory you can open and read.

9. Basic Memory

Basic Memory writes memory as markdown files with wikilinks, which Obsidian can open as a vault. Local use is free under AGPL-3.0 (4,070 stars). Cloud sync is $15 a seat a month ($13 at 10 seats, $12 at 20) or $30 for Business with SSO and audit logs, with a 7-day trial.

Basic Memory beats Mem0 when one person wants memory as notes they can edit. Mem0 is better when you need memory for the end users of an app.

10. Dexio: one wiki for all your agents

Dexio is ours. It is a hosted wiki that agents read and write over MCP at https://app.dexio.wiki/mcp. Memory is linked markdown pages, not extracted facts: agents search, read, write and edit pages, every change names the agent that made it, and history is kept in full on every plan. People see what their agents know as a page graph. Claude Code, Codex, Cursor, Hermes Agent, OpenClaw, Claude and ChatGPT connect to the same wiki, so what one agent writes, the others can read.

Pricing: free for one person (unlimited pages, 100 MB of storage); Team is $10 and Business $20 a member a month, with 1 GB and 10 GB of storage per member. Open source under AGPL-3.0. Agents that run commands can set themselves up from dexio.wiki/agents.md. The idea behind it is Karpathy’s LLM wiki; LLM wiki vs RAG covers when pages beat retrieval.

Dexio is not a drop-in Mem0 replacement. It has no per-end-user memory API for your app’s customers; use Mem0, Zep, Supermemory or Hindsight for that. Dexio fits when several agents, often on different machines, need one shared memory that your team can read.

Which Mem0 alternatives are actively maintained?

From the GitHub API on 1 October 2026. Every project here had a commit in the last month.

Letta’s last release in this repo is from May because development moved to letta-code. Dexio’s v1.0.0 came out on 30 September 2026.

Should I trust memory benchmarks?

Read them as claims. Memory vendors publish scores on LoCoMo, LongMemEval and similar tests, each with its own setup, models and choice of rivals. Every number on this page is vendor-published, and several of the comparison posts ranking for “mem0 alternatives” are written by a vendor that lists its own product first. This page has a vendor too: Dexio is ours, and it sits near the end because it solves a different problem. Test two or three candidates on your own conversations before you switch.

How do I choose a Mem0 alternative?

• Per-user memory in an app, cheapest start: Mem0 (10,000 free adds a month) or Supermemory ($5 of free credits).
• Facts that change over time: Zep, or Graphiti self-hosted.
• Every feature self-hosted at no cost: Hindsight, Cognee, or Mem0’s own open-source server.
• Already on LangGraph: LangMem.
• An agent that manages its own memory: Letta.
• Conversations with several participants: Honcho.
• Memory built from documents: Cognee.
• Notes one person can read and edit: Basic Memory.
• Several agents sharing one memory your team can see: Dexio.

Our guide to agent memory covers the layers below these, from memory files to RAG, and Mem0 vs Zep vs Supermemory goes deeper on the three hosted APIs. If you only need one coding agent to remember a project, Claude Code memory may be enough.

FAQ

What is the best open-source alternative to Mem0? It depends on what you store: Graphiti for facts that change over time, Hindsight for a full MIT memory system you self-host, Cognee for documents. Mem0 itself is Apache-2.0 and can be self-hosted.

Does Mem0 include graph memory on the free plan? No. Its pricing page lists graph memory on Pro ($249 a month) and Enterprise only.

Is Zep cheaper than Mem0? Not at the start: Zep’s paid plans begin at $125 a month, Mem0’s at $19. Zep does not charge for retrieval; Mem0 caps retrievals on each plan.

Does Mem0 have an MCP server? Yes, a hosted one. Setup, and what happened to its older local OpenMemory server, are in our MCP memory servers roundup.

Sources

• https://mem0.ai/pricing
• https://docs.mem0.ai/open-source/overview
• https://github.com/mem0ai/mem0
• https://www.getzep.com/pricing/
• https://github.com/getzep/graphiti
• https://supermemory.ai/pricing/
• https://github.com/supermemoryai/supermemory
• https://vectorize.io/pricing
• https://hindsight.vectorize.io/
• https://github.com/vectorize-io/hindsight
• https://honcho.dev/
• https://github.com/plastic-labs/honcho
• https://memorilabs.ai/pricing
• https://github.com/MemoriLabs/Memori
• https://memos.openmem.net/
• https://github.com/MemTensor/MemOS
• https://docs.letta.com/pricing
• https://docs.letta.com/v1-sdk/memory/memory-blocks
• https://github.com/letta-ai/letta
• https://langchain-ai.github.io/langmem/
• https://github.com/langchain-ai/langmem
• https://www.cognee.ai/pricing
• https://github.com/topoteretes/cognee
• https://basicmemory.com/pricing
• https://github.com/basicmachines-co/basic-memory
• https://dexio.wiki/agents.md
• https://dexio.wiki/docs/
• https://dexio.wiki/pricing/
• https://github.com/dexio-wiki/dexio