mnem vs Letta
Letta: “Letta is the platform for building stateful agents: AI with advanced memory that can learn and self-improve over time.” (repo description, letta-ai/letta) mnem: a content-addressed graph substrate that stores the memory an agent uses, without assuming the agent.
At a glance
| mnem | Letta | |
|---|---|---|
| License | Apache-2.0 | Apache-2.0 |
| Stars | small / pre-launch | 22,305 (GitHub API, 2026-04-26) |
| Embedded / Server | embedded | server (Letta API) + Letta Code CLI |
| LLM at ingest | no | yes; the agent is the writer |
| Content-addressed | yes | no (DB row IDs) |
| Bitemporal | no | partial (Letta tracks message timestamps) |
| WASM target | yes | no (Python server) |
| MCP server | yes | yes (Letta supports MCP integrations) |
| Hybrid retrieval | yes | recall + archival memory; not headlined as hybrid |
| Token-budget retrieval metadata | yes | not exposed |
| 3-way merge | yes | no |
| Reproducible benchmarks in-repo | yes | partial (Letta leaderboard external) |
Feature comparison
| # | Dimension | mnem | Letta | Source |
|---|---|---|---|---|
| 1 | Product shape | memory substrate | agent platform (agents + memory + tools + runtime) | Letta README sha bb52a8900a79 |
| 2 | Memory model | open graph of content-addressed nodes + edges | tiered: core blocks (in-context) + recall + archival | MemGPT paper arXiv:2310.08560 |
| 3 | Who writes memory | the application | the agent itself, via tool calls | Letta docs |
| 4 | LLM at ingest | none | yes; agent decides what to write, promote, evict | MemGPT paper |
| 5 | Identity | content CID | DB row IDs | Letta SDK |
| 6 | History | signed commit DAG | standard DB state with timestamps | Letta SDK |
| 7 | Conflict resolution | 3-way merge | agent-to-agent messaging | Letta docs |
| 8 | Scoping | open (any node label) | agent_id first-class | Letta API |
| 9 | Vector lane | HNSW via mnem-ann | recall / archival via configurable embedder | Letta docs |
| 10 | Sparse lane | BM25 + SPLADE | not first-class | Letta docs |
| 11 | Graph lane | first-class | not first-class | Letta docs |
| 12 | Bindings | Rust + Python + TS + HTTP + CLI + MCP | Python + REST + Letta Code CLI (Node 18+) | Letta README |
| 13 | Cloud | none yet | hosted Letta API + free dashboard | https://docs.letta.com |
| 14 | Model agnosticism | yes (provider-not-tactic) | “fully model-agnostic; recommends Opus 4.5 / GPT-5.2” | Letta README |
| 15 | Headline use-case | agent-memory substrate | “stateful agents that learn and self-improve” | Letta repo description |
Benchmarks (where comparable)
Letta publishes a model leaderboard at leaderboard.letta.com ranking
LLMs on Letta’s agent benchmarks (multi-turn, tool-use, reasoning).
This measures models inside the Letta agent, not retrieval quality of
a memory layer. mnem’s benchmarks measure retrieval R@K over corpora,
not agent task success.
The two systems are not directly comparable on a single number. Letta’s “how well does this LLM run my agent” answers a different question from mnem’s “how well does the substrate retrieve under a fixed embedder.”
mnem’s retrieval numbers under ONNX MiniLM-L6-v2:
| Benchmark | Split | Metric | mnem |
|---|---|---|---|
| LongMemEval | 500 Q | R@5 session | 0.966 |
| LoCoMo | 1986 Q | R@5 session | 0.726 |
| ConvoMem | 250 Q | Avg recall | 0.976 |
Latency (where measured)
| System | Setup | Latency |
|---|---|---|
| mnem | LongMemEval 500 Q, MiniLM ONNX | 711 ms mean retrieve |
| mnem | LoCoMo 1986 Q, MiniLM ONNX | 333 ms mean retrieve |
| Letta | varies wildly with model + tool-use depth | not headlined |
Letta’s user-perceived latency is dominated by the agent loop, not the memory tier. Different mechanism; not comparable.
Architecture differences
Letta is the platform descended from MemGPT. The headline pattern is
tiered memory: core memory blocks held in the LLM’s context window,
recall memory (recent conversation history) accessible via tool calls,
and archival memory (long-term store) similarly accessed by tool. The
agent itself decides what to promote and evict, using the LLM’s own
reasoning. Letta ships as a Python framework, a hosted API, and a
local CLI (letta via @letta-ai/letta-code). The product
optimisation is “give an LLM persistent memory and let it manage the
tiers.”
mnem is one layer below that. There is no agent in mnem. mnem is a
graph substrate: content-addressed nodes and edges, signed commit
history, 3-way merge, hybrid retrieval. If you wanted to build the
MemGPT pattern on top of mnem, you would ship: core_blocks as a
small ad-hoc graph, recall as an HNSW lane over recent commits,
archival as the full graph traversal lane. mnem doesn’t impose any
of that; it gives you the storage primitives and lets you choose the
agent shape.
Where Letta clearly wins
- The agent is in the box. Drop in Letta, you have an agent with memory and tool-use today. mnem requires you to bring your own agent / framework.
- The MemGPT brand and lineage. Anyone reading the agent-memory literature has seen the paper. Letta’s the canonical implementation.
- Hosted API + leaderboard. Comparing models on Letta’s harness is one click.
- Skills + subagents. Bundled patterns for advanced memory and continual learning.
- Multi-agent reconciliation via messaging. Agent-to-agent conversations are first-class.
Where mnem clearly wins
- No agent assumed. Letta’s memory belongs to a Letta agent; mnem’s memory belongs to your application. Port your agent framework next year, the data stays.
- No LLM in the write path. Letta writes to memory through the agent (LLM tool calls). mnem writes deterministically.
- Content-addressed identity. Same fact = same CID across machines.
- Real commit DAG. Diff, log, 3-way merge, signed history. Letta has DB state, not commits.
- Structural multi-agent merge. Two agents working offline in the same scope reconcile by 3-way graph merge, not by chat messages.
- WASM, embedded, single binary. Ship to the edge. Letta is a Python server.
- Hybrid 3-lane retrieval with token-budget metadata. Explicit
RRF over dense / sparse / graph;
tokens_usedper response.
When to pick Letta, when to pick mnem
Pick Letta if: you want the MemGPT pattern in a box, you want a ready-made agent platform with skills and subagents, you want to use Letta’s leaderboard to pick a model, or you are building a single stateful agent rather than a multi-application substrate.
Pick mnem if: you want the memory layer separate from the agent, you need content-addressing and a commit DAG, you are running multiple agent frameworks against the same store, or you need embedded / edge / WASM deployment.
Sources
- Letta repo, sha
bb52a8900a79onmain, 2026-04-26: https://github.com/letta-ai/letta - Letta README (Letta Code CLI, Letta API, model-agnostic note): https://github.com/letta-ai/letta/blob/main/README.md
- Letta docs: https://docs.letta.com
- Letta leaderboard: https://leaderboard.letta.com
- MemGPT paper, arXiv:2310.08560: https://arxiv.org/abs/2310.08560
- mnem README:
/README.md