Comparisons

The agent memory market is crowded. Here’s how Mnemosyne stacks up against the alternatives, feature by feature, as of June 2026.

Feature matrix

Capability	Letta (MemGPT)	Zep (Graphiti)	Mem0	Cognee	LangMem	Engram	Mnemosyne
Bitemporal validity	❌	✅	❌	❌	❌	❌	✅
Knowledge graph	❌	✅ (Neo4j)	❌	✅	❌	❌	✅ (PG-native + hypergraph)
Hebbian + STDP	❌	❌	❌	❌	❌	partial	✅
Memory Worth (RL-grounded)	❌	❌	❌	❌	❌	❌	✅
Consolidation gate	❌	❌	❌	❌	❌	❌	✅
PII filter + poisoning detection	❌	❌	❌	❌	❌	❌	✅
RLS multi-tenant (database-enforced)	❌	❌	❌	❌	❌	❌	✅ + FORCE
Self-editing memory	✅	❌	❌	❌	❌	❌	✅
Procedural memory / prompt evolution	❌	❌	❌	❌	✅	❌	✅
Task management as memory primitive	❌	❌	❌	❌	❌	❌	✅
CoT distillation	❌	❌	❌	❌	❌	❌	✅
Session collapse → typed knowledge	❌	❌	❌	❌	❌	❌	✅
Federation between instances	❌	❌	❌	❌	❌	❌	✅
Multi-transport (REST + MCP + gRPC + WS)	REST	REST	REST+MCP	REST	REST	REST	REST + MCP + gRPC + WS
Typed knowledge primitives	3	3	1	2	1	1	10 live
Delta-encoded episodes	❌	❌	❌	❌	❌	❌	✅
Token-budget-adaptive recall	❌	❌	❌	❌	❌	❌	✅
Trust-anchor consensus (zero-LLM)	❌	❌	❌	❌	❌	❌	✅
Composition engine (zero-LLM)	❌	❌	❌	❌	❌	❌	✅
Meta-cognition (confidence map)	❌	❌	❌	❌	❌	❌	✅
Predictive anticipation (zero-LLM)	❌	❌	❌	❌	❌	❌	✅
PostgreSQL-native (no Neo4j/Qdrant)	❌	❌	❌	❌	❌	partial	✅
Open source (permissive)	✅	partial	partial	✅	✅	✅	✅ (Apache 2.0)
Single-binary deploy	❌	❌	❌	partial	❌	✅	✅
No required third-party services	❌	❌	❌	❌	❌	partial	✅

What each alternative does best

Letta (MemGPT)

Best at: self-editing memory and agent-as-OS metaphor. Weakest: no temporal correctness, no knowledge graph, no consolidation gate.

Zep (Graphiti)

Best at: bi-temporal knowledge graph in Neo4j. Sub-200ms recall. Weakest: Neo4j lock-in (you bring more infra), no Hebbian, no governance.

Mem0

Best at: dead simple API and excellent MCP integration. Mem0 wrote the playbook for “easy to adopt”. Weakest: graph was removed, no temporal, no governance, no isolation.

Cognee

Best at: ontology grounding and cascade schema. Weakest: immature, no temporal, single-tenant.

LangMem

Best at: procedural memory and prompt optimisation. Weakest: locked to LangGraph, no knowledge graph, no temporal.

Engram (both flavours)

Best at: pragmatic, SQLite-friendly, git-syncable, topic-key upserts. Weakest: SQLite limits, no multi-tenant, no vectors.

ROI calculator

Estimate what Mnemosyne saves your stack each month. Slide the inputs to your own scale.

Sessions / month: 50,000

Tokens per recall call: 2,200

Model

$440without Mnemosyne

$297with Mnemosyne

$143saved / month

57.2Mtokens saved / month

These numbers assume composition + trust-anchor reduce 65% of input tokens on recall-heavy workloads. Your mileage will vary based on session length and how repetitive your context is.

When NOT to pick Mnemosyne

Be honest — Mnemosyne isn’t always the right answer.

You need a single Python file with no server. Engram is closer.
You only need to remember user preferences for a chatbot. Mem0 is faster to wire up.
You’re already deeply on LangGraph. LangMem is the path of least resistance.
You can’t run PostgreSQL. Mnemosyne can’t help you. Postgres is the floor.

For everything else — when you want bitemporal correctness, multi-tenant isolation enforced by the database, cognitive governance grounded in outcomes, and a positive ROI multiplier — Mnemosyne is built for you.

The matrix above will date. We update it on every release. The June 2026 snapshot is preserved in internals/comparisons-history.json.

Academic foundations Changelog