Mem0 Alternatives: Supermemory, Letta, Zep, Cognee and a Shared Board

The main Mem0 alternatives are Supermemory, Letta, Zep and Cognee, and they are less interchangeable than the phrase “memory layer” suggests. Supermemory is a managed context platform that ingests documents and connectors as well as chats. Letta is a whole agent harness whose agents manage their own memory as files. Zep is a governed context layer for enterprise data built on temporal graphs. Cognee turns documents, code and application data into graph-based memory, and is open source. And if what you actually want is a record of work, rules and progress that people and every AI app can read and edit, that is a shared board rather than a memory engine. Pick by the reason you are leaving, not by a ranking. Everything below is from each vendor’s own documentation as of October 8, 2026.

First, why are you looking?

• You want the engine to ingest files, email and drives, not just conversation turns.
• You want an agent that keeps and reorganizes its own memory, rather than an API your code calls.
• You need governance: role-based access, policy limits on what each agent can retrieve, audit logs.
• You want an open-source pipeline you can bend, with graphs over your own data.
• You are not building an app at all. You use ChatGPT, Claude and Cursor for work and want them to share one memory you can see.

The first four point to the engines below. The last points somewhere else, covered at the end. If you have not used Mem0 itself, what is Mem0 is the starting point, and the general checklist is in choosing an agent memory system.

Supermemory: documents, connectors and a memory graph

Supermemory calls itself context infrastructure for AI agents: memory, retrieval and user profiles through one API. You send it documents, which can be chat transcripts, PDFs, URLs or items synced from Google Drive, Gmail, Notion, OneDrive, GitHub and others, and it extracts memories that link to each other as facts update, extend or are inferred from earlier ones. Its isolation unit is the namespace↗ (opens in a new tab), and each namespace is backed by its own vector index.

Pick it if your agent needs to remember users and also search their files, and you would rather not run retrieval yourself. A self-hosted binary exists, but its server is not open source. The detailed comparison is in Mem0 vs Supermemory, and the product on its own in what is Supermemory.

Letta: agents that manage their own memory

Letta is not a memory API in the same sense. It is an open-source agent harness, from the team that created MemGPT, whose agents keep long-term memory in MemFS. Letta’s MemFS documentation↗ (opens in a new tab) describes it as a git repository that belongs to the agent: Markdown files the agent reads and edits with ordinary file tools, every edit committed, so memory has version history. Background “dreaming” subagents review recent conversations and consolidate what was learned. Agents run from a CLI, a desktop app, the web or messaging channels, and can run fully locally.

Pick it if you want a persistent agent, a coworker or personal assistant, rather than memory bolted onto an agent you already have.

Zep: governed context for enterprise data

Zep describes itself as the unified context layer for enterprise data, combining business data, documents and conversations into temporal Context Graphs. Facts carry time ranges, so an old fact can be marked no longer valid while its history is kept. For agent memory you create a Zep user, add messages to threads, and fetch a Context Block before the next model call. Its governance documentation↗ (opens in a new tab) covers role-based access for people in the dashboard, policy-based limits on what each agent’s API key can reach, source traceability and audit logs.

Pick it if compliance and access policy are the hard part of your project. Its open-source graph framework, Graphiti, is available if you want to build on the same ideas yourself.

Cognee: open-source memory from your own data

According to Cognee’s documentation↗ (opens in a new tab), it turns documents, code and application data into persistent AI memory that agents and applications can store, query and improve over time. It is Apache 2.0 licensed, has an MCP server for clients such as Cursor and Claude Code, and offers a managed Cognee Cloud. Pick it if your memory starts from a body of documents or code rather than from chat, and you want to own the pipeline.

The structural differences at a glance

             Unit of memory           Who writes it        Self-host
Mem0         extracted facts          the model, via API   open source
Supermemory  documents + memories     the model, via API   binary (not OSS)
Letta        agent's own files        the agent itself     yes, local runtime
Zep          temporal graph facts     the model, via API   Graphiti (OSS)
Cognee       graph over your data     pipeline you run     open source
Shared board tasks, rules, notes      people + assistants  no (web app)

How to test an alternative in an afternoon

1. Take twenty real conversations, with personal data removed, including a few where a fact changes halfway, such as a new job or a new address.
2. Load them into Mem0 and into one alternative, scoped to two or three test users.
3. Ask each the same ten questions, including one about the fact that changed and one that should return nothing for the wrong user.
4. Correct one wrong memory in each and time how long it takes, and whether the old version still comes back.
5. Write down what each costs you to operate: services to run, keys to manage, models to call.

Step three tells you about retrieval and isolation, step four about correction, and step five about the part a demo never shows. If two engines tie, pick the one whose model of memory your team can explain to each other in a sentence.

When to stay with Mem0

If your reason for looking is a missing feature, check Mem0’s Platform vs Open Source comparison↗ (opens in a new tab) first. Graph memory, webhooks, export, organizations with member roles and a project-wide event feed exist on the managed Platform but not in open source, so a team that only tried the library may be missing them. If you are building an AI app for your users, Mem0 remains a strong choice, and so do the four above. Run the same small test against two of them before deciding.

When none of them is the answer

All of these engines are developer infrastructure. An app or agent calls them, the model decides what to keep, and the end user rarely sees the memory. They are stronger than any board at scale, speed, retrieval and compliance, and they should be.

They are not built for a different and common problem: a person or team that uses several AI apps for work and keeps re-explaining the project to each one. What is missing there is not extraction but a shared record people can read, correct and own. Built-in memory in ChatGPT or Claude helps inside one vendor, as ChatGPT project memory and Claude project memory explain, but it stays with that vendor.

fenbs is a web app built for that case. Your projects, tasks, Decisions and rules, lessons learned and Where we left off sit on one board, and ChatGPT, Claude, Claude Code, Codex, Cursor and others read and update it over MCP. People write the rules; assistants follow them and cannot decide a decision or pre-approve work. A note an assistant adds is signed with its name, and History records every change by the person or assistant who made it. Switch apps or models and the context is still there. It is free to start.