ai-memory/docs/comparison.md

How ai-memory compares

For anyone evaluating ai-memory against another agent-memory tool — or migrating from one. This page aims to be fair and specific: what each approach does well, where ai-memory differs, where others are ahead, and how the field has independently validated the bets ai-memory made. The deep analysis behind it is in research-2026-landscape.md and the per-project research docs; the numbers are from benchmarks/, reproducible from the in-repo harness.

The short version

Most memory tools optimize one of: extracting atomic facts per turn (Mem0, LangMem), a temporal knowledge graph (Zep/Graphiti), an agent-editable memory OS (Letta, MemOS), or a hosted context database (OpenViking). ai-memory optimizes something different: a git-backed markdown wiki as the source of truth, with a derived index for retrieval, captured automatically from lifecycle hooks, shared across agents and machines.

What actually distinguishes it:

• Cross-agent and cross-machine by construction. One server; 20+ harnesses (Claude Code, Codex, Cursor, Gemini, OpenCode, Kimi, …) feed and read the same memory. Quit one agent, open another in the same repo, get a real handoff. Handoffs are a typed protocol (owned, claimed exactly once), not a note file.
• Zero-LLM default. Capture, FTS5 + entity + graph retrieval, local embeddings, and rule-based summaries all work with no API key. An LLM is opt-in for richer consolidation — not a requirement to function.
• Files are the truth. The wiki is plain markdown + YAML frontmatter — a native Open Knowledge Format (OKF v0.2) bundle. grep it, open it in Obsidian, edit by hand, rsync it. The SQLite index is derived and rebuildable. Nothing is trapped in a vector store or binary blob.
• Multi-user without a paid tier. An auth ladder (root → DB-user tokens → OIDC), per-person attribution, audit log, and the invariant that pages are shared per project while handoffs stay owned — a team story built in.
• One self-contained binary. Bundled SQLite, vendored libgit2; no external services to stand up. Runs on a laptop, a homelab box, or a LAN server.

And it publishes numbers: LongMemEval-S hit@5 0.823 (local-embeddings default; 0.668 zero-LLM), produced by the in-repo harness with full provenance — not a marketing claim. For context on the same dataset, mcp-memory-service reports 0.804 R@5 and agentmemory 0.967 R@5 (hybrid + reranking); ai-memory is comparable to the former and honestly below the latter, and it documents why (the pipeline pays a real 2 KB privacy-capture cost the raw-log retrievers do not). See where we're behind.

By camp

Approach	Representatives	Strength	Trade-off vs ai-memory
Fact extractors	Mem0, LangMem	Cheap per-turn personalization	Atomic facts lose relational/causal context (see TriMem); LLM-per-turn; not file-first
Hosted memory API (hybrid)	Supermemory, LiquidLM	Chunk-RAG + LLM temporal fact-graph + per-user profiles in one query; managed connectors (Drive/Notion/GitHub), multimodal, metadata/tag query filters	Cloud-first (best features + extraction are paid/hosted); LLM-required quality path; an opaque store is the source of truth (not file-first, nothing to grep/diff). Supermemory's MIT self-host binary drops the connectors + extraction models; LiquidLM is closed-source and cloud-only (no self-host at all)
User-modeling / theory-of-mind	Honcho (Plastic Labs)	Reasoning-derived model of what each "peer" knows/believes over time — personalizes around the human the agent serves	Different problem: it remembers the user, ai-memory remembers the project. Opaque Postgres, LLM-required (Deriver/Dreamer), multi-service stack; adjacent (shares MCP/plugin delivery) but not a coding-memory migration target. ai-memory borrowed the conveniences, not the engine: an opt-in dialectic answer over its own hits and a reasoning tier now ship (both off by default, LLM-required)
Temporal knowledge graph	Zep/Graphiti, Cognee	Bi-temporal "what was true vs believed when"	Needs a graph DB; heavier to self-host. ai-memory ships bi-temporal-lite on SQLite (temporal.md) + typed edges (typed-edges.md) for the useful part
Memory OS / self-editing	Letta, MemOS, MIRIX	Agent curates its own tiered memory	Token-expensive self-editing; Letta itself now concedes file-first ("Is a Filesystem All You Need?")
Hosted context database	OpenViking (ByteDance)	Progressive L0/L1/L2 loading; directory-scoped retrieval; broad integrations	LLM-required (VLM + embeddings); opaque swappable storage; AGPLv3 core + SaaS/enterprise weight
Paper-backed pages	Hindsight (Vectorize)	"Mental models" = living markdown pages an agent boots from; belief-strength consolidation; a preprint	Postgres/pgvector-primary, LLM-required; strict per-bank isolation (no team-sharing within a project). ai-memory now ships belief-strength confidence + an opt-in LLM "dream" rewrite, both zero-LLM-default-preserving, off by default, and R2-gated before default-on
Closest sibling (fact-row twin)	doobidoo/mcp-memory-service	SQLite(+vec), local ONNX, hook capture, typed edges, honest numbers	What ai-memory would be if it chose fact-rows over wiki pages
Platform-native	Claude Code auto-memory	Zero setup, on by default	Machine-local, no sync, single-agent, repo-scoped, no tool-lifecycle capture, no team
File-first wiki (ai-memory)	ai-memory, basic-memory, OKF	Human-editable markdown truth + derived index; cross-agent; zero-LLM default; multi-user	Below the reranking leaders on raw R@5; LLM-optional means no VLM fact-extraction sophistication
File-first wiki (LLM-leaning)	memU, EverOS	Markdown source of truth + derived vector/SQLite(+LanceDB) indexes; offline consolidation; skill distillation from session history	LLM-required for the core capture/distill flow (no zero-LLM default); Python multi-service + a hosted-cloud option, vs one self-contained zero-LLM binary; memU patches host instruction files rather than exposing a git-diffable wiki
Self-hosted coding-agent store	Engram	Single Go binary, SQLite+FTS5, MCP stdio, project-scoped, mem_session_summary handoffs, git-sync across machines	Structured rows the agent saves through MCP tools (SQLite is the truth, git-syncs compressed chunks), not a hand-editable git-markdown wiki captured automatically from lifecycle hooks
Governed multi-agent / fleet memory	Caura	Shared fleet memory: agent/team/org visibility scopes, four trust tiers, audit log, PII flagging, contradiction/supersession, auto knowledge graph	Fleet-governance-first on Postgres+pgvector (LLM extraction), hosted option; ai-memory optimizes one project's git-backed wiki with pages shared, batons owned, not org-scale fleet governance
Shared memory server (proxy fan-in)	TencentDB Agent Memory	One proxy in front of many harnesses distills chats/docs/code into Chat Memory / Skill / Wiki / CodeGraph assets	Proxy base-URL interception, not MCP or OS lifecycle hooks; despite the name it needs no Tencent DB product (SQLite by default); a Node three-service stack vs one file-first binary

Maturity and maintenance

This is a crowded, fast-moving field, and it is only fair to say so: every tool compared here is actively maintained (as of 2026-09-18, all had commits within the last ~10 days — none stale, none archived; the five new-entrant rows below were verified 2026-09-22). Raw GitHub popularity, though, tracks funding and app-developer reach more than coding-agent fitness — the star leaders are the app-personalization and hosted-context players (a different buyer), while the tools closest to ai-memory's file-first, self-hosted, coding-continuity niche are smaller by design.

Project	Stars (~)	Latest release	Maintenance
Mem0	65.6k	2026-09-18	active
OpenViking	38.0k	2026-09-14	active
Zep/Graphiti	31.0k	2026-09-08	active
Cognee	30.8k	2026-09-15	active
Supermemory	30.1k	2026-08-17	active
agentmemory	28.6k	2026-08-16	active
TencentDB Agent Memory	27.2k	v2.0.1 (2026-08-25)	active
Letta	24.8k	2026-05-14	active (releases lag code)
Hindsight	23.9k	2026-09-14	active
memU	14.4k	v1.5.1 (2026-03-23)	active (releases lag code)
EverOS	13.1k	v1.3.1 (2026-09-08)	active
Honcho	7.2k	tag v3.2.0	active
Engram	6.8k	v2.0.0 (2026-09-18)	active
basic-memory	4.0k	2026-08-25	active
mcp-memory-service	2.0k	2026-09-14	active
LangMem	1.7k	PyPI-only	active
Caura	0.5k	backend-v3.17.2 (2026-09-19)	active
LiquidLM	closed-source	@liquidlm/cli 0.1.5 (2026-09-17)	active (young, solo)

Full figures, sources, and per-tool caveats: research-2026-landscape.md.

How the field validates the approach

The strongest endorsement of ai-memory's design is that others arrived at its core bets independently, from different substrates:

• Google standardized file-first. The Open Knowledge Format (June 2026) — markdown + YAML frontmatter, one concept per file, no runtime — is the interop layer for agent memory. ai-memory's wiki is a native OKF bundle.
• Letta conceded the filesystem. The "memory OS" camp's own leader published that agents post-trained for file search rival specialized memory systems — the file-as-truth + derived-index split ai-memory uses.
• Hindsight's paper validates pages-over-facts. A funded competitor on the opposite (Postgres, LLM-required) substrate makes its top tier "mental models" — living markdown pages a background process rewrites and the agent boots from. That is ai-memory's wiki/ + auto-improve loop under another name, backed by arXiv:2512.12818.
• OpenViking validates document memory + a consolidation loop. ByteDance's entrant stores document/directory-scoped memory (not atomic facts) with a background extract/merge pass and a "compile" step into wikis — the same shape as ai-memory's consolidation, from an LLM-required corner.
• The literature backs it. TriMem (arXiv:2605.19952) argues document/page/ narrative hierarchies beat atomic-fact stores; the Storage→Reflection→ Experience survey (arXiv:2605.06716) names cross-trajectory abstraction as the frontier — which ai-memory's experience pass targets.

ai-memory also shipped the borrowable ideas from that research rather than just cataloguing them: typed relation edges, ingestion-time temporal validity with as_of queries, local (no-key) embeddings as the default, and the cross-session abstraction pass are all in the product today. The 2.4 line added five retrieval conveniences, each opt-in with defaults byte-identical: a bounded related-pages graph walk (memory_read_page include_related, basic-memory/LiquidLM), an opt-in dialectic answer over hits and a reasoning tier (Honcho, both LLM-required and off by default), a pin-before-search contract (memory_query pin_first + a pinned standing-context briefing, LiquidLM), and a show-superseded retrieval knob over the supersession chains.

The 2.4 line also closed most of the memory-aging gap — the decay, compression, and consolidation machinery the field converged on — on ai-memory's own zero-LLM, file-first terms (design of record: design-memory-aging.md):

• Per-tier decay curves (mcp-memory-service's 365/180/90/30 shape): the single global half-life is now a tunable per-tier [decay.half_life_days] table. Identity default — an upgrade changes no score.
• Extractive tier-down of cold episodic pages (agentmemory and mcp-memory-service ship extractive, zero-LLM compression as a default): instead of evicting a cold page, ai-memory can compact it to its abstract, a summary, and a regex-mined keep-token set (paths, URLs, code spans, error codes) and drop the prose — reversible through git + the supersession chain.
• Cold-cluster dedup (mcp-memory-service's DBSCAN): near-duplicate cold episodic pages cluster (adaptive-eps DBSCAN over already-stored embeddings) and collapse to one survivor — superseded, never deleted.
• Zero-LLM contradiction flagging (mcp-memory-service's 0.4–0.75 cosine band): memory_lint now surfaces likely-conflicting pages, advisory only, from existing embeddings.
• Access-weighted retention (mcp-memory-service's access boost): a page a human opens, searches, or reaches through the link graph resists decay like a search hit — now on every read path.
• Belief-strength confidence (Hindsight, mcp-memory-service): a read-time, zero-LLM confidence per page (distinct-session breadth, recency, live contradicts count), surfaced in memory_query explain and memory_status.
• An opt-in LLM "dream" pass (Hindsight's Dreamer, Honcho's Dreamer, Supermemory's "dreaming"): idle-scheduled, cancel-on-activity, surprisal-first cross-session rewrite/merge of cold clusters.

Two of these change behavior only where a provider is configured and the operator opts in — belief-strength folded into ranking, and the dream pass — and both are off by default and gated on a recall eval (R2) before they may default on. No such eval has been run yet, so ai-memory claims parity of mechanism, not a measured quality win: the substrate ships, honestly, off. Everything else here is zero-LLM, reversible, and off by default until an operator turns it on.

Coming from another tool?

• From Mem0 / a fact extractor: you keep automatic capture, but memory compiles into readable pages you can open and edit, not opaque fact rows. Retrieval fuses FTS + entity + graph + vectors instead of vector-only.
• From Zep/Graphiti: you get bi-temporal-lite (as_of, version-filtered search) and typed edges without standing up a graph database — on one binary.
• From Claude Code's built-in memory: the same "remember my project" convenience, but synced across machines and agents, searchable, team-capable, and capturing tool lifecycle — not a per-laptop MEMORY.md.
• From mcp-memory-service: a very close sibling; the switch is fact-rows → wiki pages (human-editable markdown truth) and cross-agent handoffs as a first-class protocol. Cross-project agent messaging is new ground neither had as a typed queue. On aging you keep what you relied on — the 2.4 line matches its per-tier decay curves, extractive compression, DBSCAN cold-cluster dedup, access boosts, and 0.4–0.75-band contradiction detection — but done zero-LLM by default, reversibly (every collapse supersedes rather than deletes; restore-page recovers the original), and off by default so an upgrade evicts nothing.
• From Supermemory / LiquidLM (a hosted memory API): you trade a cloud vault and a managed multimodal RAG service for a self-contained binary whose memory lives in git-versioned markdown you own, works zero-LLM by default, and captures your coding sessions automatically through lifecycle hooks instead of explicit uploads. You give up (for now) their multimodal ingestion (video/audio/PDF/Office), a polished consumer web app + grounded chat, and managed hosting; you gain data ownership, no required API spend, offline operation, per-project team sharing, and — now opt-in on the 2.4 line — a pin-before-search contract and a bounded related-pages graph walk over the link neighbours ai-memory already computes. Different job: they build a general "second brain," ai-memory remembers this repo.
• From Hindsight / OpenViking: you trade a hosted, LLM-required service for a self-contained binary that runs zero-LLM by default and keeps memory in files you own. The consolidation shape you came for is here on 2.4 — a belief-strength confidence over evidence and an idle-scheduled, cancel-on-activity, surprisal-first LLM "dream" rewrite of cold clusters — but as opt-in layers that never delete a source (the pre-merge versions stay reachable) and are off by default and gated on a recall eval before default-on, over a zero-LLM core, rather than a mandatory loop. OpenViking's L0/L1/L2 progressive tiers map onto ai-memory's extractive tier-down (abstract + summary + keep-tokens). You give up (for now) their VLM-driven extraction depth and their published headline accuracy numbers; you gain no vendor lock-in, no required API spend, and per-project team sharing rather than strict per-bank isolation.
• From Engram (self-hosted coding-agent store): the closest operational sibling among the newcomers — a single self-hosted binary, SQLite+FTS5, MCP, project scope, and session-summary handoffs. The switch is Engram's agent-saved structured rows (the agent calls mem_* MCP tools; SQLite is the truth, git-syncing compressed chunks) → ai-memory's automatic lifecycle-hook capture compiled into a hand-editable git-markdown wiki, plus typed claim-once handoffs, cross-project messaging, and multi-user page sharing. You keep a keyless, offline, single-binary posture; you give up (for now) Engram's managed Cloud replication add-on.
• From memU / EverOS (file-first, LLM-leaning): you keep markdown as the source of truth, but ai-memory's core capture, retrieval, and summaries run zero-LLM by default rather than requiring a provider for the capture/ distill flow, and ship as one binary instead of a Python multi-service stack. memU's skill-distillation and EverOS's offline consolidation map onto ai-memory's experience pass + auto-improve loop; EverOS's SQLite+LanceDB derived indexes map onto ai-memory's derived SQLite/FTS5(+local embeddings). You give up (for now) memU's turnkey skill-distillation packaging and hosted cloud, and EverOS's LanceDB vector tier.
• From Caura (governed multi-agent fleet memory): different buyer. Caura optimizes org-scale fleet governance — agent/team/org visibility scopes, four trust tiers, an audit log, PII flagging — on Postgres+pgvector with LLM extraction. ai-memory shares the multi-agent/multi-user goal but at project scope (pages shared, batons owned, invariant #16) with a self-hosted auth ladder and audit log, not fleet-wide trust tiers. If you need cross-fleet trust governance across hundreds of agents, that is Caura's lane, not ours; if you want file-first, zero-LLM, single-binary project memory, it is ours. (Caura's trust-tier governance is an honest capability we do not match — see competitive-parity.md.)
• From TencentDB Agent Memory (proxy fan-in server): you trade a Node three-service proxy that intercepts each harness's API base URL (distilling Chat Memory / Skill / Wiki / CodeGraph assets) for a file-first binary that captures through OS lifecycle hooks and stores git-versioned markdown you own. Despite the name, TencentDB Agent Memory needs no Tencent database (SQLite by default). You give up its zero-code proxy integration and its CodeGraph code index (an adjacent, codebase-intelligence feature ai-memory does not do); you gain hook capture, a git-markdown wiki, typed handoffs, and zero-LLM operation.

Where we're behind, or different by choice

Fair means saying this plainly:

• Raw retrieval score, and no local reranker. 0.823 hit@5 on LongMemEval-S is comparable to mcp-memory-service and below agentmemory's 0.967 (hybrid + reranking). Part is deliberate — a 2 KB privacy cap on captured excerpts puts evidence deep inside one long turn out of the index's reach; the benchmark measures the shipped, sanitized system, not an idealized retriever. The only reranker is LLM-as-judge, so the zero-LLM default path has none; the opt-in answer=true dialectic synthesis (2.4) is likewise LLM-required, off by default, and its end-to-end QA-accuracy is early and small-sample (see benchmarks/retrieval-ab-r2.md), not a headline claim.
• Belief-strength and the dream pass ship, but off — no proven win yet. The 2.4 memory-aging set includes the two pieces that could move retrieval quality — folding belief-strength confidence into ranking authority, and the LLM "dream" rewrite of cold clusters — but both are off by default and gated on a recall eval (R2) that has not been run. We claim parity of mechanism with Hindsight/mcp-memory-service here, not a measured recall or QA improvement; until R2 shows a positive delta the honest statement is "shipped, opt-in, unproven," and the default path is unchanged.
• Headline benchmark comparability. Hindsight quotes 91.4% accuracy and OpenViking quotes LoCoMo lifts — different datasets/metrics than our hit@5, and both are self-reported/preprint. We publish a reproducible harness and a single stated metric rather than a bigger number.
• No VLM fact extraction. Because the default path is zero-LLM, ai-memory does not do the LLM-per-turn atomic extraction the fact-extractor and LLM-required systems build on. Consolidation is opt-in and page-shaped.
• Not a graph database. ai-memory chooses bi-temporal-lite on SQLite over a full temporal knowledge graph — the useful 80%, not the graph-query surface.
• Single server, not SaaS. No hosted multi-region tier, no enterprise console. That is the point (own your data, one binary), but it is a difference if you want managed infrastructure.

If a specific comparison here reads as unfair or out of date, open an issue — these numbers and claims are meant to be checkable against the linked research and the reproducible harness.