COMPARE · COMPARISON: AGENT MEMORY

Mem0 alternatives in 2026: 8 agent memory tools, with published tests

AUTHOR · XERJ documentation team · REVIEWED BY · XERJ engineering team · PUBLISHED · 2026-11-15 · UPDATED · 2026-11-15

SHORT ANSWER · UPDATED 2026-11-15

What are the best Mem0 alternatives in 2026? It depends on the job. In our open benchmark ReMe hybrid and XERJ found the right memory in the top 5 for 93.3% to 94.7% of questions, against 88.0% for Mem0. Zep and Graphiti fit temporal knowledge graphs, Letta fits stateful agents, and Cognee fits document graphs.

Key number: On the same 85 memories and 75 questions, XERJ semantic recall found the right memory in the top 5 for 94.7% of questions, ReMe hybrid 93.3%, mcp-memory-service 89.3% and Mem0 88.0%. (as of 2026-10-31 · source: github.com/xerj-org/xerj/tree/main/benchmarks/agent-memory)

Last checked: 2026-11-15. Every third-party fact on this page was re-read from the tool's own docs or repository on that date.

TL;DR The best Mem0 alternative depends on what your agent needs. For a memory API with no model call on write, ReMe, mcp-memory-service and XERJ matched or beat Mem0 in our open benchmark: 93.3% to 94.7% top 5 recall against 88.0%. For temporal knowledge graphs, look at Zep and Graphiti. For a full stateful agent, Letta. For a graph built from documents, Cognee.

PASTE THIS TO YOUR AI AGENT — IT DOES THE REST

Act as a coding agent. Read https://xerj.org/llms.txt and https://xerj.org/compare/mem0-alternatives-2026, then pick a memory layer for this project from the table on that page. If no language model may run on each write, try XERJ: install it, start a node with --embed-mode neural, store five facts with POST /_memory/project, change one, and recall each with hybrid recall. Report what you chose and why.

Mem0 is a strong default with 69,009 GitHub stars. It runs a language model on each write to extract facts. The tools below take other paths: plain search over stored text, a knowledge graph, or an agent harness. Background reading: what agentic memory is.

Try it: pick by job

Which Mem0 alternative fits

XERJ, ReMe or mcp-memory-service

All three store memories with no language model call. With MiniLM embeddings they found the right memory in the top 5 for 94.7%, 93.3% and 89.3% of 75 questions in our benchmark. Mem0 raw mode scored 88.0%.

Recall figures from the XERJ agent memory benchmark of 2026-10-31. Tool features from each project README, checked 2026-11-15.

Summary table

Top 5 is the share of 75 questions where the right memory came back in the first five results, from our AI agent memory benchmark. A dash means the tool was not in that round.

Tool	Licence	How it stores memory	LLM call on write	Top 5 in our test	Stars (2026-11-15)
Mem0	Apache-2.0	LLM-extracted facts plus embeddings	yes by default, infer=false turns it off	86.7% (infer) / 88.0% (raw)	69,009
ReMe	Apache-2.0	BM25 plus optional embeddings	no	93.3% (hybrid) / 70.7% (BM25)	3,806
mcp-memory-service	Apache-2.0	SQLite plus local ONNX embeddings	no	89.3%	2,128
MemPalace	MIT	verbatim text, ChromaDB by default	no	84.0%	60,566
agentmemory	Apache-2.0	BM25 keyless, local embeddings opt-in	no	74.7% (keyless)	30,376
Zep and Graphiti	Apache-2.0 (Graphiti)	temporal knowledge graph	yes	not tested	32,821 (Graphiti)
Letta	Apache-2.0	memory blocks in a stateful agent	yes, it is an agent	not tested	3,845 (Letta Code)
Cognee	Apache-2.0	graph of entities plus chunks	optional, GLiNER works without a key	not tested	33,329
XERJ	Apache-2.0	stored text, BM25, semantic or hybrid recall	no	94.7% (semantic) / 93.3% (hybrid)	19,111

When to choose Mem0 instead

Choose Mem0 when you want a language model to read conversations and keep a tidy list of facts for you. It ships as a library, a self-hosted server and a cloud platform, so a team can start in the cloud and move in-house later. In our test, Mem0 raw mode reached 64.0% on the first result, close to the leaders. See XERJ vs Mem0 for a side-by-side.

ReMe: fast, light and keyword first

ReMe comes from Alibaba's Tongyi Lab team. Its default setup is BM25 with no embedding model and no API key, and it answered queries in 1.4 ms in our test. With MiniLM embeddings switched on, it found the right memory in the top 5 for 93.3% of questions. Choose ReMe when write and query speed matter most and a few seconds of indexing delay is fine. Details: XERJ vs ReMe.

mcp-memory-service: memory over MCP with a dashboard

mcp-memory-service stores memories in SQLite with local ONNX embeddings and adds to Claude Code in one line. It scored 89.3% top 5 and adds a knowledge graph dashboard. Its default duplicate check rejected 4 of our 15 updates, which keeps the store tidy for repeated notes. Choose mcp-memory-service when you want an MCP-first memory with a visual graph. Details: XERJ vs mcp-memory-service.

MemPalace and agentmemory: memory for coding agents

MemPalace keeps verbatim text, uses ChromaDB by default and exposes 47 MCP tools. agentmemory captures coding agent sessions through hooks and exposes 54 MCP tools; its keyless mode uses BM25 and scored 74.7% top 5. Choose MemPalace when you want verbatim recall with a rich MCP surface, and agentmemory when you want automatic session capture for Claude Code and other coding agents. Details: MemPalace and agentmemory.

Zep, Letta and Cognee: graphs and agent harnesses

Choose Zep or Graphiti when facts change over time and you want a temporal knowledge graph. Zep Cloud is the managed product; Graphiti is the open framework and needs Neo4j, FalkorDB or Amazon Neptune plus an LLM.
Choose Letta when you want a complete stateful agent with memory blocks, not a memory API you call from your own agent.
Choose Cognee when your memory starts as documents, code and conversations that you want turned into a graph of entities and relationships. It runs locally with a GLiNER model and no LLM key.

The side-by-side is on Mem0 vs Zep vs Letta vs Cognee.

XERJ: memory and search in one local node

XERJ stores exactly the text your agent sends with POST /_memory/{namespace} and recalls it with BM25, semantic or hybrid search. With MiniLM on, it found the right memory in the top 5 for 94.7% of questions. With a recency weight of 0.3 it put the new value of a changed fact first in 14 of 15 cases, at 68.0% top 5 overall. The same node indexes your files, so memory and document search share one API and one MCP server.

XERJ is single-node. It makes no model call on write, so it does not summarise or merge facts for you.

How this page was checked

Recall figures come from our AI agent memory benchmark, run on 2026-10-31 with the same data, the same MiniLM model and one score script for every system. Licences, install lines and features were read from each project's README on 2026-11-15, and star counts came from the GitHub REST API the same day. Tools marked not tested were described from their own documentation.

Try it with XERJ

Use the Copy the prompt button and paste it into your coding agent. It picks a memory layer from this table and, if it picks XERJ, stores five facts, changes one and shows which recall mode found them.

FAQ

What is the closest open-source alternative to Mem0?

For the same job, a memory API you call from your agent, ReMe, mcp-memory-service and XERJ are the closest. In our benchmark all three found the right memory in the top 5 at least as often as Mem0 raw mode (88.0%), with no language model call on write.

Which Mem0 alternative works without an LLM?

ReMe, mcp-memory-service, MemPalace, agentmemory and XERJ all store memories with no model call on write. Cognee also runs without an LLM key, using a local GLiNER model to build its graph. Mem0 runs LLM fact extraction by default, and infer=false turns it off.

Which Mem0 alternative handles facts that change?

In our test, XERJ with a recency weight of 0.3 put the new value of a changed fact first in 14 of 15 cases. That setting lowered overall top 5 recall to 68.0%, so use it for state that changes. Zep and Graphiti model time in a knowledge graph, which we have not tested.

Were Zep, Letta and Cognee benchmarked?

Not yet. They need an LLM call on each write, a graph database or a hosted key, and our first round ran on a shared CPU machine. Their rows on this page come from their own documentation.

Can I run the benchmark myself?

Yes. The 85 memories, 75 questions, one adapter per system and the score script are in benchmarks/agent-memory in the XERJ repository. The full table is on the AI agent memory benchmark page.

How were licences and stars collected?

Licences and install lines come from each project's README, read on 2026-11-15. Star counts come from the GitHub REST API the same day.

Evidence

Top 5 recall on 85 memories and 75 questions: XERJ semantic 94.7%, XERJ hybrid 93.3%, ReMe hybrid 93.3%, mcp-memory-service 89.3%, mem0 infer=False 88.0%, mem0 infer=True 86.7%, MemPalace 84.0%, agentmemory 74.7%. Newest value first on changed facts: XERJ with recency weight 0.3 93.3%, with 68.0% top 5 overall. — benchmarks/agent-memory/out/summary.csv
Top 1 recall: mem0 infer=False 64.0%, XERJ semantic 65.3%. ReMe default BM25 top 5 70.7% with a median query of 1.41 ms; mcp-memory-service rejected 4 of 15 updates as duplicates at its default settings. — benchmarks/agent-memory/out/summary.csv
mem0 infer=True made 1 LLM call per write with Qwen2.5 3B, with a median write of 16.5 s on a shared 8 core CPU machine. — benchmarks/agent-memory/results/mem0__infer.json
Mem0 ships as a library (pip install mem0ai), a self-hosted server (docker compose up) and a cloud platform, under Apache 2.0; its add API runs LLM fact extraction by default and supports infer=false. — https://github.com/mem0ai/mem0
ReMe is Apache-2.0, installs with pip install reme-ai[core], recalls with BM25 plus optional embeddings, and has embeddings disabled by default. — https://github.com/agentscope-ai/ReMe
mcp-memory-service is Apache-2.0, installs with pip install mcp-memory-service[sqlite] for local ONNX embeddings and SQLite storage, and adds to Claude Code with claude mcp add memory -- memory server. — https://github.com/doobidoo/mcp-memory-service
MemPalace is MIT, installs with uv tool install mempalace, uses ChromaDB as its default retrieval backend and exposes 47 MCP tools. — https://github.com/MemPalace/mempalace
agentmemory runs with npx -y @agentmemory/agentmemory@latest; its keyless mode disables vectors so memory_recall uses BM25, and EMBEDDING_PROVIDER=local adds on-device semantic recall. — https://github.com/rohitg00/agentmemory
Zep Cloud is the managed product and Zep Community Edition is deprecated. Graphiti is the Apache-2.0 framework for temporal context graphs and needs Neo4j, FalkorDB or Amazon Neptune. — https://github.com/getzep/graphiti
Letta (formerly MemGPT) builds stateful agents with memory, its current source lives in letta-ai/letta-code, and it installs with npm install -g @letta-ai/letta-code. — https://github.com/letta-ai/letta
Cognee is Apache-2.0, turns documents and conversations into a graph plus searchable chunks, and runs locally without an LLM key using the GLiNER extraction model from cognee[gliner]. — https://github.com/topoteretes/cognee
GitHub stars on 2026-11-15 from the GitHub REST API: mem0 69,009; MemPalace 60,566; Cognee 33,329; Graphiti 32,821; agentmemory 30,376; XERJ 19,111; ReMe 3,806; Letta Code 3,845; mcp-memory-service 2,128. — https://api.github.com/repos/mem0ai/mem0