Mem0 vs Graphiti vs Cognee vs Honcho: which open source agent memory fits?

Short answer

All four are open source memory layers for AI agents, built around different ideas. Mem0 extracts facts from conversations and stores them per user or agent. Graphiti, the engine inside Zep, builds a temporal context graph that keeps track of when facts were true. Cognee turns documents, code and conversations into a knowledge graph. Honcho models the people and agents in a conversation. Pick by what you need to remember.

Four ideas of what memory is

These four tools come up when developers look past the managed memory platforms toward something they can run themselves. They solve the same problem, giving an agent memory beyond its context window, but they disagree on what is worth remembering.

  1. Mem0 treats memory as facts. It extracts facts from messages, stores them under a user, agent or run, and returns the relevant ones later. Its open source retrieval combines semantic, BM25 and entity matching. Graph memory is a separate Platform feature. More on the product itself in What is Mem0?
  2. Graphiti treats memory as a graph that changes over time. Facts get validity windows; when a fact stops being true it is invalidated, not deleted, so you can ask what is true now or what was true then. Retrieval combines embeddings, BM25 and graph traversal. Graphiti is the graph framework inside Zep, the hosted product.
  3. Cognee treats memory as a knowledge graph built from your material: documents, code and conversations become chunks, entities and concepts. Its current API centers on remember, recall, improve and forget.
  4. Honcho treats memory as an understanding of the participants. Every human or agent is a “peer”, and Honcho reasons in the background over messages to draw conclusions and keep a representation of each peer, which you can query in plain language through its chat endpoint.

Side by side, as of November 2026

Mem0 Graphiti Cognee Honcho
What it is Memory layer that extracts facts Framework for temporal context graphs Memory platform that builds a knowledge graph Memory infrastructure that models peers
Storage model Vector store with semantic, BM25 and entity matching; graph memory is Platform-only Graph database: Neo4j, FalkorDB or Amazon Neptune Graph plus vector stores; embedded databases locally PostgreSQL with pgvector
Handling change New facts extracted when you add Old facts invalidated with a time window, history kept improve enriches memory and applies feedback; forget removes items Background reasoning updates conclusions and representations
Open source license Apache 2.0 Apache 2.0 Apache 2.0 AGPL-3.0
Hosted option Mem0 Platform Zep (managed or in your own cloud) Cognee Cloud api.honcho.dev
Best for Personalization: remembering preferences per user or agent Facts that change, where you need to know what was true when Making a body of documents and code queryable as a graph Agents that need to understand the people they talk to

Not every tool documents every detail. Cognee’s README calls Postgres as a graph store a demo feature, and Mem0’s migration guide states that graph memory has been removed from the open source SDK. Where a cell is general, the sources were too.

The misunderstanding: graph memory means one kind of thing

“Graph” appears in three of the four, and it means something different each time. Mem0 Open Source combines semantic, keyword and entity matching without a graph database; graph memory is a Platform feature. In Graphiti the graph is the memory itself, and time is part of every fact. In Cognee the graph is built from documents and is the thing you search. Honcho is not built around a graph at all: it keeps observations as vector-embedded documents per observer and observed peer. So “graphiti vs mem0” is not a contest between two graph databases. It is a choice between a time-aware fact graph you run yourself and a fact extractor with entity-boosted search. The same idea applies to the managed tools in Mem0 vs Zep vs Supermemory vs Letta.

Which one, by question

  1. “Remember what this user prefers.” Mem0 or Honcho. Mem0 stores the facts; Honcho tries to understand the person behind them.
  2. “What did we agree, and is it still true?” Graphiti, because invalidated facts keep their history. Running its MCP server for a team has limits of its own; see the Graphiti MCP server.
  3. “Make our documents and repos answerable.” Cognee, which starts from the material rather than from the chat.
  4. “I am building the agent in LangGraph.” LangMem is the lightest choice, a library inside your agent rather than a service next to it.

What this means for a team

These tools support different deployment and sharing models. Honcho documents shared memory across coding-agent plugins configured for the same workspace. Cognee offers Claude Code and Codex plugins and an MCP integration. Mem0 scopes by user and agent, and Cognee Cloud adds dataset permissions. Evaluate each product’s permissions and sharing configuration for your team. If you are wiring memory into your own agent, start with how to give an LLM long-term memory.

Where Bombos fits

Bombos is not another library to build into your agent. It is a plugin: a shared memory layer underneath the AI your team already uses, from Claude, ChatGPT, Copilot, Grok, Codex, Cursor and your own agents. It learns how your team works, draws on what already sits in mail, documents and repos, and shows with every answer what it rests on. It runs in the cloud in Europe or standalone on your own server, and one person can try it first with their own agents.

Related questions

Which of the four can I run fully on my own servers?

All four. Mem0 and Cognee are Apache 2.0, Graphiti is Apache 2.0 and self-hosted only, and the Honcho server is open source under AGPL-3.0. Each also has a hosted route: Mem0 Platform, Zep for Graphiti, Cognee Cloud, and Honcho at api.honcho.dev.

Does Mem0 need a graph database like Graphiti does?

No. Current Mem0 Open Source uses semantic, BM25 and entity matching without an external graph database. Graph memory belongs to Mem0 Platform. Graphiti supports Neo4j, FalkorDB and Amazon Neptune.

Why does the AGPL license of Honcho matter?

AGPL-3.0 asks that you share the source of a modified version when you offer it to users over a network. For internal use that is rarely an issue, but if you build a product on a changed Honcho server, check it with whoever handles licenses.

Where does LangMem fit in?

LangMem from LangChain is an MIT-licensed library of memory primitives: it extracts information from conversations and can refine an agent's prompts. It stores through LangGraph's BaseStore or any storage you choose, so it is a toolkit inside your agent rather than a separate memory service.

Sources

  1. getzep/graphiti (GitHub README)
  2. Mem0 Open Source migration: graph memory moved to Platform
  3. topoteretes/cognee (GitHub README)
  4. Cognee documentation
  5. plastic-labs/honcho (GitHub README)
  6. LangMem documentation
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.