M3 Memory Comparison · May 2026

# Sovereign Memory Systems Comparison

Honest dimensional comparison of local-first / sovereign memory substrates

## How to read this page

This is a head-to-head against other sovereign / local-first memory substrates — projects competing on data residency, integrity, and offline operation. If you're choosing between M3 and a developer-tool memory layer like Mem0, Letta, Zep, or LangChain Memory, see the developer-facing decision guide instead.

SovereigntyLocal SQLite, local-SLM extraction, zero telemetry by default.
IntegrityBitemporal logic with native undo across valid time and transaction time.
OrchestrationNative MCP handoffs, agent registry, atomic WAL writes.
ComplianceBuilt-in GDPR primitives; aligns with FISMA and CMMC.
How to read the table: M3 leads on retrieval accuracy — 100% session-hit-rate @ k=20 (99.2% @ k=10) on LongMemEval-S. Its end-to-end QA accuracy is 92.0% with no oracle metadata — a separate, answer-model-dependent metric. Several competitors publish higher top-line numbers, but those mix QA accuracy with recall@k and use different answer models, so they are not a controlled head-to-head. M3 trades any QA-accuracy gap for sovereignty, bitemporal correctness, and a small auditable codebase.

Dimension | m3-memory (2026.4.24.12) | agentmemory (V4.0.2) | Chronos (High/Res) | Hindsight (v0.5.4) | Mastra OM (v1.26.0) | Mem0 (v3.0.0) | Memento (v1.0.0) | MemPalace (v3.3.0)
--- | --- | --- | --- | --- | --- | --- | --- | ---
▸ Sovereignty & Integrity (M3 strengths) |
Sovereignty (Main) | 🛡️ Full Sovereign | 🛡️ Full Sovereign | ⚖️ On-Prem | ⚖️ High Local | ⚖️ Hybrid | 🔻 Cloud-Tied | ⚖️ Config-Local | 🛡️ Full Verbatim
└ Data Residency | 🏆 Local SQLite | ✅ Local SQLite | ✅ Local Files | ✅ Local Files | ⚖️ Postgres / Container | 🔻 Cloud DB | ✅ Local SQLite | ✅ Local SQLite
└ Extraction Compute | 🏆 Local SLM | ✅ Deterministic | ✅ ISO-Temporal | ✅ Neural / Local | 🔻 Cloud Reflector | 🔻 Cloud LLM | ⚖️ User-Defined | ❌ Verbatim only
└ Telemetry / Audit | 🏆 Zero / Bitemporal | ✅ Zero / Merkle | ✅ Event Logs | ✅ Internal | ⚖️ Usage Logs | 🔻 SaaS Metrics | ✅ Zero / Merkle | 🛡️ Total Dark
└ Infrastructure | 🏆 Native Python + SQLite | ✅ Native Python | ⚖️ Linux / Python | ⚖️ Py / Services | 🔻 Docker stack | ✅ SDK / API | ✅ Native Python | ✅ Native Python
Data Integrity | 🏆 Bitemporal Logic + Undo | 🏆 Merkle Tree | ✅ Event Logs | ✅ Traceable | ⚖️ DB-Level only | 🔻 Managed only | 🏆 Merkle-Audit | 🔻 JSON Desync Risk
Bitemporal & Undo | 🏆 Full bitemp + Undo | ⚖️ Temporal sig. | ✅ Audit log | ✅ Traceable | ✅ 3-Date Anchor | 🔻 No Undo | 🏆 Merkle-Audit | ❌ Verbatim only
Privacy / GDPR | 🏆 Native GDPR tools | ✅ Local-only | ✅ On-Prem | ✅ Local-only | ⚖️ Hybrid | 🔻 No native | ✅ Local-only | 🛡️ Total sovereignty
▸ Multi-Agent & Concurrency |
Multi-agent Writes | 🏆 Atomic (WAL) | 🏆 Durable Objects | ✅ Turn-based | 🏆 Shared Banks | ⚖️ Adapter-based | ✅ ID-Scoped | ✅ Transactional | 🔻 Silent failures
Multi-agent Orchestration | 🏆 Native MCP handoffs | 🏆 Orchestrated | ✅ Sequential | 🏆 Bank-Scoped | 🏆 Supervisor | ✅ ID-Scoped | 🏆 Native (MCP) | ✅ Agent Diaries
Native OS Support | 🍎 🐧 🪟 | 🍎 🐧 | 🐧 🍎 | 🐧 🍎 | 🔻 (Docker only) | 🍎 🐧 🪟 | 🍎 🐧 🪟 | 🍎 🐧 🪟
Multi-Computer Sync | 🏆 Bi-dir Delta Sync | ✅ Managed API | ✅ Web Server | 🏆 Local Server | 🏆 Cloud / EKS | 🏆 Cloud Native | ⚖️ Local Sync | 🔻 Manual Sync
▸ Retrieval & Extraction (M3 is solid; not the recall leader) |
LME-S Score | 92.0% (no oracle) | 96.2% (🏆 #1) | 95.6% | 91.4% | 94.9% | 89.1% | 90.8% | 96.6% (R@5)
Search Strategy | ✅ 3-Pillar Hybrid | 🏆 6-Signal Hybrid | ⚖️ Dual-Index | 🏆 4-Stream Neural | ✅ Reflective | ✅ Vector-only | ✅ Compositional | ⚖️ Spatial-palace
Local Fact Extraction | 🏆 Local SLM | ✅ Deterministic | ✅ ISO-Temporal | ✅ Entity-centric | 🏆 Reflector | ✅ LLM-Powered | ✅ Entity-Res. | ❌ Verbatim only
Token Efficiency | 🏆 Lazy tools + low-K (1.8% window at startup) | ✅ Signal Filter | ✅ Event-Pruned | 🔻 Heavy Rerank | ✅ Cache-Stable | 🏆 ~90% Savings | ✅ Stores raw text | ⚖️ Stores raw text
▸ Architecture (for context) |
Architecture | 3-Tier (Short / Working / Long-Term) | 6-Signal Hybrid | Event Calendar | 4-Stream | 3-Tier (Obs / Ref) | Dual-Store | Bitemporal KG | Loci Hierarchy

## Icon Legend

🛡️ Sovereign — 100% offline, local-SLM extraction, zero telemetry by default.
🏆 Best-in-class — leads the cohort on this dimension.
✅ Has feature — standard implementation; functional and competitive.
⚖️ Parity / partial — feature exists with a meaningful caveat.
🔻 Weakness — significant cloud dependency or stability risk.
❌ Missing — capability not implemented.

## When another tool fits better

M3 is not the right answer for every workload. Pick from the table based on what matters most to you:

- Top-line QA accuracy is paramount — agentmemory (96.2%) or MemPalace (96.6% R@5) publish higher numbers. M3's 92.0% no-oracle QA is strong; on pure retrieval recall (100% SHR @ k=20) M3 is state-of-the-art for a local-first substrate. (Note: an independent analysis, arXiv 2604.21284, attributes MemPalace's 96.6% to ChromaDB embeddings and verbatim storage rather than its "memory-palace" architecture.)
- You need extreme token compression — Mem0 reports ~90% context savings. M3's working-memory model is good but not as aggressive.
- You only need verbatim recall, no extraction — M3 already does this: content is stored exactly as written, never altered in place, and always retrievable byte-for-byte. Unlike a verbatim-only store, M3 also keeps the verbatim text of superseded facts (corrections close-and-link rather than overwrite), so exact recall survives across edits.
- Heavy neural reranking is acceptable — Hindsight's 4-stream architecture wins on rich retrieval if you can absorb the latency cost.
- You're committed to a Docker-first ops model — Mastra OM fits cleanly into containerized stacks.

If sovereignty, bitemporal correctness, and a small auditable codebase matter more than raw recall, M3 is built for that combination — and the table above is the receipt.

For the developer-tool decision (Mem0, Letta, Zep, LangChain Memory), see the developer-facing comparison guide.

## Dimension Glossary & Analysis

Hover any underlined acronym for its full meaning. SOTA = state-of-the-art.

### Sovereignty (Main)

↑ Back to table

What it means: Independence from cloud services, telemetry, and external dependencies for normal operation.

Why it matters: If your data can't leave the machine — for legal, contractual, or personal reasons — every external dependency is a compliance risk and an attack surface.

M3 standing: Full Sovereign. Local SQLite, local SLM extraction, zero telemetry, native Python — runs on a laptop or in an air-gapped enclave with the same code path.

Sub-dimensions:

- Data Residency: Local SQLite — single file, portable, inspectable (or PostgreSQL as the primary backend for a shared/server store).
- Extraction Compute: Local SLM via LM Studio / Ollama / vLLM — no data egress.
- Telemetry / Audit: Zero by default; bitemporal log gives auditability without phoning home.
- Infrastructure: `pip install` — no Docker, no services, no daemons.

Cohort context: M3 is tied with agentmemory and MemPalace at the top. Cloud-tied systems (Mem0) can't reach this tier without significant rework. Mastra OM's Docker stack is more dependent than M3's plain-Python install.

### Data Integrity

↑ Back to table

What it means: Mechanisms that keep data accurate, consistent, and tamper-evident across time and across agents.

Why it matters: Silent corruption destroys trust slowly. By the time you notice the memory is wrong, the bad fact has already propagated through dozens of decisions.

M3 standing: Bitemporal logic with native undo. Every write is durable (WAL), every fact is bounded by valid-time and transaction-time, and supersedes relationships record exactly which old fact was replaced and when.

Cohort context: Merkle-tree systems (agentmemory, Memento) provide cryptographic audit but no native undo; bitemporal gives undo but isn't cryptographic. JSON-store systems (MemPalace) carry silent-desync risk.

### Bitemporal & Undo

↑ Back to table

What it means: Tracking facts along two independent time axes — valid time (when the fact was true in the world) and transaction time (when M3 learned it) — with the ability to undo writes.

Why it matters: Agents make mistakes. Without bitemporal logic and undo, every error becomes permanent or requires destructive overwrites that lose context.

M3 standing: SOTA — full bitemporal model + native undo via supersedes relationships.

Cohort context: Memento offers Merkle-style audit (different shape, also strong). Mem0 has no undo; mistakes there are sticky.

### Privacy / GDPR

↑ Back to table

What it means: Built-in primitives for the right to erasure (Article 17) and data portability (Article 20).

Why it matters: Many regulated workloads require these capabilities to be operational, not theoretical. Implementing them retroactively on top of a memory layer is expensive and error-prone.

M3 standing: SOTA — `gdpr_forget` (hard delete) and `gdpr_export` (portable JSON) ship as MCP tools. See also the FISMA and CMMC alignment notes.

Cohort context: Local-only systems (agentmemory, Memento) inherit privacy by deployment but require custom GDPR tooling. Mem0 has no native GDPR primitives.

### Multi-agent Writes

↑ Back to table

What it means: Safe handling of concurrent writes when multiple agents update memory simultaneously.

Why it matters: In real agent swarms, race conditions silently destroy knowledge — and the corruption usually surfaces hours or days later.

M3 standing: Atomic via SQLite WAL. Writes are durable, ordered, and crash-safe.

Cohort context: agentmemory (durable objects) and Hindsight (shared banks) are at parity. MemPalace's "silent failures" mode is the worst category here — writes can drop without surfacing an error.

### Multi-agent Orchestration

↑ Back to table

What it means: Built-in primitives for task handoff, context sharing, and coordinated agent lifecycles.

Why it matters: A single agent is useful. Multiple agents that can hand off work mid-task are the actual value of "agentic" systems.

M3 standing: Native MCP handoffs, agent registry, notifications, tasks — all via the same MCP tool surface, no extra runtime required.

Cohort context: Memento also goes native MCP. Mastra OM uses a supervisor pattern. Mem0 scopes by ID but doesn't ship handoff primitives.

### Native OS Support

↑ Back to table

What it means: Runs natively on macOS, Linux, and Windows without Docker or platform-specific dependencies.

Why it matters: Most developers' machines are macOS or Windows; most production servers are Linux. A memory layer that works in all three avoids forcing operational compromises.

M3 standing: Full native support — same install command everywhere.

Cohort context: Mastra OM's Docker-only deployment is the outlier; the rest of the cohort cover at least two OSes.

### Multi-Computer Sync

↑ Back to table

What it means: Synchronizing memory across multiple physical machines without a central cloud.

Why it matters: A laptop, a desktop, and a server should be able to share memory without giving the data to a SaaS provider.

M3 standing: Bi-directional delta sync via PostgreSQL — set one env var, your memories follow you across devices.

Cohort context: Cloud-native systems (Mem0) deliver sync trivially but at the cost of sovereignty. MemPalace requires manual sync.

### LME-S Score

↑ Back to table

What it means: LongMemEval-S, a 500-question benchmark for long-horizon conversational memory retrieval. The single number captures recall accuracy averaged across question types.

Why it matters: A retrieval layer that can't find what's there is a liability. But — and this is the part vendor pages skip — the benchmark doesn't measure sovereignty, integrity, undo, or compliance. A 96% score sourced from a cloud LLM tells you nothing about whether your data left the machine.

M3 standing: 92.0% end-to-end QA accuracy with no oracle metadata (100% retrieval SHR @ k=20). We optimize correctness, sovereignty, and a small codebase — and the no-oracle QA number is strong without privileged dataset labels.

Cohort context: agentmemory (96.2%), MemPalace R@5 (96.6%), Chronos (95.6%), and Mastra OM (94.9%) publish higher top-line numbers, but those mix QA accuracy with recall@k and use different answer models — not a controlled head-to-head. M3 (92.0% no-oracle QA) sits alongside Hindsight (91.4%) and Memento (90.8%, oracle/no-distractor setting).

### Search Strategy

↑ Back to table

What it means: The retrieval architecture under the hood — how the system blends keyword, vector, and structural signals.

Why it matters: Vector-only search hallucinates synonyms. Keyword-only misses paraphrases. The blend is what matters.

M3 standing: 3-Pillar Hybrid — FTS5 (BM25) + vector cosine + MMR diversity reranking. Explainable per-result scores via `memory_suggest`.

Cohort context: agentmemory's 6-signal hybrid and Hindsight's 4-stream neural model push further. Vector-only systems (Mem0) are simpler but lose precision on terminology-heavy queries.

### Local Fact Extraction

↑ Back to table

What it means: Distilling structured facts from raw conversational text — entirely on-device.

Why it matters: Raw text is noisy. Extracted facts are dense, queryable, and easier to refresh. Doing this locally preserves sovereignty.

M3 standing: SOTA — dedicated local SLM pipeline (LM Studio / Ollama / vLLM compatible).

Cohort context: Mastra OM's reflector matches M3 in capability but runs in the cloud. Mem0's LLM-powered extraction is strong on quality but breaks sovereignty. MemPalace's verbatim-only design skips extraction entirely.

### Architecture

↑ Back to table

What it means: The high-level system design and internal memory organization.

Why it matters: Architecture determines how the system scales, what kinds of queries it can answer, and how easy it is to extend.

M3 standing: 3-Tier (short / working / long-term) optimized for real agent lifecycles, with bitemporal logic threaded through every tier.

Cohort context: agentmemory's 6-signal hybrid is richer; MemPalace's spatial loci hierarchy is novel. Trade-off: more complex architectures cost more to maintain.

### Token Efficiency

↑ Back to table

What it means: How effectively the system reduces context-window usage and downstream LLM costs.

Why it matters: Every token saved is dollars saved and latency reduced. At scale, the difference is order-of-magnitude.

M3 standing: Strong — lazy tool-loading keeps the context window small, and SOTA retrieval means a low top-K (versus the typical K=20–50) is enough: less noise, and the correct answer tends to surface on the first search rather than in follow-up queries.

Cohort context: Mem0 reports ~90% context savings. M3 attacks token cost from two directions instead — lazy-loading the tool surface, and retrieving accurately at low K so fewer results carry the answer — while preserving bitemporal richness. Heavy reranking (Hindsight) wastes tokens.