LLM Memory Comparison: 11 Memory Systems Side by Side

11 min read

LLM memory comparison table: Mem0, Zep/Graphiti, Letta, Cognee, LangMem, Supermemory, Hindsight, Honcho: license, storage, retrieval, hosting, benchmarks.

This LLM memory comparison puts eleven memory systems for LLM agents side by side: what license they use, how they store memories, how they retrieve them, whether you can self-host, and which benchmarks they publish. Every fact was checked against the project’s GitHub README or docs on 8 October 2026. Where a number is self-reported, the table says so.

This page is the fact sheet. For advice on which one to pick, see how to choose the best AI memory framework. For the concepts behind the columns, see AI agent memory explained.

What is an LLM memory system?

An LLM memory system stores information from an agent’s conversations and work outside the model, then retrieves the relevant parts into the prompt on later calls. It usually extracts facts or events with an LLM, keeps them in a vector, graph or relational store, and searches them per user or agent. It’s what gives a stateless model long-term memory.

Memory engine, memory layer, memory system: the same thing

“AI agent memory engine”, “AI memory layer” and “LLM memory system” all name the same component: the service that decides what an agent keeps, where it is stored, and what comes back into the prompt. Vendors pick different words for it. Cognee calls itself a memory engine, Mem0 and Memori call themselves a memory layer, Supermemory describes a “memory engine” inside its API, Hindsight calls itself a memory server. None of those labels implies a different architecture: to compare them you still have to look at the write path, the store and the retrieval method, which is what the tables below do. The only real split is where the engine runs: a library inside your process (Mem0, LangMem, Cognee), a server you host (Hindsight, Graphiti, Honcho, MemOS), or a cloud API you call (Zep, Supermemory, Vertex AI Agent Engine Memory Bank).

LLM memory comparison table: license, storage and hosting

SystemLicenseStorage modelRetrievalSelf-hostHosted option
Mem0Apache-2.0Extracted facts in a vector store (local Qdrant by default; Postgres + pgvector for the server), plus an entity collectionSemantic + BM25 + entity matching, fusedLibrary or Docker serverMem0 Platform
GraphitiApache-2.0Temporal knowledge graph: entities, facts with validity windows, episodesSemantic + BM25 + graph traversalYes (Neo4j, FalkorDB or Neptune)No (that’s Zep)
ZepCommercialGraphiti-based context graphs on Zep’s own graph engineSame as Graphiti, pre-tunedCommunity Edition deprecatedZep Cloud, or in your cloud
LettaApache-2.0Git-backed memory files (MemFS) and memory blocks the agent editsAgent-driven: message search, files in contextYes (local backend)Letta Cloud
CogneeApache-2.0Knowledge graph + vectors + relational (SQLite, LanceDB, LadybugDB by default)Graph, vector, summary or hybrid; auto-routedYesCognee Cloud
LangMemMITLangGraph store (in-memory, Postgres or other backends)Agent tool search over the store’s vector indexYesThrough LangGraph Platform
SupermemoryRepo MIT; local server source not publicExtracted memories, user profiles, documentsHybrid search (documents + memories), profilesFree local binary (“lite license”)Supermemory API
HindsightMIT, full server includedWorld facts, experiences, observations, mental models on Postgres + pgvector (or Oracle)Semantic + BM25 + graph + temporal in parallel, RRF fusion, cross-encoder rerankDocker, pip, Helm, embeddedHindsight Cloud
HonchoAGPL-3.0Messages and per-peer representations on Postgres + pgvectorPeer representations, search, natural-language queriesYesapi.honcho.dev
MemOSApache-2.0Graph-structured memory “cubes”; server uses Neo4j + Qdrant, local plugin uses SQLiteHybrid (full-text + vector)YesMemOS Cloud
MemoriApache-2.0Structured state in your own database (BYODB) or Memori CloudAutomatic recall through a wrapped LLM clientBYODBMemori Cloud

Two notes the table can’t hold. Mem0 removed graph memory from its open-source SDK in v3 (“not being replaced by an OSS equivalent”); it’s now a platform feature. And Letta’s main repo now points to letta-ai/letta-code; the Letta V1 API server lives on an archive branch.

How each system writes memory

The write path is where these systems differ most. It decides cost per message and how well memory handles changed facts.

SystemCore APIWho decides what to saveHow updates are handled
Mem0add, searchYour code calls add; an LLM extracts factsSince April 2026, ADD-only: “nothing is overwritten,” time-aware retrieval picks the current fact
Graphiti / Zepadd_episode, searchYour code adds episodes; an LLM extracts entities and edgesOld facts are invalidated with an end date, not deleted
LettaAgent tools, /rememberThe agent itself, plus background “dreaming”The agent rewrites its memory files; changes are git-tracked
Cogneeremember, recall, improve, forgetYour code; improve applies feedback and session lessonsEnrichment and feedback stages; explicit forget
LangMemMemory tools + background managerThe agent (hot path) or a background managerManager “extracts, consolidates, and updates” memories
Supermemoryadd, profile, searchYour code; extraction is automaticResolves contradictions, expires temporary facts
Hindsightretain, recall, reflectYour code (or an LLM wrapper that does it per call)Background consolidation into observations that are refined, not overwritten
HonchoMessages on sessions, then queryYour code stores messages; Honcho reasons in the backgroundPeer representations updated from a queue
MemOSUnified add, retrieve, edit, deleteYour code; async ingestion through MemSchedulerNatural-language feedback can correct or replace memories

Published benchmark results

Most memory vendors report scores on LoCoMo (long multi-session conversations) and LongMemEval (500 questions on extraction, multi-session reasoning, temporal reasoning, knowledge updates and abstention). Some now add BEAM, which goes up to 10M tokens.

Read this table as a list of claims, not a ranking. Each vendor ran its own evaluation, with its own answer model, judge model, retrieval budget and prompt. A two-point gap between vendors means little.

SystemBenchmark results it publishesSourceWho ran it
Mem0LoCoMo 92.5, LongMemEval 94.4, BEAM 1M 64.1, BEAM 10M 48.6Mem0 README / research, April 2026Self-reported; on the managed platform, which “includes proprietary optimizations not available in the open-source SDK.” Eval code is open source
Mem0 (paper)On LoCoMo: 26% relative gain over OpenAI’s memory on LLM-as-judge, 91% lower p95 latency and 90%+ token savings vs full contextarXiv 2504.19413, 2025Self-reported
ZepDMR 94.8% vs MemGPT’s 93.4%; on LongMemEval, accuracy gains up to 18.5% and 90% lower latency vs baselinearXiv 2501.13956, 2025Self-reported
Hindsight (paper)LongMemEval 91.4%, LoCoMo up to 89.61%; with a 20B open model, 83.6% vs 39% for full context on the same modelarXiv 2512.12818, Dec 2025Vendor-run; README says research collaborators at Virginia Tech’s Sanghani Center and The Washington Post reproduced the results
Hindsight (site)LongMemEval-S 94.6%, LoCoMo10 92%, BEAM 100K 75, BEAM 1M 73.9, BEAM 10M 64.1, PersonaMem 32K 86.6benchmarks.hindsight.vectorize.ioVendor-run; Mem0’s own comparison page lists the same LongMemEval, LoCoMo, BEAM 1M and BEAM 10M scores
SupermemoryClaims #1 on LongMemEval, LoCoMo and ConvoMem; 95% Recall@15 on LongMemEval with ~720 tokens of contextSupermemory READMESelf-reported. Recall@15 is a retrieval metric, not answer accuracy
MemOSLoCoMo 88.83, LongMemEval 89.20, BEAM-10M 56.75MemOS READMESelf-reported, via its own OmniMemEval harness
MemoriLoCoMo 87% with an average 721 tokens per queryMemori READMESelf-reported
CogneeBEAM 100K: 0.79; BEAM 10M: 0.67Cognee BEAM reportSelf-reported; Cognee calls the 10M result “exploratory” because settings were tuned on the scored questions
HonchoPublishes LongMemEval and LoCoMo evalshoncho.dev/evalsSelf-reported
Letta, LangMemNo memory benchmark scores in their READMEs

A competitor’s table that puts Hindsight first

Every row above is the vendor scoring itself, which is the main reason the table can’t be read as a ranking. One partial exception is worth knowing, and it is worth being precise about what it is and isn’t.

Mnemosyne, an MIT-licensed SQLite memory layer with about 3,455 GitHub stars, ran BEAM on itself and published the result next to Hindsight’s: Mnemosyne 65.2%, Honcho 63.0%, Hindsight 73.4%, LIGHT 35.8%, plain RAG 32.3% at the 100K scale. Its README states plainly: “Hindsight leads on this benchmark as published.”

What that is: a competing project putting a rival ahead of itself in its own README, which a vendor comparison page rarely does. What it is not: an independent re-run. Mnemosyne measured its own 65.2% and took Hindsight’s 73.4% from Hindsight’s published results, and its own caveat says the two used different judge models (DeepSeek V4 Flash for Mnemosyne’s run, Llama-4-Maverick for Hindsight’s), so the scores in that row are not directly comparable. Mnemosyne also labels its figures as measured on v3.0.0 (May 2026) and not re-run since. One more mismatch to note, since a reader can spot it: Hindsight’s own benchmarks site lists 75 at BEAM 100K, not the 73.4 Mnemosyne’s table quotes, so even a borrowed number has drifted between the two pages. Nobody outside the vendors has yet run BEAM across these systems under one judge, which is the measurement the field is still missing. The two systems are compared in full in Mnemosyne vs Hindsight.

Two patterns stand out. First, the top claimed scores on both main benchmarks are now in the high 80s to mid 90s, so these tests may be close to saturated for separating systems. Second, larger tests like BEAM 10M show much bigger spreads, though only a few vendors report them: Cognee 0.67 (its own “exploratory” run), Hindsight 64.1, MemOS 56.75 and Mem0 48.6. For how these benchmarks work and where they fall short, see LLM memory evaluation.

Per-system notes

Mem0

The most adopted memory layer by GitHub stars. Three deployment modes: Python/npm library, self-hosted server, and hosted platform. Its April 2026 algorithm moved to single-pass ADD-only extraction with entity linking. Hybrid BM25 and entity search in the open-source library need the [nlp] extra and a spaCy model; without it, search is semantic-only. More in what is Mem0.

Zep and Graphiti

Graphiti is the open-source temporal graph framework; Zep is the managed product built on it, with users, threads, a dashboard and a proprietary graph engine. Zep’s README claims “sub-200ms” retrieval at scale. Graphiti also ships an MCP server. Compare in Zep vs Mem0.

Letta

Letta Code is a stateful agent harness from the MemGPT authors. Agents keep memory in a git-backed filesystem and rewrite their own memory, skills and prompts. It’s a runtime more than a memory library.

Cognee

Builds a knowledge graph from text, code and conversations, and runs locally with small models and no LLM key. Supports Python, TypeScript, Rust and a REST API. Running the whole layer on Postgres is a demo feature; the production version is licensed.

LangMem

A memory toolkit for LangGraph: hot-path memory tools, a background memory manager, and prompt optimization. It works with any storage through a functional core, with native LangGraph store support.

Supermemory

Memory, RAG, user profiles, connectors and file processing behind one API. The GitHub repo is MIT, but its docs state the local server’s “source is not in the public repository,” so self-hosting means running a free binary, not building from source.

Hindsight

Built by Vectorize. Separates world facts from the agent’s experiences, consolidates them into observations with evidence, keeps mental models (standing answers refreshed in the background), and adds reflect for reasoning over memory. Everything, including graph and temporal recall, is in the MIT release, with no paid-only features. It works with 25+ LLM providers, local ones included, and 60+ integrations, with native plugins for Claude Code, Codex, Cursor and Copilot plus an MCP endpoint per memory bank.

Its clearest data-backed lead is on long histories: 73.9 vs Mem0’s 64.1 on BEAM 1M and 64.1 vs 48.6 on BEAM 10M, by Mem0’s own comparison. The cost: Mem0 measured it returning 24K-44K tokens per retrieval against Mem0’s under 7K, so set max_tokens lower if prompt size matters. Its README also notes it may be overkill for simple workflows. More in Mem0 vs Hindsight. Vectorize’s own comparisons, such as Hindsight vs Mem0, are vendor-written.

Honcho, MemOS and Memori

Honcho (Plastic Labs) models users, agents and groups as peers and reasons about them in the background; see Honcho LLM memory. MemOS (MemTensor) frames memory as an operating system with composable memory cubes and plugins for OpenClaw and Hermes Agent. Memori (Memori Labs, formerly under GibsonAI) wraps your LLM client and stores structured state in your own database or its cloud. Three things to know, from its GitHub README, paper and docs (checked 2026-10-25):

  • Extraction still goes to Memori’s servers by default. In BYODB mode, the Python SDK sends conversations to Memori’s hosted augmentation API and writes the results to your database. Your own database keeps the stored memory, not the extraction step. Hindsight runs extraction on your own server, with any of 25+ LLM providers, including local ones.
  • The LoCoMo numbers are Memori Labs’ own runs. The README and results page say 87.0% at 721 tokens per query. The paper says 81.95% at 1,294 tokens. Mem0’s own comparison page lists Mem0’s platform at 92.5, against the 62.47 Memori measured for Mem0. Hindsight’s vendor-reported LoCoMo score is 92.
  • The API changed. Code written for the old memorisdk package (conscious_ingest=True, memori.enable()) does not run on the current memori package (3.3.6, May 2026). The OpenClaw and Hermes integrations store memory in Memori Cloud only; running them on your own database is on the roadmap.

Which is the best LLM memory?

No system wins on every axis, and the published benchmarks can’t settle it. The deciding factors are usually license and hosting, the shape of your data, and how much infrastructure you’re willing to run. If your agent’s histories run into the millions of tokens, or you want graph, temporal recall and consolidation fully open source, the published data points to Hindsight; if the smallest prompt per retrieval matters most, Mem0. The decision guide by use case walks through those choices, and open-source memory systems compared covers repo activity, stars and languages.