Memory for AI is a fast-growing space — Mem0, Zep/Graphiti and Supermemory are the serious players. Here's how memnos fits in, honestly. The short version: memnos remembers deterministically (no LLM guessing what to keep), is fully governed (auth · ACL · audit · encrypted vault), runs as one self-hostable engine, and we publish judge-transparent benchmarks — the full strict-to-lenient judge band, with per-question predictions in the repo — instead of one self-graded number.
✓ = supported ✗ = not supported ~ = partial or limited support ‡ = unverifiable — engine source not published
| Capability |
memnos
|
Mem0 v2.0.4 |
Zep Cloud† |
Graphiti v0.29 |
Supermemory June 2026‡ |
Mnemosyne v3.10 · MIT |
Honcho AGPL-3.0§ |
Hindsight MIT · 17k★ |
|---|---|---|---|---|---|---|---|---|
| Ingestion & memory model | ||||||||
| Structured fact extraction (typed subject–predicate–object) | ✓ | ~ graph option | ✓ | ✓ | ‡ | ✗ LLM summaries | ✓ Neuromancer | ✓ retain() |
| Bi-temporal facts (valid-time + as-of queries) | ✓ | ✗ | ✓ | ✓ | ‡ | ✗ | ✗ | ~ updates-not-overwrites |
| Deterministic conflict resolution at write — no LLM | ✓ | ✗ | ✗ | ✗ | ‡ | ✗ | ✗ LLM-resolved | ✗ LLM-resolved |
| Single- vs multi-valued attribute logic (supersede vs accumulate) | ✓ | ✗ | ✗ | ✗ | ‡ | ✗ | ✗ | ✗ |
| Offline consolidation into entity dossiers / communities | ✓ | ~ | ✓ | ✓ | ‡ | ✓ sleep() | ✓ Dreaming | ✓ reflect() |
| Deterministic auto-capture from your existing AI tools (hooks / proxy — not model-discretionary) | ✓ | ✗ MCP only | ✗ | ✗ | ✗ plugin = paid | ✗ MCP / opt-in hook | ✗ API push or MCP | ✗ API push or MCP |
| Retrieval & ranking | ||||||||
| Hybrid retrieval (vector + BM25 keyword) | ✓ | ✓ | ✓ | ✓ | ‡ | ✓ vec + FTS5 | ✓ | ✓ |
| Reciprocal Rank Fusion (RRF) | ✓ | ✗ | ✓ | ✓ | ‡ | ✗ weighted blend | ✗ | ✓ |
| Cross-encoder reranking on recall | ✓ default | ~ opt-in | ~ opt-in | ~ opt-in | ‡ | ✗ | ✗ | ✓ |
| Entity-guarantee + timeline retrieval arms (answer completeness) | ✓ | ✗ | ✗ | ✗ | ‡ | ✗ | ✗ | ✓ graph + temporal arms |
| Grounded recall — admin-linked knowledge namespaces consulted on every recall | ✓ | ✗ | ✗ | ✗ | ‡ | ✗ | ✗ | ~ Mental Models inject context |
| No LLM at query time | ✓ | ✓ | ~ LLM reranker default | ~ LLM reranker default | ‡ | ✓ | ~ context() free; reasoning = LLM | ~ recall: no; reflect(): LLM |
| Architecture & deploy | ||||||||
| Deployment model | Self-host; embedded (zero-dep) or your Postgres |
Self-host or cloud |
Hosted cloud | Library + graph DB |
Cloud (local = closed binary) |
Local SQLite, single user |
Managed cloud; Docker self-host |
Docker / bare metal; embedded (no server) |
pipx install → works, zero external deps |
✓ --embedded downloads PG + pgvector |
~ needs Postgres or Docker | ✗ cloud only | ✗ needs Neo4j + Postgres | ✓ pip install + API key | ✓ pip install, SQLite | ~ needs API key + account | ✓ pg0 embedded |
| Single store — no separate graph database required | ✓ | ~ | ✗ | ✗ | ~ local file store | ✓ SQLite | ✗ storage + insights services | ✓ pure PG, graph = recursive CTEs |
| Runs on standard PostgreSQL + pgvector — your database | ✓ | ✓ | ✗ | ✗ | ✗ no Postgres option | ✗ SQLite only | ✗ managed, not your DB | ✓ or pg0 embedded |
| MCP server (any MCP client) | ✓ | ✓ | ~ | ✓ | ~ cloud-only | ✓ | ✓ | ✓ |
| Python SDK (LangChain / LangGraph) | ✓ | ✓ | ✓ | ~ DIY | ✓ | ✓ | ✓ | ✓ + TypeScript + Go |
| Governance & security — in the free, self-hosted tier | ||||||||
| Token auth + namespace access control | ✓ | ~ | ~ | ~ | ✗ single API key locally | ✗ filesystem perms | ~ API key + workspace | ✗ tag convention only; RBAC = Enterprise |
| Audit trail + usage / cost ledger | ✓ | ~ | ~ | ✗ | ✗ server logs only locally | ✗ | ✗ | ~ Mental Model history only |
| Author-attributed memories — author server-signed, never client-supplied | ✓ | ~ client-supplied IDs | ~ client-supplied IDs | ~ client-supplied IDs | ✗ single key locally | ✗ single user | ✗ | ✗ |
| Encrypted secret vault + ingest secret-redaction | ✓ | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ | ✗ |
| Built-in management console (self-hostable) | ✓ | ✓ | ~ cloud | ✗ | ~ cloud | ✗ | ~ cloud app | ~ cloud dashboard |
| Trust & licensing | ||||||||
| Engine source published — read every line that touches your data | ✓ | ✓ | ✗ cloud | ✓ | ✗ engine unpublished | ✓ MIT, fully open | ~ server open; Neuromancer closed | ✓ MIT, pure SQL |
| License | Apache-2.0 | Apache-2.0 | Proprietary (CE deprecated) |
Apache-2.0 | MIT (SDKs/apps); engine closed |
MIT | AGPL-3.0§ | MIT |
| Benchmark with per-question predictions published + open harness | ✓ | ✗ | ✗ | ✗ | ~ open harness, no predictions | ~ BEAM harness open | ~ harness open; predictions unknown | ~ harness open; judge version undisclosed |
~ = partial / limited / opt-in support. Verified from official docs, repos and pricing pages against Mem0 v2.0.4, Graphiti v0.29.x, Zep Cloud, Supermemory, Mnemosyne v3.10, Honcho, and Hindsight, June 2026. Vendors evolve — check each project's current docs.
† Zep's open-source Community Edition was deprecated April 2025; Zep is now a hosted Cloud product whose open-source engine is Graphiti (shown separately). Cloud-only features are marked ~ for self-hosters.
‡ As of June 2026, Supermemory's engine source is not published — the MIT repo contains SDKs, apps and docs, and npx supermemory local downloads a closed-source precompiled binary. Engine-internal rows marked ‡ cannot be independently verified from source; local-mode facts (file store, single API key, logs-only observability) and paid-tier gates (org air-gap, SOC2/HIPAA, ACL, connectors, the Claude Code plugin) are from their own published docs and pricing.
§ Honcho is AGPL-3.0 — if you self-host and modify, those changes must be open-sourced. memnos is Apache-2.0 with no such requirement. Hindsight is MIT — same as Apache-2.0 for practical commercial use, but lacks the explicit patent grant Apache-2.0 provides.
Honest gaps, conceded (as of June 2026): memnos has no SaaS connectors (Drive / Gmail / Notion), no multimodal ingestion (OCR / video), no one-command npx-style launcher, and a smaller community than Mem0, Zep, Supermemory, or Hindsight. If you need those today, they are real reasons to pick another tool.
mem0 is a per-user memory layer for individual AI assistants. memnos is organizational memory for multi-agent engineering teams. These are different products solving different problems.
Per-user memory for individual AI assistants
Organizational memory for AI engineering teams
The fundamental difference: mem0 remembers what you told it. memnos stores what your team built, decided, and learned — shared across every agent, governed, audited, and enforced. Different scope entirely.
Zep is a hosted temporal-knowledge-graph memory built on Graphiti and a graph database. memnos delivers bi-temporal memory and self-hostable governance on a single PostgreSQL — no graph DB, no cloud dependency.
Temporal knowledge graph
Zep/Graphiti builds a bi-temporal graph of entities and relationships from conversations, with community detection and graph-aware retrieval. A mature, well-engineered approach.
Managed cloud
Zep Cloud is a polished hosted product with SDKs, a dashboard and multi-tenant auth — a good fit if you'd rather not self-host your memory layer.
One engine, not a graph database
Zep's engine (Graphiti) requires a graph database — Neo4j, FalkorDB or Neptune. memnos runs entirely on one PostgreSQL + pgvector you already know how to operate. No second store to scale, secure or back up.
Deterministic writes, not LLM-judged
Both are bi-temporal. The difference is how conflicts resolve: Zep/Graphiti use an LLM to detect and invalidate contradicting edges; memnos supersedes by rule (same subject + attribute), so writes are predictable and reproducible.
Self-hostable governance
Zep's Community Edition was deprecated in 2025; auth, audit and the console now live in Zep Cloud. memnos ships token auth, namespace ACL, audit + cost ledger and an encrypted secret vault in the open-source build you self-host.
No LLM at query time
memnos answers retrieval with hybrid search + RRF + a cross-encoder by default — no generative model in the loop. Graphiti's default reranker is an LLM classifier, adding latency and cost to every recall.
Mem0, Zep and Graphiti are strong. Here's the honest difference — the things memnos is built around that the others don't combine.
When a fact changes, memnos closes out the old value by rule (same subject + attribute) and keeps lists additive — no LLM guessing what to add, update or delete at write time. Bi-temporal, so you can also ask what was true on any past date.
# belief change supersedes deterministically
remember("Alex lives in Austin")
remember("Alex moved to Seattle")
# recall now returns Seattle (current);
# Austin retained with valid_to for as-of queriesRule-based, not LLM-guessed.
Token auth, namespace ACL, a full audit trail, a usage/cost ledger, and an encrypted secret vault with ingest secret-redaction — in the open-source build. The memory players treat governance as a cloud add-on, if at all.
# every call is authed, scoped, audited
memnos token alice
memnos grant alice "org:acme:*"
memnos secret set openai # AES-256-GCM vault
# pasted secrets are redacted before storageOpen-source governance, not a paid add-on.
We publish the full judge band — the same answers under strict, standard and lenient rubrics — plus per-question predictions in the repo, so you can see exactly how much the grader moves any number. The harness is open; reproduce it yourself.
# LoCoMo, full 10 conversations — from scratch
gpt-4o judge : 64–65% # 3 independent ingests; predictions published
# same answers, judge band: 44% .. 88%
$ python benchmarks/locomo_eval.py --sample-ids 0,1,2,3,4,5,6,7,8,9
# LongMemEval, 500 questions — Supermemory's open MemoryBench harness
gpt-4o judge : 78.4% # predictions publishedReproducible, not self-graded. How benchmarks are really measured →
Supermemory is a polished cloud-first platform with SaaS connectors and a local launcher. memnos is an open-engine, self-hosted memory layer built on PostgreSQL — no closed binary, no cloud dependency for governance.
Cloud-first memory platform with connectors
npx supermemory local), broad connector library (Drive, Gmail, Notion, Slack)Open engine, governed by default, runs on your Postgres
The honest split: Supermemory wins on connectors, multimodal, and DX if you're cloud-first. memnos wins on open engine, governance in the free tier, bi-temporal correctness, and running entirely on your own Postgres. We ran our 78.4% LongMemEval score on their own open benchmark harness — it's the fairest comparison we can make.
Mnemosyne (github.com/AxDSan/mnemosyne) is a popular lightweight alternative — zero dependencies, SQLite-backed, sub-10ms local retrieval. memnos solves a different problem: shared, governed memory for teams on a real database.
Zero-dependency local memory — SQLite, single user
pip install, no Postgres, no Docker — runs anywhere including on the same thread as the agentsleep()Team memory — shared, governed, on your Postgres
The honest split: Mnemosyne is the right tool for a solo developer who wants memory in under 60 seconds, no ops, no database. memnos is the right tool when two or more people (or agents) share the same memory, when you need to audit who wrote what, or when "my SQLite file" isn't a sufficient backup strategy.
Honcho (honcho.dev) is a managed memory-infrastructure service with a proprietary reasoning pipeline (Neuromancer) and strong benchmark results. It targets developers building AI products on managed cloud. memnos is self-hosted, Apache-2.0, and runs no LLM at query time.
Managed reasoning-first memory service · AGPL-3.0 · 5,600+ stars
context() retrieval: unlimited, ~200ms — no per-query LLM cost at this tier. Optional reasoning queries (active synthesis) cost $0.001–$0.50 each (Minimal→Max)Self-hosted · Apache-2.0 · no LLM at query time
A note on benchmark comparisons
Honcho's LongMemEval S: 90.4% and memnos's LongMemEval: 78.4% share the same judge (GPT-4o) and the same dataset (LongMemEval S, 500 questions) — that's more directly comparable than most vendor cross-comparisons. The meaningful variable is the answering model: Honcho uses Claude Haiku 4.5 (a cheaper model) yet scores 12 points higher, because Honcho's Representation + Dreaming pipeline surfaces a precise 11% of relevant context, while memnos retrieves a broader set. For LoCoMo the judge differs: Honcho uses GPT-4o-mini; memnos uses gpt-4o — those 89.9% vs 64–65% numbers are not comparable (the same answers can differ 15–20 points by judge alone — documented on our benchmarks page). Both teams publish reproducible harnesses — run both on your data with your judge and form your own view.
The honest split: Honcho is a managed reasoning service — you pay per-query for LLM-powered extraction and synthesis, and you get high benchmark scores in return. memnos is self-hosted infrastructure that runs no LLM at retrieval time — lower raw benchmark ceiling, but zero per-query cost, no cloud dependency, Apache-2.0 licensed, and every line of the engine is yours to read and modify.
Hindsight (vectorize.io) is the strongest recall-performance competitor in the space — MIT licensed, pure PostgreSQL, 17k+ GitHub stars. An honest read: they lead on benchmarks and community. memnos leads on governance and benchmark transparency.
Agent memory platform · MIT · 17k+ stars · vectorize.io
Self-hosted · Apache-2.0 · governed by default
Benchmark comparison note
Hindsight's leaderboard (94.6% LongMemEval S) and memnos's result (78.4%) are measured with different judges: memnos uses GPT-4o; Hindsight uses Gemini (version undisclosed). The same answer set can differ 15–20pp by judge alone — a gap we document with our full judge ladder. Hindsight's published paper (arXiv:2512.12818) reports 91.4% for the same config with Gemini-3, not 94.6% — that unexplained 3.2pp drift between the paper and the leaderboard is worth noting. Their LoCoMo claim of 92% is also flagged in their own docs as potentially unreliable due to "flawed ground truth" in that dataset. Both teams publish open harnesses — run both on your workload, with the same judge, before making infrastructure decisions.
The honest split: Hindsight and memnos make the same core architectural bet (PostgreSQL, no separate graph DB) and differ on where they put their energy. Hindsight invests in benchmark-optimised recall and a large integration surface. memnos invests in governance-first design (enforced ACL, audit trail, bi-temporal provenance, encrypted vault) that works correctly by default without disciplined tag usage from every developer on the team. Choose by what breaks first in production: recall accuracy or data governance.
A different category entirely — an agent runtime, not a memory layer. Verified against published repos and docs as of June 2026.
An agent runtime — a different category
A note on capture that applies to all vendors: no memory product — ours included — can capture automatically through MCP alone; the MCP spec has no post-response event, so MCP capture is always at the model’s discretion. memnos ships deterministic capture where the platform allows it (Claude Code hooks, the memnos proxy for base-URL clients) and best-effort MCP tools everywhere else. Claude Desktop allows tools only — for every vendor.
Self-host with Docker in 90 seconds. Apache-2.0 licensed. No lock-in. If you're running AI-assisted engineering at any scale, your team needs a memory layer built for teams — not individuals.