mem20 is an MIT-licensed MCP server that gives AI agents persistent memory with a hard partition between grounded and simulated content, contamination auditing, evidence-based promotion, and an append-only, origin-tagged ledger. 270 tools across 27 domains. Self-hosted. Zero lock-in.
Persistent memory for AI agents — with the audit trail that regulated teams need. Grounded vs simulated, enforced in the architecture.
Every memory layer on the market competes on retrieval quality. None of them lead with auditability — the ability to show why a memory is in the store and where it came from. In a regulated context that is the whole ballgame: you don't need "probably relevant," you need "here is the source, and here is the evidence it was promoted."
A hard grounded/simulated partition plus an append-only origin-tagged ledger tells you where every memory came from.
Auditing detects simulated content bleeding into grounded memory — leak rate 0.000 on clean stores.
MIT licensed, Python, self-hosted. No lock-in, no black box, no vendor holding your audit trail.
Grounded and simulated memory are not the same store with a boolean flag. They are separate classes, so "the agent made this up" is structurally visible instead of silently plausible.
Content that traces to a real source. This is the only class a downstream decision should be allowed to rest on — and every entry carries its origin.
Hypotheses, drafts, inferences and speculative content the model produced. Useful, kept, and quarantined by construction — never silently indistinguishable from fact.
Nothing graduates from simulated to grounded by assertion. Content is promoted only with evidence attached to the promotion, and that promotion is recorded. The claim is auditable — an append-only trail you can inspect — not a claim of cryptographic tamper-proofing.
Every memory carries its source. History is written forward and tagged with origin, so the record can't be quietly rewritten after the fact — and an audit can reconstruct what the agent knew, and when.
Benchmarks are self-published on the mem20 v2.1.0rc2 harness. We show the full table — including the adversarial row — because a memory layer you're meant to audit shouldn't get to hide the row it loses.
| Query class | Hit rate | What it means |
|---|---|---|
| Direct recall | 1.000 | Explicit, well-formed lookups resolve reliably. |
| Multi-hop | 0.800 | Chains that require composing several memories. |
| Adversarial known weakness | 0.000 | Hard adversarial queries defeat the retrieval path today. On the roadmap — not hidden. |
| Leak rate (clean stores) | 0.000 | No simulated content detected bleeding into grounded memory. |
These benchmarks are self-published on our own harness. mem20 does not yet have a published LoCoMo or LongMemEval result comparable to Mem0 or Zep, so we make no parity claim and cite no one else's figure as ours.
The 0.000 adversarial hit rate is a genuine limitation, not a marketing footnote: an adversary who knows how to phrase around the retrieval path can defeat it today. If your threat model includes adversarial query injection, weigh that honestly.
The mature players have more benchmark mileage and, in several cases, larger communities. mem20's bet is orthogonal: none of them leads with provenance. Figures below are the vendors' own published claims and pricing, verified October 2026; we present them as claimed, not as independently confirmed.
| mem20 | Mem0 | Zep / Graphiti | Letta (MemGPT) | |
|---|---|---|---|---|
| Approach | Memory + cognition substrate with a grounded/simulated partition | Extract-and-retrieve memory layer | Temporal knowledge graph | Stateful agent runtime, self-editing memory |
| License | MIT | Apache 2.0 | Managed / enterprise | Apache 2.0 |
| Provenance & audit surface | Grounded/simulated partition + contamination auditing + append-only origin-tagged ledger | Not positioned as an audit layer | Temporal graph edges; auditability not a lead claim | Self-editing memory; no provenance partition |
| Vendor-published benchmark | Hit rate 1.000 / 0.800 / 0.000 · leak 0.000 own harness | LoCoMo 92.5 · LongMemEval 94.4 | DMR 94.8% | LoCoMo 74.0% |
| Independent benchmark | Not published no comparable LoCoMo/LongMemEval | 49.0 on LongMemEval reported in independent testing 45-point gap vs vendor claim | Not in our verified set | Not in our verified set |
| Pricing | Free & open source — self-host | Free → $19 → $79 → $249 (graph) → Enterprise | Flex $125/mo (50k credits) · Flex Plus $375/mo · Enterprise | Free → Pro $20/mo → API $20/mo + $0.10/active agent/mo |
| Community signal | v2.1.0rc2 — early | ~59.9k stars · $24M Series A | Managed platform | ~23.6k stars · $10M seed |
Mem0 and Letta are Apache-2.0 and self-hostable too, and both have substantially more production mileage than mem20. Zep's temporal graph is a genuinely different design that solves problems our ledger does not attempt. The row that matters here is provenance: this is the one axis where mem20 leads, and it leads by positioning, not by a headline benchmark number.
Three limits we'd rather state ourselves than have someone else discover in production.
mem20 has no published benchmark comparable to Mem0 or Zep. We do not imply parity, and we never present their numbers as ours.
Hard adversarial queries defeat the retrieval path today. It's on the roadmap, and it stays visible wherever the benchmark table appears.
A self-attestation hole in the promotion gate was flagged in a prior audit. Promotion is auditable, with an append-only trail — not unfakeable, and not cryptographic.
If your memory layer is the thing you have to audit, you can't audit someone else's black box. mem20 is MIT-licensed and self-hosted by design — and not yet on PyPI, so install is from source.
# not on PyPI — install from source git clone https://github.com/bythewayz66-glitch/mem20 cd mem20 python3 -m venv .venv .venv/bin/pip install -r requirements.txt # run the MCP server over stdio (JSON-RPC 2.0) MEM20_STORE_PATH=~/.mem20/store .venv/bin/python mcp/mcp_server.py
Auditable agent memory — two memory classes, a promotion gate with a trail, and a ledger that keeps the receipts.