Six AI memory systems, six different definitions of memory

TL;DR

• Mem0, Letta, Zep/Graphiti, Cognee, Supermemory, and Mnemoverse make six different architectural bets on what agent memory is. They are not interchangeable storage layers.
• The first decision is integration posture: drop-in API, agent harness, graph library, memory engine over your sources, managed context engine, or MCP-first managed API. Self-host reality is often different from what the license label suggests.
• Only Zep/Graphiti keeps a validity window on every fact by default. Cognee can end-date a replaced fact by hand and sells bi-temporal memory in its Enterprise tier; the others track which version of a fact is current, when a described event happened, or when something was written, which answers a different question.
• Vendor benchmark numbers have not survived reproduction so far: Mem0's LongMemEval figure fell from a claimed 93.4% to 73.8% under Maximem's harness (Maximem is itself a memory vendor). Always ask for the harness, and who runs it.

An agent memory choice starts before retrieval quality. It starts with a boundary question: how much of the application should the memory system own?

Choosing a memory layer for an AI agent in autumn 2026 means picking an architecture, not just a feature list. Mem0, Letta, Zep/Graphiti, Cognee, and Supermemory, plus Mnemoverse, which publishes this page, each answer the boundary question differently.

This is the September 2026 edition of a recurring comparison and replaces the Q3 edition. Mnemoverse is compared on the same dimensions as the other five, and its row is the publisher's own description: by this article's rule, ask for the harness and who runs it, and read that row as a vendor's claim. Every fact about the six systems was re-checked against their documentation, release notes, and pricing pages on September 28, 2026, and a future edition will supersede this one. For the wider market, platform memory from OpenAI, Anthropic, Google, and Microsoft plus the funding picture, see the parent AI memory landscape 2026.

Correction, 2026-09-28: the Q3 edition said Cognee has no BM25 or dedicated temporal retrieval, that self-hosting Graphiti requires Neo4j, that Mem0 cannot answer point-in-time questions and that its extraction is not easily customized, and that Zep offers less retrieval diversity than Cognee. Cognee's lexical and temporal search modes, Graphiti's embedded FalkorDBLite, Mem0's platform temporal reasoning and custom instructions show these were wrong or out of date; this edition replaces them. It also said Supermemory's clients are MIT, while its SDKs are Apache-2.0, and attributed LongMemEval figures of 49.0% for Mem0 and 63.8% for Zep to one Vectorize measurement with GPT-4o; they come from an independent paper with a GPT-5-mini reader and from Zep's own paper with gpt-4o-mini. And it removes a statement that Mnemoverse has no self-host path: self-hosting is available on the Enterprise plan by agreement.

Correction, 2026-08-03: an earlier version of this page said Mem0's self-editing pipeline resolves conflicting facts on write, and that OSS graph memory runs over Neo4j or Memgraph. Both describe the pre-v3 algorithm; Mem0's current OSS extraction is ADD-only and its external graph-store drivers were removed in SDK v2.0.0 (migration notes, v2.0.0 release). See agent memory deduplication for the code-level reading.

If you are new to the category, AI agent memory explains what these systems actually store and recall.

Six AI memory systems at a glance

Agent memory is persistent knowledge an AI system can store, retrieve, update, and verify across sessions instead of rebuilding context from scratch. These six systems implement it in six different shapes:

• Mem0 extracts facts across user, agent, run, and app scopes, then fuses semantic, BM25, and entity signals on retrieval.
• Letta runs an agent harness whose memory is a git-tracked set of files that the agent reads and edits with file tools.
• Zep/Graphiti stores facts inside a bi-temporal knowledge graph, tagging each with when it became true and when it stopped being true.
• Cognee builds a persistent knowledge graph from source material and offers a wide set of search types over it.
• Supermemory exposes a managed context engine that maintains cross-session profiles behind an automatic memory layer.
• Mnemoverse, the publisher of this page, stores memories in a learned concept-association graph over semantic embeddings and re-ranks recall by the outcomes an agent reports.

The rest of this article expands each system, compares them across eight dimensions, and explains why their benchmark numbers cannot be stacked into one ranking.

Mem0: extracted facts as a memory layer

Mem0 is a memory orchestration layer, not a database. Its open-source extraction is ADD-only as of the v3 algorithm (Python SDK v2.0.0, released 2026-04-16): add() returns only ADD events, with no separate UPDATE or DELETE pass, so conflicting facts accumulate and retrieval ranking surfaces the current one (Mem0 v2 to v3 migration). On the managed platform, a background process Mem0 calls Dream marks outdated memories as superseded instead of deleting them, and a latest_only option returns only the current version (Dream). Memories are scoped by user, agent, run, and app. Retrieval fuses semantic search, BM25, and entity matching. The default library stack uses Qdrant for vectors and SQLite for history; the self-hosted server swaps in Postgres with pgvector (Mem0 overview). External graph-store support, roughly 4,000 lines of Neo4j, Memgraph, Kuzu, and AGE driver code, was removed in Python SDK v2.0.0 and replaced by entity linking inside the existing vector store (v2.0.0 release notes); graph memory remains a platform feature. Extraction can be steered with custom instructions and custom categories. The open-source core is Apache-2.0, the current Python SDK is v2.2.1 (September 25, 2026), and the repository held 66,223 stars on September 28, 2026 (GitHub API). Mem0 announced $24 million raised across its Seed and Series A in October 2025 (Mem0).

This shape fits a team that already has an agent runtime and wants to add memory without adopting a new execution model.

Weaknesses. The headline vendor benchmark numbers do not reproduce under a competitor-run harness, the most important buyer caveat, covered in the benchmark section below. The open-source library stores timestamps and optional expiration dates but has no validity windows (memory expiration). Since May 13, 2026 the platform boosts memories whose event dates match a time expression in the query, such as "last week" or "as of March 2025" (Temporal Reasoning), which is date-aware ranking rather than a record of when a fact stopped being true. Graph memory and Dream synthesis sit on the Pro plan at $249 per month, a step up from the $19 Starter plan for teams that want the full feature set; Enterprise adds on-premises deployment (Mem0 pricing).

Letta: memory inside an agent harness

Letta is an agent harness, not a bolt-on memory API. Its current memory model, MemFS, keeps an agent's memory as a git-tracked repository of Markdown files: the system/ folder is placed in the prompt on every turn, and the agent reads the rest with file tools when it needs them (MemFS). A sleep-time step Letta calls dreaming lets background subagents review recent turns and write lessons back to memory (Letta memory docs). The runtime is the Letta agent harness, also called Letta Code (v0.33.5, September 28, 2026; terminology). It runs locally as a CLI or as an App Server with an OpenAI-compatible API, with state kept on the device and no account required (self-hosting). The earlier V1 server, with its Core, Recall, and Archival memory tiers, was archived on August 16, 2026. Its repository, letta-ai/letta, now points to letta-ai/letta-code, where the source lives; on September 28, 2026 the original repository held 24,954 stars and letta-code 3,467 (GitHub API). Both are Apache-2.0. Cloud pricing starts free for three agents and moves to $20 per month for twenty; an API plan costs $20 per month plus $0.10 per active agent (Letta pricing). Letta raised a $10 million seed in September 2024 at a reported $70 million post-money valuation.

Weaknesses. Adopting Letta means adopting its harness, which commits more of the agent's architecture than a drop-in memory API would. MemFS builds no knowledge graph and has no vector index by default; semantic search over memory files is an optional mod, and vector search over conversation history is on Letta Cloud only (MemFS).

Zep and Graphiti: native bi-temporal memory

Zep is a managed context service built around Graphiti, an open-source temporal-graph library. Every fact in the graph carries four timestamps: created_at, valid_at, invalid_at, and expired_at. When a fact is superseded, the prior edge is invalidated rather than deleted, which preserves an audit trail (Zep facts, temporal knowledge graph). Retrieval combines semantic embeddings with BM25 full-text search, can bias results toward connected nodes with breadth-first graph search, and reranks the combined list (Zep graph search). Self-hosted Graphiti runs on Neo4j, FalkorDB, an embedded FalkorDBLite (since v0.29.2), or Amazon Neptune (Graphiti README); the older Zep Community Edition is deprecated. Graphiti held 31,265 stars on September 28, 2026 (GitHub API), and its latest release is v0.30.2. Zep is a Y Combinator company (W24). Zep Cloud has a free tier of 10,000 credits a month; Flex is $125 per month with 50,000 credits and $25 per additional 10,000, Flex Plus is $375 per month with 200,000 credits, and Enterprise adds deployment into the customer's own cloud account (Zep pricing). Zep now positions itself as a unified context layer for enterprise data.

This is the clearest technical divider in the comparison. A timestamp says when a record was stored. A validity window says when the represented fact was true. That distinction matters for changing roles, addresses, plans, permissions, or account states.

Weaknesses. Self-hosting means running the Graphiti library and its graph database yourself. The embedded FalkorDBLite lowers the entry point, but operating a graph store in production remains your job, and Zep Cloud's own graph store and enterprise features are a separate managed offering. The graph's build, query, and latency costs are treated separately in the GraphRAG tax.

Cognee: a knowledge-graph memory engine

Cognee is a graph-native memory engine. It extracts entities and relations from source material, enriches them with embeddings, and builds a connected knowledge graph; its main operations are now remember, recall, improve, and forget, and the older add and cognify calls remain as legacy operations (Cognee docs). It supports RDF ontologies. Its search types number 20, from plain chunk retrieval and a BM25-style lexical mode to graph completion with chain of thought, a hybrid mode, an agentic mode, and a temporal mode (SearchType). Replaced facts can be closed with an end date on the default graph store. Embedded defaults, SQLite, LanceDB, and the Ladybug graph store that succeeds Kuzu, let a team start with no external infrastructure. It is Apache-2.0, its latest release is v1.6.1 (September 24, 2026), it held 31,126 stars on September 28, 2026 (GitHub API), and it announced a $7.5 million seed in February 2026 (Cognee). The cloud has a free tier of 1 million tokens and a Standard plan at $1.00 per million tokens plus $5 per additional workspace a month; Enterprise is deployed into the customer's own cloud (Cognee pricing).

Weaknesses. Cognee publishes no LongMemEval or LoCoMo score. Its published numbers are on BEAM under its own methodology with an LLM judge, so they cannot be set beside the other systems' results. End-dating replaced facts works on the default Ladybug store, and bi-temporal memory with conflict resolution is sold as an Enterprise feature.

Supermemory: a managed context engine

Supermemory is a managed context API built on what it calls a temporal vector-graph engine. It maintains static and dynamic user profiles and manages memory automatically: memories are related as updates, extensions, or derivations of each other, the current version is flagged, and a memory can be set to expire (Supermemory docs). Its documentation gives a sub-300-millisecond p50 range on the managed platform, a vendor figure, not independently verified. Its main repository, with the apps, MCP server, and integrations, is MIT-licensed and held 30,971 stars on September 28, 2026 (GitHub API); the official Python and TypeScript SDKs are Apache-2.0 (PyPI). TechCrunch reported a $2.6 million seed in October 2025.

Since June 2026 Supermemory ships a free local mode: a prebuilt single-machine server, with macOS and Linux builds and Windows builds since July, that runs the full Memory API (Supermemory self-hosting). Supermemory's documentation describes the local server as free and open source; its source is not in the public repositories we checked, the main repository and the organization's other public repositories, on September 28, 2026. Connectors, the highest-quality extraction models, and the Supermemory MCP remain on the platform (local vs enterprise). The distinction matters during procurement: an open repository, an open client, and an open deployable engine are three different claims.

Weaknesses. The local mode is single-machine and pre-1.0 (latest server-v0.0.8, August 17, 2026). Memory management is automatic: the engine, not the agent, decides what is updated, extended, or forgotten, and an air-gapped deployment depends on a prebuilt binary, with connectors and the MCP staying on the platform.

Mnemoverse: outcome-ranked hosted memory (the publisher)

This section describes the publisher of this page, on the same dimensions as the five above; read it as a vendor's description. Mnemoverse is a hosted memory API that ranks recall by outcomes. Each memory is stored with a semantic embedding and linked into a concept-association graph; when an agent reports that a recalled memory helped or misled, that memory's outcome valence changes, and later reads rank it up or down (how it works, API reference). Reads can be bounded by write time and ordered newest-first, and a correction is written with supersedes, which keeps the earlier memory as history instead of deleting it (Python SDK). Metadata, a client external_ref, and an authorship record on shared writes carry provenance, and the association edges around a concept can be read back with their weights and valence. Integration is MCP-first: a local MCP server with an API key and a hosted connector with OAuth sign-in expose the same tools, alongside REST and the Python SDK (MCP server, remote connector). Rooms (beta) let agents under different accounts write to and read from one membership-checked memory space. The hosted plans start free; Enterprise adds dedicated instances and self-hosting by agreement for security requirements (pricing).

Weaknesses. The engine is not open source: the MCP server and Python SDK are MIT, the engine runs as a hosted service, and self-hosting is an Enterprise arrangement rather than a download. Time filters apply to when a memory was written, not to when the fact it describes was true, so point-in-time questions about the world still need Zep-style validity windows. The client packages are pre-1.0 and Rooms is in beta. Benchmark results are self-published with their configuration (benchmarks); by this article's rule, read them as a vendor's numbers.

Why agent memory benchmark scores need a harness

The single most important caveat for any buyer is that vendor-published benchmark numbers have not survived reproduction so far: the one full reproduction of a vendor headline, of Mem0 and run by a competitor, came in 19.6 points lower.

Mem0's benchmark report gives 92.5 on LoCoMo and 94.4 on LongMemEval at about 6,900 tokens per query, and the report, last updated September 22, 2026, also gives BEAM results (Mem0 benchmark report, retrieved 2026-09-28). Mem0's own April 2025 paper reported 68.4 on LoCoMo for its graph variant (arXiv:2504.19413), a different vintage under a different harness, which is itself a lesson in how these numbers move. On May 27, 2026, Maximem published a reproduction. With gpt-5 as the answer model, a binary judging prompt, five random seeds, and a customer-style ingestion path, it measured 73.8% for Mem0 on LongMemEval after April 14, up from 57.5% before that date. In Maximem's words, "The published claim from the same announcement was 93.4%", and it attributes the gap to benchmark-specific prompt engineering and dataset-specific equivalence rules rather than to the memory system (Maximem reproduction). The two Mem0 figures also differ: the report now leads with 94.4, while the April claim Maximem cites, also in Mem0's migration guide, is 93.4%. Maximem's table also lists Zep at 63.8% and Supermemory at 71.3%, both run on its April 10, 2026 harness. One more disclosure belongs next to these numbers: Maximem is itself a memory-system vendor, and its own product, Synap, scored 92.0% on the same harness, so this is a competitor-run reproduction, not a neutral third party. The finding survives the caveat; the caveat still has to be stated.

An independent paper measured 49.0% on LongMemEval for a Mem0 pipeline with a GPT-5-mini reader (arXiv:2603.04814); Zep's own paper reports 63.8% with gpt-4o-mini and 71.2% with gpt-4o (arXiv:2501.13956). Vectorize, which builds the competing system Hindsight, published a comparison in which Hindsight scored 94.6% against 81.6% for Supermemory (Vectorize: Hindsight vs Supermemory); treat that as vendor-published.

The other systems report their own numbers. Supermemory's May 2026 report gives 97% Recall@20 on LongMemEval-S with aggregation and a gpt-4o judge, a retrieval metric rather than answer accuracy (Supermemory research). Letta reports 74.0% on LoCoMo with gpt-4o-mini under an agent-autonomy framing (Letta benchmarking). Zep's research page reports 94.7% on LoCoMo and 90.2% on LongMemEval with gpt-5.4 as reader and judge (Zep research). Cognee publishes BEAM results under its own methodology and no LongMemEval or LoCoMo score. Mnemoverse publishes its results with their configuration on its benchmarks page and gives no headline number here.

These are not contradictions. They are separate experiments that differ in answer model, judge, ingestion path, prompts, and implementation choices. No single ranking across vendors exists, and none should be asserted. Always ask for the harness, not just the score; when the harness is not public, treat the number as a vendor claim. The broader problems, why judge leniency inflates scores and why benchmark numbers need caveats, are covered in evaluating agent memory and LLM-as-judge patterns.

AI memory solutions compared across eight dimensions

The eight dimensions fall into two questions, and each gets its own table so that every system stays on one screen. The first is what a system stores: the shape of a memory, how it is scoped, how time is handled, and what provenance travels with a record. The second is how you run it: how a read works, what you adopt, where it runs, and the latest release as checked on 2026-09-28. Both omit raw benchmark scores on purpose: those are harness-dependent and belong in prose, not in a side-by-side grid. The Mnemoverse row is the publisher's own.

What each system stores

System	Memory model	Scoping	Temporal handling	Provenance
Mem0	Extracted facts, ADD-only in OSS (v3); vector + entity linking	User, agent, run, and app scopes	Timestamps and expiry; platform date-aware ranking and latest_only	Change history per memory
Letta	Git-tracked memory files (MemFS)	One memory repository per agent	Git history of the files	Git history of edits
Zep/Graphiti	Bi-temporal knowledge graph	Graph with validity windows	Native bi-temporal (valid/invalid)	Edges carry time and source episodes
Cognee	Knowledge graph built from sources	Persistent graph, embedded stores	Temporal search mode; manual end-dating of replaced facts; bi-temporal on Enterprise	Graph edges, ontology
Supermemory	Temporal vector-graph engine + user profiles	Project-scoped, cross-session profiles	Current-version flag, expiry	Relations between versions
Mnemoverse (publisher)	Memories with concepts; embedding + learned association graph; outcome valence	Per-organization domains; Rooms (beta) across accounts	Write-time bounds, newest-first; revision chain via supersedes	Metadata, external_ref, authorship on shared writes, revision chain

How you run each system

System	Retrieval	Integration posture	Self-host vs cloud	Latest release
Mem0	Semantic + BM25 + entity fusion	Drop-in memory API	Both (Apache-2.0); Enterprise on-premises	Python SDK v2.2.1
Letta	File tools; optional semantic search module	Agent harness	Local CLI or App Server (Apache-2.0); cloud	Letta Code v0.33.5
Zep/Graphiti	Embeddings + BM25 + graph traversal, reranked	Graph library or managed service	Graphiti OSS on Neo4j, FalkorDB(Lite) or Neptune; Zep Cloud; Enterprise in your cloud	Graphiti v0.30.2
Cognee	20 search types incl. lexical, temporal, graph CoT	Memory engine over your sources	Both; embedded defaults; Enterprise in your cloud	v1.6.1
Supermemory	Hybrid; sub-300 ms p50 (vendor figure)	Managed context API	Hosted-first; free local single-machine server (prebuilt)	Local server v0.0.8; platform hosted
Mnemoverse (publisher)	Semantic + association expansion, ranked by outcome valence and recency	MCP-first managed API; REST; Python SDK	Hosted; Enterprise self-hosting by agreement; MIT client packages	MCP server v0.13.1; Python SDK 0.3.1

Stars and funding on September 28, 2026, from each project's GitHub API and announcements: Mem0 66.2k and $24M across Seed and Series A; Letta 25.0k on letta-ai/letta (source now in letta-ai/letta-code, 3.5k) and a $10M seed; Graphiti 31.3k, Y Combinator W24; Cognee 31.1k and a $7.5M seed; Supermemory 31.0k and a reported $2.6M seed.

Integration posture is the axis few comparison pages frame. Mem0, Supermemory, and Mnemoverse are drop-in APIs with little surface area; Mnemoverse is reached first through MCP. Letta is a harness: adopt it and it manages the agent's context and sleep-time consolidation. Cognee and Graphiti are library-shaped and can run embedded with no cloud dependency. That distinction decides more than any feature checklist.

Self-host reality is where license labels mislead. Mem0, Letta, and Cognee are Apache-2.0 and run on your own infrastructure with reasonable effort: Mem0 needs a vector store, and Cognee and Graphiti can start embedded. Graphiti is Apache-2.0, but a production deployment still means operating a graph database. Supermemory's local server is free but ships as a prebuilt binary, so an air-gapped deployment means trusting a binary whose source we could not find in its public repositories, and connectors stay on the platform. Mnemoverse's MIT label covers the MCP server and the Python SDK, not the engine, which runs hosted unless an Enterprise agreement says otherwise.

Temporal handling is the sharpest divider. Zep/Graphiti is the only system here that keeps a validity window on every fact by default, so it answers what was true on a past date. Cognee's open-source engine can end-date a replaced fact by hand and check whether it was current at a given moment, on its default graph store only, and its Enterprise tier sells bi-temporal memory. Mem0's platform temporal reasoning, expiration dates and latest_only, Supermemory's current-version flag and expiry, and Mnemoverse's write-time bounds and revision chain each answer part of the question: when a described event happened, which version is current, or what was written when. For compliance or auditing that needs the state of the world on a date, that difference is decisive.

LangMem: the already-on-LangChain option

If an agent already runs on LangGraph, LangMem is the low-friction choice. LangChain's long-term-memory SDK (MIT, PyPI 0.0.30, October 2025, pre-1.0, no release since) offers episodic, semantic, and procedural memory types (LangMem on PyPI, conceptual guide). It is not a peer to the six above: Mem0's April 2025 paper, written by a competing vendor, measured a p95 search latency of 59.82 seconds, which is impractical for interactive agents (arXiv:2504.19413), and its documentation describes no knowledge graph or temporal model. It is compelling only when leaving the LangChain ecosystem costs more than those limits.

Choose the integration boundary first

The practical decision sequence is short. Choose the integration boundary first, then let temporal and self-host needs narrow the field.

1. Choose Mem0 when memory must attach to an existing agent stack as a drop-in layer.
2. Choose Letta when the harness itself should make memory management part of agent behavior.
3. Choose Graphiti or Zep when historical validity, what was true and when, is a core query requirement.
4. Choose Cognee when the main job is turning heterogeneous source knowledge into a queryable graph.
5. Choose Supermemory when a managed context API with automatic profiles is acceptable and engine self-hosting is not required.
6. Choose Mnemoverse when one hosted memory should serve several MCP clients and agents, with recall re-ranked by the outcomes an agent reports; engine self-hosting is an Enterprise arrangement.

For MCP-shaped deployments, apply the selection rubric in how to choose a memory MCP server rather than repeating it here, and see thirteen memory MCP servers compared for the named side-by-side with pricing and registry presence. Teams that need controlled head-to-head evidence should fix one protocol and one judge configuration and run the comparison themselves: the judge, not the memory system, often decides the score.

Common questions

Mem0 vs Zep: which memory layer should I use?

Choose Mem0 for a drop-in fact-extraction layer with hybrid retrieval and Apache-2.0 self-hosting. Choose Zep or Graphiti when facts must carry validity windows. Graphiti also runs on an embedded FalkorDBLite, so a first deployment no longer requires operating Neo4j.

What is the best memory layer for AI agents in 2026?

There is no single best layer. The choice depends on integration posture, temporal needs, and self-host reality. This article gives the deep per-system read; the one-page decision map lives at /library/best-ai-agent-memory-2026.

Do AI memory benchmark scores like Mem0's 93% hold up independently?

Not so far. Maximem's May 27, 2026 reproduction, run by Maximem, itself a memory-system vendor, measured 73.8% on LongMemEval for Mem0 with gpt-5 as the answer model across five seeds, against a published claim of 93.4%.

Self-hosted vs cloud agent memory: what are the trade-offs?

Self-hosting gives control over data and infrastructure but transfers operational work to you. Cloud services reduce that work but can limit engine access and inspection, and a license label alone does not guarantee a practical self-host path.

Mem0 vs Letta: bolt-on memory layer or agent harness?

Mem0 adds memory to an existing agent stack. Letta is an agent harness whose agents keep memory as a git-tracked set of files and edit it with file tools, so you adopt more of the stack.

When do I need a temporal knowledge graph (Zep) instead of vector memory (Mem0)?

Use one when you must answer what a fact was on a past date or audit how knowledge changed. Zep/Graphiti's data model is bi-temporal: every fact carries the time it became true and the time it stopped. Cognee has a temporal search mode, lets you end-date a replaced fact by hand on its default graph store, and sells bi-temporal memory in its Enterprise tier. Mem0's platform ranks memories by the dates of the events they describe and, like Supermemory, marks which version of a fact is current, and Mnemoverse bounds reads by write time and keeps corrections as a revision chain. Only Zep/Graphiti keeps a validity window on every fact by default.

Which AI agent memory tools are open source and can I actually self-host?

Mem0, Letta, and Cognee are Apache-2.0 and self-hostable, and Cognee defaults to embedded stores. Graphiti is Apache-2.0 and runs on Neo4j, FalkorDB, an embedded FalkorDBLite, or Amazon Neptune. Supermemory's main repository is MIT and its SDKs are Apache-2.0; it offers a free local server as prebuilt binaries whose source we could not find in its public repositories. Mnemoverse's MCP server and Python SDK are MIT; the engine is hosted, with self-hosting by agreement on Enterprise.

Where does Mnemoverse fit among these systems?

Mnemoverse publishes this page and is compared in it. It is a hosted memory API that re-ranks recall by the outcomes an agent reports, reached over MCP, REST, or a Python SDK. Read its row as the publisher's own description.

Sources

All web sources were reviewed September 28, 2026. GitHub metrics were captured the same day.

• Mem0: open-source overview, memory expiration, v2 to v3 migration, v2.0.0 release, Dream, Temporal Reasoning, pricing, funding announcement, 2026 benchmark report (updated 2026-09-22), arXiv:2504.19413
• Maximem: claimed vs observed reproduction (2026-05-27)
• Independent LongMemEval evaluation (arXiv:2603.04814); Vectorize: Mem0 vs Zep, Hindsight vs Supermemory
• Letta: MemFS, terminology, memory documentation, self-hosting, pricing, benchmarking post, letta-code repository, seed coverage
• Zep and Graphiti: facts, graph search, Y Combinator profile, temporal knowledge graph, Graphiti repository, pricing, research, Zep/Graphiti LongMemEval paper (arXiv:2501.13956)
• Cognee: repository, SearchType, documentation, pricing, seed announcement
• Supermemory: documentation, self-hosting overview, local vs enterprise, research, releases, Python SDK on PyPI, seed coverage
• LangMem on PyPI
• Mnemoverse: how it works, API reference, MCP server, remote connector, Rooms, Python SDK on PyPI, pricing, benchmarks
• GitHub star counts (2026-09-28): Mem0, Letta, Letta Code, Graphiti, Cognee, Supermemory

Related

• AI memory landscape 2026: parent landscape with platform memory, the funding table, and academic survey.
• How to choose a memory MCP server: the 5-question rubric for MCP-shaped memory.
• The GraphRAG tax: build, query, and latency costs of graph memory.
• Evaluating agent memory: why benchmark numbers need caveats.
• LLM-as-judge patterns: judge leniency and the Maximem gap.
• Knowledge graph memory for agents: the graph-memory substrate.
• Navigating knowledge graphs: traversal policy once the graph pays.
• AI agent memory: the category hub.
• How Mnemoverse compares: head-to-head pages vs Mem0, Zep, Cognee, Letta, Supermemory, and LangMem, plus a fair roundup and the market map.
• Awesome Agent Memory: open CC0 index of the category: managed APIs, open-source engines, MCP memory servers, benchmarks, and papers. Contributions welcome.
• Best AI agent memory in 2026: the sales-side version of this comparison, where we name a fair strength for each system and say where we fit.

Edward Izgorodin · Mnemoverse · last updated 2026-09-28

Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Docs: Getting Started