Agent memory

What to look for

The questions that separate the options, in order of how much they matter.

1. 01

   How memory is stored, and what that lets you ask

   Storage decides which questions a memory layer can answer. Vector stores (Mem0's open-source SDK, Honcho, RetainDB) find text that resembles the query, so two versions of a fact both come back and ranking has to choose. Knowledge graphs (Cognee, Mem0's paid graph memory) link entities, which helps with questions that join several facts. Temporal graphs (Graphiti and Zep) date every fact and mark it invalid when contradicted, so an agent can say what is true now and what was true last quarter. Hindsight keeps vectors, entities and time series together in Postgres. Single files (Mnemosyne and Holographic in SQLite, Memvid's .mv2) need no server and suit one user or one device. Markdown and git files (ByteRover's topic tree, Letta's MemFS) are the easiest to read and audit, and the reference memory MCP server is a plain JSONL file with substring search only.

2. 02

   Extraction, contradictions and stale facts

   Most layers send every write to an LLM that pulls out facts, so each write costs a model call and the extraction model's mistakes become your memory. Then check what happens when a fact changes. Since April 2026 Mem0's extraction only adds, so a user's old job sits beside the new one. Graphiti and Zep invalidate the old fact but keep its history; Hindsight merges facts into observations that are strengthened or weakened by new evidence; RetainDB links contradictions and gives facts valid-until dates. Mnemosyne's conflict resolver is off by default, Memvid documents no contradiction handling, and Holographic makes no LLM extraction call: the agent writes, updates and contradicts facts itself. Asynchronous designs (Honcho's deriver, Hindsight's consolidation) also lag, so a fact from the last turn may not be in the answer yet.

3. 03

   Benchmarks: whose run, which model, which metric

   LongMemEval (500 questions across five abilities, including knowledge updates and abstention) and LoCoMo (conversations of about 300 turns over up to 35 sessions) are the common tests, with BEAM for very long histories. Almost every published score is the vendor's own, with an answering and judging model it chose, so scores do not compare across vendors. Zep reports 90.2% on LongMemEval with gpt-5.4 answering and judging; Supermemory's table lists Zep at 71.2% from an older GPT-4o run. Supermemory's 97% is Recall@20, whether the right memory was retrieved, not answer accuracy, which its own report puts at 81.6% to 85.2%. Hindsight's results were reproduced by researchers who co-authored its paper, and its competitor figures were copied, not rerun; ByteRover and Memvid also compare against rival figures copied from other papers. Mnemosyne withdrew a 98.9% LongMemEval figure for lack of a run log. Honcho graded LoCoMo with an LLM judge rather than the paper's F1 metric. Run the open harnesses (Mem0 publishes one) on your own conversations before trusting any table.

4. 04

   Latency, measured on whose hardware

   Retrieval sits in front of every reply, so its latency adds to every turn. Layers that make no LLM call at query time post the lowest figures: Zep reports p50 and p95 retrieval of 104 and 162 ms on LongMemEval for its managed service, Honcho's context reads take about 200 ms, and Holographic's keyword recall took 3.7 ms at the median on a desktop CPU. Read claims against their own evidence. ByteRover's paper promises answers in under 100 ms, yet its measurements with caches off show cold queries of 1.2 to 1.6 seconds at the median and up to 2.3 seconds at p95. Memvid quotes 0.025 ms with no corpus size or hardware, and Hindsight publishes no retrieval latency. Natural-language endpoints such as Honcho's chat or Hindsight's reflect run a model on every call and are billed per call.

5. 05

   Self-hosting and licence traps

   Open source on the label does not always mean you can run the product. Supermemory's SDKs and plug-ins are MIT, but its memory engine is closed; the local server is a binary capped at 10,000 documents, and production self-hosting starts on the $399 Scale plan. Zep ended its self-hosted Community Edition in April 2025, so running it yourself means Graphiti plus your own graph database or an Enterprise contract. RetainDB Server is under the Business Source License 1.1, which forbids offering it as a hosted service without a commercial licence. ByteRover archived its Elastic-licensed CLI on 27 September 2026 and version 4 needs a sign-in. Honcho is AGPL-3.0, so a modified Honcho run as a network service obliges you to publish the changes. Memvid is Apache 2.0, but its files stop at 50 MB unless you hold a signed ticket from memvid.com. Hindsight, Graphiti, Cognee, Mnemosyne and Holographic keep their features in the open licence; Mem0 moved graph memory to its paid platform.

6. 06

   Cost per write at scale

   Memory bills grow with what you store, not only with how often the agent reads. Hosted rates per million tokens written vary widely: Hindsight Cloud charges $10 to retain, Supermemory $5 ($0.005 per 1,000 tokens), Honcho $2 and Cognee Cloud $1 processed, so 100 million tokens a month is $1,000 on Hindsight and $200 on Honcho before any reads. Zep bills one credit per episode of up to 350 bytes, so long messages cost several credits, while retrieval is free. Mem0's free plan and RetainDB's plans cap reads separately, and an agent that searches every turn hits that limit first. Self-hosting replaces the fee with extraction calls on every write, plus a database.

7. 07

   Security defaults on a self-hosted server

   A memory server holds everything users have told your agent, and several ship open. Self-hosted Hindsight checks no API key until you set HINDSIGHT_API_TENANT_EXTENSION, and every memory bank gets an MCP endpoint on by default. Honcho ships with AUTH_USE_AUTH=false and needs a JWT secret before it goes on a network. Graphiti's reference MCP and REST servers have no authentication, RetainDB Local runs open on ports 3111 and 3113 unless RETAINDB_API_KEY is set, and claude-mem's local worker has no request authentication. Mem0's self-hosted server and Cognee's API turn auth on by default, though Cognee's quick-start example switches it off and versions before 1.2.0 carry a critical remote code execution advisory. Check telemetry too: Mem0, Graphiti, Cognee and Supermemory's local server send it until you opt out. Finally, anything an agent reads can be saved as a memory and replayed in later sessions, so a prompt injection can outlive the chat that carried it.

8. 08

   Project health and where the product is heading

   Several projects in this stage changed shape in 2026, and a memory store is hard to move. Letta archived its Python API server on 16 August 2026 and removed AgentFile export. ByteRover replaced its open CLI with a desktop app. RetainDB's last package release was 1 June 2026 and Memvid's was 27 May 2026. Holographic passed to a single community maintainer in October 2026 when Hermes Agent stopped bundling it. Prefer a layer that can export its memories in a plain format, and note that Cognee can import from Mem0, Letta, Zep and Graphiti.

14 tools, compared

Ranked by our rating. Open any review for sources, prices and the full verdict.

Agent memory tools compared

Tool	Rating	Our verdict	Best for	Price
HHindsightrepo	4.4/5	Hindsight is the most capable open-source agent memory server you can run today, with nothing held back from the MIT licence, though its benchmark lead rests on numbers its own paper's co-authors reproduced.	Teams that want graph, temporal and vector memory in one self-hostable server without an open-core feature split.	Self-hosted server free under MIT. Hindsight Cloud is usage-billed with $5 of free credit: retain $10 per million tokens, recall $0.75 per million tokens, reflect $0.05 per call, storage $0.25 per million tokens a month after the first 30 days. Enterprise (BYOC, on-premises, SSO) by quote.
Graphitirepo	4.3/5	For agents whose facts change over time, Graphiti is the open-source memory layer to beat, provided you will run a graph database and pay for LLM extraction on every write.	Teams building long-running agents that must remember changing facts about users, accounts or the world.	Free and open source under Apache 2.0. You supply the graph database and pay for LLM and embedding calls during ingestion.
ZZeptool	4.1/5	Zep is the safest hosted pick when your agent must know which facts are current and you want fast, free retrieval, but you pay per message stored and you can no longer run Zep itself without an Enterprise deal.	Teams building long-running agents that must track changing facts about customers and would rather pay for a managed graph than run one.	Billed in credits: one credit per episode of up to 350 bytes, retrieval and storage free. Free $0 with 10,000 credits a month; Flex $125/month with 50,000 credits and $25 per extra 10,000; Flex Plus $375/month with 200,000 credits and $75 per extra 40,000; Enterprise custom (BYOC, SOC 2 Type II report, HIPAA BAA).
HHonchorepo	4.1/5	Honcho is the memory layer to choose when you want an agent to understand a person rather than look facts up, and its AGPL licence is the first thing your lawyers will ask about.	Teams building tutors, companions or support agents that must understand individual users over many sessions.	Server free under AGPL-3.0. Managed service: $2.00 per million tokens ingested (context reads unlimited, dreaming included); chat queries from $0.001 (minimal) to $0.50 (max) each, $0.01 by default. $5 in credits for new accounts and $5 a month once a card is added; Enterprise by quote.
Mem0repo	4.0/5	Mem0 is still the quickest way to give an agent a memory, but the open-source SDK is increasingly the trial version of a platform that keeps graph memory and the best benchmark scores for itself.	Developers adding cross-session user memory to chatbots and agents.	Open-source SDK free under Apache 2.0. Platform: Free (10,000 adds and 1,000 retrievals a month for the first 30 days with model calls included, then 50,000 adds and 10,000 retrievals with your own LLM key, usage-billed beyond that up to a cap you set); Custom plans by quote. The earlier $19 Starter and $249 Pro plans are no longer listed.
SSupermemorytool	4.0/5	Supermemory is the fastest way to give an app memory of its users plus search over their files in one API, as long as you are comfortable that the engine itself is closed and the headline benchmark measures retrieval, not answers.	Product teams that want user memory and document search in a working app this week and do not need to inspect the engine.	Every plan includes monthly credits spent at the same usage rates. Free $0 with $5 of credits; Pro $19/month with $20; Max $100/month with $130; Scale $399/month with $600 (SOC 2, HIPAA BAA, self-hosting option); Enterprise custom. Memory costs $0.005 per 1,000 tokens of text, search $0.005 per 1,000 queries. Supermemory local is free up to 10,000 documents.
Cogneerepo	3.8/5	Cognee builds a shared knowledge graph from almost any source, but its defaults need an owner before they meet production.	Teams building several agents that need a shared knowledge graph assembled from many sources.	Open source under Apache 2.0. Cognee Cloud: free up to 1M tokens and one workspace, then $1 per 1M tokens plus $5 per extra workspace a month; Enterprise is a quoted BYOC engagement.
Lettarepo	3.7/5	Letta still has the most considered ideas about agent memory, but rebuilding the product mid-flight left its earlier users to migrate and newcomers with a fast-moving target.	Developers who want long-running personal or team agents with inspectable, versioned memory and are happy to adopt a whole harness.	Apache 2.0, free to run locally with your own model keys. Letta Cloud: Free (3 agents, 5 MiB per memory repository); Pro $20/month (20 agents, 50 MiB, model quota); API plan $20/month plus $0.10 per active agent a month and $0.00015 per second of tool execution, tokens extra; Teams Pro $20/seat/month; Enterprise custom.
MMnemosynerepo	3.7/5	Mnemosyne is the most self-contained agent memory around, one SQLite file and no services, but its benchmark record is thin and partly withdrawn, so its quality claims still need your own test.	Individual developers and Hermes Agent users who want persistent memory on their own machine without running a database.	Free and open source under the MIT licence. No hosted service or paid tier; costs are your own machine plus any remote embedding or LLM endpoint you choose.
claude-memrepo	3.7/5	Real cross-session memory for Claude Code, wrapped in an installer that steers you towards a hosted subscription and a compression bill you have to watch.	Developers on long-running projects who want the agent to remember past sessions.	Open source (Apache-2.0). Compression runs on your Anthropic plan or your own key. Hosted CMEM plans: Pro $30/month, Heavy $70/month, Max $100/month with overages; TeamBrain pricing not announced.
HHolographicrepo	3.6/5	Holographic is the careful, offline choice for Hermes users who want a fact store they can audit, but it is a one-maintainer plug-in with no standard benchmark and little use outside Hermes.	Hermes Agent users who want inspectable, offline fact memory and are willing to have the agent write facts deliberately.	Free and open source under the MIT licence. Optional search by meaning and reranking call endpoints you choose and pay for.
MMemvidrepo	3.6/5	Memvid is a tidy way to ship searchable memory as one file an agent can carry offline, but it is a document index rather than a memory layer that understands changing facts, and its benchmark lead rests on rivals' 2025 figures.	Developers building offline or edge agents that need a searchable, portable knowledge file rather than a model of a changing user.	Free under Apache 2.0. The library caps a file at 50 MB by default (the Free tier in the source); larger capacities of 2 GB and 10 GB are unlocked by signed tickets from memvid.com. Cloud plan prices are not published.
BByteRovertool	3.4/5	ByteRover reports a 96.1% LoCoMo score and keeps memory in files you can read, but it has just traded its open CLI for a sign-in desktop app, and that move makes it a harder bet than its numbers suggest.	Small development teams that want their coding agents to share written project knowledge and are comfortable with a young, cloud-synced product.	Free (100 context files synced to the cloud, team sharing); Pro 15 a month billed yearly with unlimited context files (the pricing page shows no currency symbol); Enterprise custom, with SOC 2, SSO, RBAC and on-premises deployment.
RRetainDBtool	2.9/5	RetainDB has a sensible design and cheap plans, but self-run benchmarks it oversells, contradictory pricing and five quiet months make it hard to trust with a product's memory.	Developers prototyping agent memory on a small budget who can tolerate an early, thinly staffed supplier.	Starter free (20,000 memory writes and 5,000 context reads a month, 1 project); Builder $9/month (75,000 writes, 15,000 reads); Pro $29/month (250,000 writes, 75,000 reads); Scale $99/month (1,000,000 writes, 300,000 reads); Enterprise custom. The page title still advertises $20/month, which matches no listed plan.

Side by side

The specifications that matter for this step. Checked Nov 6, 2026; confirm on the vendor’s site before you commit.

Connect it to your agent

MCP servers that let assistants like Claude, ChatGPT and Cursor use these tools directly.

• Memory (reference server) 3.5
• MCP Memory Keeper 3.4

Sources for this guide

• LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory (arXiv)
• Evaluating Very Long-Term Conversational Memory of LLM Agents (LoCoMo, arXiv)
• Zep: A Temporal Knowledge Graph Architecture for Agent Memory (arXiv)
• Hindsight is 20/20: Building Agent Memory that Retains, Recalls, and Reflects (arXiv)
• Zep memory benchmarks
• Supermemory research
• ByteRover: Agent-Native Memory Through LLM-Curated Hierarchical Context (arXiv)
• Mnemosyne BEAM benchmark report
• Honcho evals
• Vectorize pricing (Hindsight Cloud)
• Announcing a New Direction for Zep's Open Source Strategy