# Cozy compared with Mem0, Zep, Letta and Supermemory

> How the Cozy wiki (cozy.cloud) differs from the Mem0, Zep, Letta and Supermemory developer memory layers: storage, graph, access control, MCP and where each one is the better pick.

Updated 2026-11-09. Canonical: https://cozy.cloud/compare/mem0-zep-letta-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](https://docs.mem0.ai/changelog) describes ADD-only extraction, so nothing is overwritten or deleted.
- **Zep** is a temporal knowledge graph. [Graphiti](https://github.com/getzep/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](https://docs.letta.com/concepts/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](https://github.com/supermemoryai/supermemory).
- **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](https://docs.mem0.ai/platform/features/graph-memory), [Graphiti](https://github.com/getzep/graphiti), [Letta MemFS](https://docs.letta.com/concepts/memfs), [Supermemory](https://github.com/supermemoryai/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_of` frontmatter, stale-page detection and `CONFLICT:` 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](https://www.getzep.com/) 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](https://mem0.ai/blog/locomo-benchmark) 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](https://docs.mem0.ai/platform/features/graph-memory).
- **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](/wiki-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_health` and `cozy_changes`, then records the run in `agents/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](/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](https://www.getzep.com/blog/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](/connect/claude-code), [Codex](/connect/codex) and the general [MCP server](/mcp-server) page.

## Which to choose

1. Building an app that remembers many end users automatically: Mem0 or Supermemory.
2. Needing temporal fact modeling or enterprise deployment: Zep.
3. Wanting one runtime where the agent manages its own memory: Letta.
4. 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](/agent-memory) and [built-in AI memory](/compare/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](/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](/mcp-server).

### What does Cozy cost?

Cozy has no public pricing on this page, so we do not quote one. Check the [FAQ](/faq) or the app for current plan details.
