Iranti vs Mem0: what the benchmarks actually show
We ran both systems through four benchmarks: recall accuracy, pool efficiency, conflict resolution, and cross-session persistence. This is what we found — with the methodology, the numbers, and the honest tradeoffs.
What we tested and why
Mem0 is one of the most widely used memory libraries for AI agents. It's designed around semantic memory — facts are stored as embeddings, deduplicated by semantic similarity on write, and retrieved via vector search. It works well for conversational memory and is easy to integrate.
Iranti takes a different approach: structured, addressed memory. Facts are stored at explicit entity/key addresses, retrieved by exact lookup or hybrid search, and written with confidence scores and provenance. The design trades some flexibility for determinism and inspectability.
The question isn't which is better in the abstract — it's which performs better on specific dimensions that matter for production agent workflows. We tested four.
Results across four benchmarks
Mem0 misses 8 questions across HIGH and LOW risk tiers. Iranti uses exact entity+key lookup — misses are structurally impossible if the fact was written.
Mem0 is lean on tokens (18/query). Iranti is slightly heavier (20/query) but 100% accurate. Efficiency score favors Iranti, but Mem0 is the closest competitor.
Iranti's entity+key model deterministically replaces old values. Mem0 uses semantic deduplication — works on 7/10 pairs, misses 2 where semantic similarity is too low to trigger an update.
Mem0 drops 5 points from its same-session score — Chroma read variance under parallel queries. Iranti (PostgreSQL) is fully consistent across process restarts.
All benchmarks run 2026-04-05. Mem0 v1.0.x. Full methodology: benchmarks →
Where the architectural difference matters most
The gap between Iranti and Mem0 is largest on conflict resolution and cross-session persistence. Both trace back to the same root cause: Mem0's semantic deduplication is probabilistic, while Iranti's entity+key addressing is deterministic.
When you write a new value to the same entity and key in Iranti, the old value is always replaced. There's no similarity threshold to cross, no case where an update fails because the semantic distance was too small. For configuration-heavy workflows — where the correct value of a fact matters and stale values cause real problems — this is a meaningful difference.
The cross-session gap (100% vs 75%) reflects a different issue: Mem0's Chroma backend shows read variance under parallel queries across process restarts. In a single-threaded, single-session workflow, Mem0 performs consistently. In multi-agent or multi-session setups with concurrent reads, the gap widens.
Where Mem0 has real advantages
Mem0 is significantly easier to get started with. It doesn't require PostgreSQL — the default backend is Chroma, which is zero-infrastructure to run. For teams that don't want to manage a database, that's a real advantage.
Mem0 also handles unstructured conversational memory more naturally. You can write arbitrary text and let Mem0's semantic layer handle deduplication and retrieval. Iranti requires explicit entity+key structure — that produces better benchmark results but demands more intentional write discipline from the agent.
For pure semantic recall use cases (e.g. "what did the user say about X last week?"), Mem0's approach is a reasonable fit. Iranti is stronger when the use case requires deterministic retrieval, conflict handling, or cross-session durability.
MCP and integration surface
Iranti ships as an MCP server — connectable to Claude Code, GitHub Copilot, Codex, or any MCP-compliant client with one setup command. Memory written by one tool is immediately available in any other tool pointing at the same Iranti instance.
Mem0 has a Python and TypeScript SDK but not a native MCP server. If your tooling is MCP-centric, Iranti integrates without a custom adapter.