COMPARISON
causal-memory vs Letta
Letta gives the agent a runtime and editable memory blocks. causal-memory gives any runtime a causal record of decisions and their outcomes.
Updated · English
The short version
Letta — the project that grew out of MemGPT — is an agent runtime. It runs the loop, manages context, gives the agent core memory blocks it can edit, and ships a server plus a desktop environment for inspecting agent state. The memory is part of a complete system, which is why the comparison is not really feature-for-feature.
causal-memory is a memory layer. It does not run an agent loop and does not want to. It exposes 17 MCP tools over a SQLite store, so Claude Code, Cursor, DSH or a custom runtime can record a decision and query it later. You keep your runtime; you add a causal record to it.
That makes the two products complementary far more often than competitive. If you are choosing a runtime, Letta is a candidate. If you already have a runtime and need it to remember why a decision worked, causal-memory is the smaller, more targeted addition.
The one place they genuinely overlap is the write path: both expect the agent to decide what is worth remembering. Letta does it by letting the agent edit memory blocks. causal-memory does it through explicit record_decision and record_fact calls, with a bundled skill that teaches the agent when to call them.
causal-memory vs Letta, capability by capability
The last block of this table is deliberate: it lists the places where causal-memory is the weaker choice. A comparison page that only has winning rows is an advertisement.
| Capability | causal-memory | Letta |
|---|---|---|
| Product category | Memory layer over MCP; bring your own agent loop | Stateful agent runtime with memory, server and desktop environment |
| Memory model | Facts plus a typed causal graph in one SQLite file | Core memory blocks the agent edits, plus archival and recall memory |
| Causal semantics | caused / enabled / prevented / no_effect, each with a spread coefficient | Block contents are prose; there are no typed causal or inhibitory edges |
| Learning from failure | prevented edges spread negative activation and feed intervention_query | The agent can write a lesson into a block; there is no ranking semantics for 'this prevented that' |
| Memory inspection | MCP tool output and the SQLite file; no UI | A desktop environment for inspecting and editing agent memory |
| Runtime lock-in | None — any MCP client, or the HTTP transport | Memory lives inside the Letta runtime and its server |
| Operational footprint | One binary and one SQLite file | Agent server plus a database; Docker compose is provided |
| Compaction survival | 100% causal recall at 5x compaction, measured | Context management is a first-class design concern; we have not run Letta on our compaction harness |
| CausalEval numbers | C7 100%, C3 95%, C2 75%, C4 80% (140q, v13) | Letta was not run on CausalEval, so this page publishes no Letta score |
| Where causal-memory is weaker — read this before the pitch | ||
| Agent runtime | We are not one. You keep your loop and your orchestration | A complete stateful agent runtime, server and desktop environment |
| Self-editing memory | Writes are explicit tool calls; a bundled skill teaches the agent when to make them | The agent edits its own memory blocks as part of the loop |
| Tooling and UI | No dashboard; inspect through MCP output or SQLite | Agent Development Environment for inspecting and editing memory |
| Managed hosting | Hosted memory is early; self-hosting is the documented path | A cloud offering for teams that do not want to run the server |
| Community and maturity | Small team, v0.10.0-alpha, Apache-2.0 | A larger project with more integrations and examples |
| Fact recall | 79.1% on LoCoMo (strict judge) | Not measured by us; mem0 leads this suite at 91.6% |
When to choose each one
Choose Letta when
- You have not chosen an agent runtime yet and want memory, context management and a UI in one system.
- You want the agent to edit its own memory blocks without an external memory service.
- You want a desktop environment for inspecting what an agent remembers.
- You are building on the MemGPT architecture and want its descendants.
Choose causal-memory when
- You already run Claude Code, Cursor, DSH or a custom loop and do not want to migrate it.
- You need typed causal edges and a pre-action warning, not prose blocks.
- You want memory as a swappable MCP server with no runtime lock-in.
- You want local-first storage in one file that a human can inspect with sqlite3.
The numbers, with their provenance
Source: causal-memory README v0.10.0 · CausalEval v13, read 2026-10-21. The baseline column is the mem0 run on the same 70-question protocol; we did not run this system on CausalEval and do not publish a score for it.
| Capability | causal-memory | mem0 (70q baseline) | What it tests |
|---|---|---|---|
| C7 Update | 100% | 80% | Supersede an old belief after it is falsified, and keep the old edge retrievable |
| C3 Counterfactual | 95% | 80% | Choose between alternatives with known outcomes |
| C2 Intervention | 75% | 40% | Forward prediction: if X happens again, what follows? |
| C4 Inhibition | 80% | 50% | Separate the root-cause fix from the blast-radius limiter |
| C1 Attribution | 85% | 90% | Walk a backward causal chain to the root cause |
| C5 Temporal-causal | 90% | 90% | Order events on a causal chain |
| C6 Lesson transfer | 20% | 30% | Cross-task analogy through meta edges — still an open limitation |
| Overall | 78% | 65% | All C1-C7 classes weighted equally |
The same table appears on every comparison page, with the same baseline, so the numbers cannot drift between pages. For the fact-recall suites where mem0 leads, see the mem0 comparison.
What the difference looks like in practice
This is mostly a layer question, not a winner question. Pick Letta if you need a runtime; add causal-memory if you need a causal record inside the runtime you already have. Teams that want both can mount causal-memory into a Letta agent over MCP and keep the causal graph outside the context window.
- Both systems can be mounted at once. Nothing in causal-memory requires you to remove an existing memory layer.
- The comparison is about the stored object, not about which project is better engineered.
- Every claim about the competitor on this page is either a public product fact or a row from the causal-memory README differentiation table.
Letta questions, answered plainly
- Is causal-memory a Letta alternative?
- No. Letta is a runtime; causal-memory is a memory layer. They compete only if you treat 'memory' as the whole product. If you need an agent loop, Letta provides one and causal-memory does not.
- Can a Letta agent use causal-memory?
- If the runtime can mount MCP servers, yes. causal-memory exposes stdio and HTTP MCP transports, so it sits beside the runtime rather than inside it. The causal table stays in its own SQLite file.
- Letta already has memory blocks. Why add causal edges?
- Blocks hold prose the agent wrote. Edges are queryable, ranked and typed: a prevented edge lowers the rank of an approach that failed, and intervention_query can return a forward chain before the agent acts. Prose can record a lesson; it cannot rank one against another at retrieval time.
- Which one puts less into the context window?
- causal-memory returns a small ranked chain instead of whole blocks, so the per-turn token cost is usually lower. The trade-off is that the agent must call a tool instead of reading memory that is always present.
- Do you publish Letta benchmark numbers?
- No. Letta was not run on CausalEval or on our compaction harness, and we do not publish scores for systems we did not measure. The comparison above is about scope and design, not about a head-to-head score.
Related
Use case
- Causal memory for a coding agentA coding agent already remembers the diff. Causal memory makes it remember why the diff was wrong the first time.
- Causal memory for a trading research agentA P&L number tells you what happened. A causal decision journal tells you which part of your reasoning was wrong — and what you would have gotten if you had done the other thing.
Integration
- causal-memory with CursorThe same repository, the same compaction problem. Cursor gets a causal record that survives the context window.
- causal-memory with DeepSeek HarnessA native plugin rather than an MCP bridge: 17 tools with clean names, plus a system-prompt section that makes the agent check memory before it acts.
Try causal-memory next to Letta
It installs as an MCP server, stores everything in one SQLite file, and does not require you to remove whatever you already use for facts.