Comparisons
Cozy compared with Mem0, Zep, Letta and Supermemory
Mem0, Zep, Letta and Supermemory are developer memory layers: APIs or runtimes that extract and retrieve facts inside an app you build. Cozy is a different kind of tool, a hosted Markdown wiki that any MCP client reads and writes. Choose the developer layers for high-volume per-user recall inside a product. Choose Cozy when you want readable, auditable memory that people can edit.
We make Cozy, so read this with that in mind. Cozy (cozy.cloud) is operated by Coral Sourcing LLC and is not affiliated with Cozy Cloud (cozy.io) or Cozi.
Two different shapes of memory
Mem0, Zep and Supermemory are services you call from code. Letta is an agent runtime. Cozy is a workspace of plain files with a hosted MCP endpoint.
- Mem0 is a memory layer for agents and apps with an extraction API. Its April 2026 changelog describes ADD-only extraction, so nothing is overwritten or deleted.
- Zep is a temporal knowledge graph. Graphiti, its open-source engine, stores facts as edges with validity windows and invalidates old facts instead of deleting them.
- Letta is an open-source runtime where the model edits its own memory. Its MemFS keeps memory as git-backed Markdown with a root MEMORY.md and a skills folder.
- Supermemory is an MIT-licensed memory and context engine with connectors and a hosted MCP server. See the repository.
- Cozy stores Markdown, text, JSON and CSV. Your own agent connects over MCP. Cozy runs no model itself, uses no embeddings or vector database, and search is lexical.
Comparison at a glance
| Question | Mem0 | Zep | Letta | Supermemory | Cozy |
|---|---|---|---|---|---|
| Main shape | Memory API | Temporal graph API | Agent runtime | Memory and RAG engine | Hosted Markdown wiki |
| How memory is stored | Extracted memories | Graph facts and episodes | Git-backed Markdown (MemFS) | Extracted memories, auto graph | Files you can open and edit |
| Who runs the model | Mem0 or your LLM key | Zep | Letta agent | Supermemory | Your own agent |
| Retrieval | Semantic | Graph and temporal | File based by default | Semantic and RAG | Lexical search plus graph |
| Graph | Entity linking, no typed relations | Bi-temporal edges | None built in | Automatic edges | Typed relations from Markdown |
Sources: Mem0 graph docs, Graphiti, Letta MemFS, Supermemory.
Where the developer layers are better
Be honest about the trade. Cozy does not do automatic fact extraction and has no vectors.
- Automatic recall at scale. Mem0, Supermemory and Zep extract and index facts without an agent writing pages. If your product serves many end users, that is the right model.
- Temporal facts. Graphiti models when a fact was true and when it was recorded. Cozy approximates freshness with
as_offrontmatter, stale-page detection andCONFLICT:lines, which is coarser. - Semantic retrieval and files. Supermemory ships connectors and file processing. Cozy has connectors too, but its search is lexical.
- Enterprise deployment. Zep offers managed cloud, customer-held keys and VPC deployment.
- An agent harness. Letta gives you the whole runtime. Cozy leaves the agent to you.
We make no benchmark claims. Vendor-reported LoCoMo and LongMemEval scores use different judges and settings, and Mem0's own benchmark page lists several factors that change the numbers.
Where Cozy fits
Cozy suits individuals who want the memory itself to be a document they can read.
- Readable and portable. Pages are Markdown files with frontmatter. There is no export step, because the files are the data.
- Typed graph from plain text. Frontmatter,
relation:: [[target]]lines and triples become typed relations on every save. Mem0's docs say it does not create typed, labeled relationships. - Governed agent access. OAuth agents get only the scopes granted, within the person's own access. Bearer credentials have read, wiki-write and source-write scopes, optional folder-prefix grants, a 90-day maximum life and revocation. Agents cannot see connector credentials or permanently purge.
- Safe writes. Edits need an
expectedRevision, so concurrent edits return a conflict. Deletes are tombstones, and the last 50 revisions can be read and restored. - Quality checks. Health scores broken links, stale pages, conflicts, orphans and unsourced pages, and lists fixes in priority order.
- Dreaming. Your own agent runs a consolidation pass using
cozy_healthandcozy_changes, then records the run inagents/dream/state.md. Mem0 and Letta also use dream-style language, so the difference is that here the output is a Markdown page you can review. See memory consolidation.
Zep has argued that Markdown breaks down with concurrent writes, stale facts, contradictions and no audit trail, in its post Markdown is not agent memory. Cozy answers those points with revision checks, Health lint, CONFLICT: lines, restorable history and scoped credentials. Whether that is enough for your workload is your call.
Connecting an agent
Each account has one hosted MCP URL, https://cozy.cloud/mcp. For Claude Code, add it and run /mcp to sign in:
claude mcp add --transport http --scope user cozy https://cozy.cloud/mcp
For scripts and headless agents, use a workspace URL, https://cozy.cloud/wiki-mcp/WORKSPACE_UUID, with a bearer credential from Agents.
Tools include cozy_context, cozy_graph, cozy_search, cozy_write, cozy_edit and cozy_restore. Push documents from scripts with the ingest API. Setup guides: Claude Code, Codex and the general MCP server page.
Which to choose
- Building an app that remembers many end users automatically: Mem0 or Supermemory.
- Needing temporal fact modeling or enterprise deployment: Zep.
- Wanting one runtime where the agent manages its own memory: Letta.
- Wanting a wiki you and your agents both edit, with scoped access and history: Cozy.
These are not exclusive. A product can use an extraction API for its users while a person keeps their own working knowledge in a wiki. For the broader picture, see agent memory and built-in AI memory.
Vendor facts above come from the linked vendor pages and may change. Check current plans and limits on each vendor's site.
Frequently asked questions
Is Cozy a replacement for Mem0, Zep, Letta or Supermemory?
Usually not. Those tools extract and retrieve memory for apps or run agents, while Cozy is a hosted Markdown wiki your own agent reads and writes over MCP. See agent memory for how the pieces fit.
Does Cozy use embeddings or a vector database?
No. Cozy search is lexical and the graph is derived from Markdown conventions such as frontmatter, wikilinks and relation:: lines. Cozy also runs no model itself, so you bring your own agent.
How does Cozy handle concurrent agent writes?
Every edit needs an expectedRevision, and a concurrent edit returns a conflict instead of overwriting. Deletes are tombstones and the last 50 revisions can be restored.
Can I limit what an agent can touch in Cozy?
Yes. Bearer credentials have read, wiki-write and source-write scopes with optional folder-prefix grants, and they expire within 90 days and can be revoked. They never exceed your own access. See MCP server.
What does Cozy cost?
Cozy has no public pricing on this page, so we do not quote one. Check the FAQ or the app for current plan details.
Give your agents a memory worth keeping
Cozy gives every account a private wiki that Claude, Codex, ChatGPT and other MCP clients can read and maintain.
Start your wiki