Best persistent memory APIs for AI agents: six questions, six systems
A persistent memory API for AI agents stores facts, decisions and preferences outside a single conversation so an agent does not start cold in a new session or a different tool. Most comparisons in this category answer with a feature list. This one asks six questions instead (the same six of every system, including our own, Mnemoverse) and reports what each vendor's own documentation actually says, not what its homepage implies.
This is the written half of a video, What are the best persistent memory APIs for AI agents?, and the sections below follow its six questions in order, so anyone arriving from the end card can pick up where they stopped.
Correction, 9 October 2026: this page said Supermemory contradicts itself about whether its coding plugins cost anything, and that its billing page and its pricing page both still gate them. The second half did not hold when it was written: the same paragraph recorded that the pricing page, read on 14 September, named no plugins at all. Supermemory corrected its docs billing table on 18 September, and read on 9 October it lists coding plugins on every plan, Free included, in line with its 15 August changelog; the paragraph now says so.
Correction, 4 October 2026: this page said Mnemoverse has no self-hosted deployment. Since 21 September its pricing page offers Enterprise customers self-hosting by agreement; the page now says so, and that no self-hostable build is published.
Correction, 13 September 2026: this page said cross-tool memory is documented for only three of the six, that only two of the six document an outcome-feedback mechanism, and that Supermemory's plugins are a paid feature. All six document a route (Letta's for Zed, JetBrains IDEs, Obsidian and OpenAI-compatible clients such as Open WebUI; Graphiti's through its own MCP server); Mem0 also takes a feedback signal, though only Cognee and Mnemoverse name the step that turns it into ranking; Supermemory's pricing page and changelog put the plugins in its free plan. The sharing section now describes Zep's standalone graphs and Supermemory's spaces instead of two retired names, the self-hosting count says Zep is covered only through Graphiti and that every path runs on a model you bring, Cognee's own stated limit is added, and several descriptions and quotes, ours included, are corrected to exactly what each page says. Earlier corrections: the Graphiti sharing cell once quoted "Build your own" from a different row of its README table, and Letta's free tier was once said to have no number. Two earlier corrections are withdrawn: Mem0's how-it-works page does count time as a fourth fused signal, and Supermemory's docs billing table does mark plugins unavailable on Free.
TL;DR
- Six systems compared on six questions: memory model, cross-client sharing, outcome feedback, multi-agent sharing, cost and self-hosting, and each vendor's notable limitation.
- The finding the comparison turns on: almost none of the six document the step that turns outcome feedback into ranking, although every one of them promises, somewhere on its own pages, that it improves itself or keeps learning. Three take a signal on how a recalled memory turned out (Mem0, Cognee, Mnemoverse), and only Cognee, whose ranking weight is opt-in, and Mnemoverse name that step. Zep is deprecating fact ratings entirely.
- Cross-tool memory (the same store reachable from Cursor, Claude Code, VS Code and so on): on the pages cited here, all six document a route, and Letta's are its own Agent Client Protocol route for Zed, JetBrains IDEs and Obsidian and an OpenAI-compatible App Server API for clients such as Open WebUI, not the editors named here.
- Five of six can be self-hosted with no vendor account, Zep only through Graphiti, on a model you bring: Mem0's OSS library, Letta's local runtime, Cognee's core, Graphiti, and Supermemory's local binary. Mnemoverse cannot: it publishes no self-hostable build, and its Enterprise self-hosting is by agreement.
- Disclosure: Mnemoverse is one of the six systems compared, built by this site's publisher. Every fact about every system, ours included, is sourced from a page that vendor published, one of them from an archived copy, and every one of the six has a real limit named on this page.
The six questions, before any vendor's name
- Memory model: in the vendor's own words, how does storage and retrieval actually work: vector similarity, a knowledge graph, something hybrid?
- Cross-client support: is using the same stored memory from different AI tools actually documented, or only inferable from "it speaks MCP"?
- Feedback or learning mechanism: does a memory's future retrieval change because it turned out to be useful or wrong, or is storage static once written?
- Multi-agent / shared memory: can several agents or team members read and write one pool, and what is the actual named mechanism?
- Free tier or self-hosting: exact numbers, and whether a genuinely free, no-account, self-hosted path exists at all.
- Notable limitation: the most surprising thing not documented, or a limitation the vendor states about itself.
Memory model: six different mechanisms
Mnemoverse uses Hebbian associations with prediction-error feedback, the same family of mechanism as classical reinforcement learning, not vector search with extra steps. A memory is still written with a semantic embedding, but what decides whether it resurfaces is an association strengthened or weakened by outcome, not distance in embedding space alone.
Mem0's own search documentation names three signals fused at read time, and its open-source search exposes them in score_details: "the semantic score, normalized BM25 score, entity boost". On its hosted Platform, dates reorder results afterwards, as a boost: "Search returns the usual memory results, reordered using the temporal boost." (docs.mem0.ai, Temporal Reasoning). Its how-it-works page counts differently, listing time as a fourth signal and stating that "Platform retrieval fuses these signals in the managed service". Its documentation calls the entity layer a graph but is explicit about the limit: "It does not assign typed, labeled relationships between entities (it won’t, for example, record a “manages” edge from one person to another); connections are inferred from co-occurrence rather than declared" (docs.mem0.ai, Graph Memory).
Letta's agent memory, MemFS, is plain Markdown files in a git repository, searched with ordinary file tools; semantic search over MemFS needs an optional mod. Its own FAQ states plainly: "MemFS does not include a semantic or vector index by default" (docs.letta.com/reference/faq).
Zep and its open-source half, Graphiti, build what they call a temporal knowledge graph: entities and facts as nodes and edges, dated when the source or a later contradiction supplies the time, retrieved through a hybrid of semantic search, BM25 keyword matching and graph traversal.
Cognee runs three stores at once (a relational database, a vector store, and an LLM-built knowledge graph) and frames itself explicitly against plain retrieval: "Classic RAG embeds text chunks and retrieves by similarity." Cognee adds a knowledge graph of entities and their relationships "on top, so recall can follow connections, not just match text" (docs.cognee.ai/getting-started/introduction).
Supermemory calls its mechanism a "custom learning model" on top of an internally built graph, distinguishing three kinds of connection between facts: one that updates what came before, one that only extends it, and one it infers without being told explicitly.
Cross-client: who documents it, and for which tools
Write something in one editor, open a different one an hour later: does it know?
Supermemory makes this claim more directly than anyone here, by name, in its own marketing: "Record something in Claude, recall it in Cursor. Your context follows you across every tool" (supermemory.ai/mcp, as archived on 2026-08-09). That address now redirects to its MCP docs, which make the same claim today: "Supermemory MCP gives every MCP-compatible assistant a shared memory layer" (supermemory.ai/docs/supermemory-mcp/mcp).
Zep's hosted product documents the same for its own client list. Mnemoverse uses the same shape architecturally: one account, every connected client pointed at the same memory behind one API key or OAuth, and Claude Code, Cursor, VS Code, Windsurf and Claude Desktop each documented in its own config shape, not one identical block.
Mem0 says its memory "persists across sessions, tools, and runs", with setup guides for Claude Code, Cursor and other coding agents (docs.mem0.ai/introduction). Cognee's API Mode connects "multiple clients to a shared knowledge graph" (docs.cognee.ai/cognee-mcp/mcp-overview). Graphiti, Zep's open-source half, has its own MCP server, documented for Claude Desktop, Cursor and VS Code with Copilot (help.getzep.com/graphiti/getting-started/mcp-server).
Letta answers this one, just not for the editors named above. Its docs connect agents out to other people's MCP servers, and never document Letta as an MCP server another tool connects into. What editors drive is the Agent Client Protocol: the docs set up Zed, JetBrains IDEs and Obsidian to reuse one agent and its memory across clients, and add that "other ACP clients use the same adapter and environment variables" (docs.letta.com/platform/acp). A self-hosted App Server also serves chat clients through an OpenAI-compatible API, "to use OpenAI-compatible clients such as Open WebUI, LibreChat, LobeChat, or the OpenAI SDKs" (docs.letta.com/platform/app-server/quickstart). Cursor, VS Code and Windsurf get no such recipe anywhere in those docs, and Claude Code appears there only in the list of agents Letta's skills are portable across.
Almost nobody here learns from being wrong
This is the finding the whole comparison turns on. Every one of these six products promises, somewhere on its own pages, that it improves itself or keeps learning. Check what actually happens when a memory turns out to be wrong, and the category gets quiet fast.
Mem0 has a Feedback endpoint. Here is how its own page describes the effect: "Over time, Mem0 continuously learns from this feedback, refining its memory generation and search capabilities for better performance" (docs.mem0.ai/platform/features/feedback-mechanism). The same page adds: "The feedback is stored in the database and used to improve the accuracy of the memories and search results." It names no mechanism for either. Compare Memory Decay, a second feature on the same product, opt-in and specified step by step: "Decay never zeroes a candidate out: at worst it scales its score by 0.3×" (docs.mem0.ai/platform/features/memory-decay). Both are Platform-only, absent from the open-source SDK.
Zep had something closer to real weighting, called Fact Rating, one upfront rule a developer wrote, and Zep scored every fact against it. As of the deprecation wave documented on Zep's own site this year: "Fact ratings are being deprecated entirely" (help.getzep.com, February 2026 deprecation wave).
Letta's docs name a positive or negative signal per agent step, and no effect of it on memory. Supermemory ranks an inferred memory low until it is approved, drops temporary facts when they expire, lets episodes decay unless significant and says preferences strengthen with repetition, but it documents nothing tied to whether a memory was actually useful when an agent retrieved it in production.
Cognee and Mnemoverse are the two that name the step from a rating to ranking. Cognee lets a session be rated after the fact and stores that rating by default, but the ranking weight is opt-in (feedback_influence defaults to 0.0). Mnemoverse's memory_feedback call updates an atom's valence, and our reference documents a read's relevance as "Final score (similarity * valence modulation)", so a memory that keeps failing loses ground without being deleted. The caveat: the call has to actually happen. It is not a background process running on a clock; if the agent never calls memory_feedback, no outcome-based update happens, which is a prompting discipline, not a guarantee.
Six different shapes of sharing
One person or one agent using memory is the easy case. Every vendor here also answers for a team, in six different shapes.
Mnemoverse calls its version Rooms: a memory space separate from any personal memory, membership checked on every request. Mem0 calls its Group Chat, and is explicit that it will not guess who said what: every write is scoped manually by the caller. Cognee treats an agent as its own permission-holding principal, distinct from the human who owns the account, and its own docs name a limit of the default embedded store: "The embedded graph store uses file-based locking and is not meant to be shared between processes or agents running at once. For concurrent access, use Neo4j or the Postgres graph store below." (docs.cognee.ai/guides/store-configurations). Zep's shared pool is a standalone graph, listed in a project-scoped graph directory. Supermemory shares through spaces: "Teammates collaborate within the spaces they are allowed to read or write." (supermemory.ai/docs/supermemory-mcp/mcp).
Graphiti, the open-source half of Zep, gives each team its own graph namespace: its docs list "Team collaboration: Allow different teams to work with their own graph spaces" (help.getzep.com/graphiti/core-concepts/graph-namespacing), and its MCP server lists "Group management for organizing related data" among its features. Its README comparison table gives Graphiti "Build your own" in the row "User & conversation management", where Zep has built-in users, threads and message storage (README).
What it costs to start, and what "free" hides
All five competitors compared here can be run self-hosted with no vendor account, Zep only through Graphiti, and the model they call is the cost: Mem0's open-source library, Letta's local runtime, Cognee's core, Graphiti, and Supermemory's local binary are all documented paths you run yourself, on a model you bring. Zep's own FAQ says "Zep Community Edition, which allows you to host Zep locally, is deprecated and no longer supported." and lists Graphiti among the alternatives. Letta documents two shapes, a local runtime whose CLI "runs agents in-process" and an App Server for a central machine, whose deployment repository "contains one Dockerfile plus ready-to-use configuration for Docker Compose, Railway, and Fly.io", and says of the local runtime that "no Letta account is required". Cognee's own docs put a Docker Quickstart card first among three setup options, marked "Recommended for most users": "Get running in minutes with a pre-built container." (docs.cognee.ai/cognee-mcp/mcp-overview).
Mnemoverse does not have that path. It publishes no self-hostable build. Its pricing page offers Enterprise customers dedicated instances Mnemoverse provides and operates, with custom data residency, and states that "Self-hosting is available by agreement when security or compliance requirements call for it". That is a contract, not a download: there is no public route to running the engine yourself without a vendor account.
Two things worth naming plainly. Letta puts a number on its free tier. Its plan card reads "$0 /month" with "Limited agents", and the same pricing page states the number in prose: "Free plans are limited to 3 stateful agents." Supermemory puts its coding plugins on every plan and bills what they use. Its changelog of August 15, 2026 says "No Supermemory plugin sits behind a paid plan any more," and names Claude Code, Cursor, Codex, OpenCode and OpenClaw as free "on any account, including the free tier." Read again on 2026-10-09, its docs billing page agrees: the feature matrix marks "Coding plugins (Claude Code, Codex, Cursor, OpenCode, OpenClaw, Hermes)" as included on every plan, and the page states that "Coding plugins are available on every plan, including Free. Their API usage still consumes your plan's credits at the applicable rates." Its pricing page ties no plugin to a plan. The changelog says the same about usage: "Usage still counts toward your plan's included credits."
The table
| memory model | cross-client | feedback | sharing | cost | |
|---|---|---|---|---|---|
| Mnemoverse | Hebbian associations + prediction-error feedback | yes, one account across 5 documented clients | yes: memory_feedback → valence, agent-called | Rooms, self-service | free tier; self-hosting only by Enterprise agreement |
| Mem0 | hybrid: vector + BM25 + entity, plus a date boost on Platform | yes, "persists across sessions, tools, and runs" | Feedback API takes a signal, no step named; Decay opt-in, step by step; Platform-only | Group Chat, manual scoping | OSS self-hosted, on a model you bring |
| Letta | MemFS: git-backed Markdown, no vector index by default | own ACP route: Zed, JetBrains IDEs, Obsidian; OpenAI-compatible API on App Server | per-step positive or negative signal, no memory effect documented | shared memory blocks, org repo | self-hosted: local runtime or App Server |
| Zep / Graphiti | temporal knowledge graph, hybrid retrieval | Zep hosted: yes; Graphiti: own MCP server, documented for Claude Desktop, Cursor, VS Code | Fact Rating, being deprecated | Zep: standalone graphs, ABAC; Graphiti: graph namespaces per team | Graphiti self-run; Zep's local edition deprecated |
| Cognee | hybrid: relational + vector + LLM-built graph | yes, named "API Mode" | yes, ranking weight opt-in | Principal/ACL system; embedded store not for concurrent agents, Neo4j or Postgres for that | fully OSS, self-hostable |
| Supermemory | proprietary learning model + typed-edge graph | yes, explicit and repeated | review of inferred memories, expiry, repetition; none tied to usefulness | spaces, read or write per space | self-hosted npx supermemory local, on a model you bring |
Where we are not the best choice
If what is needed is a memory layer you install and run yourself without a vendor agreement, this is not that, and every other system compared here documents that path, Zep's through Graphiti, its open-source half.
Sources read with full browser headers between 2026-09-01 and 2026-09-13, one Supermemory quote from an archived copy of 2026-08-09: docs.mem0.ai, docs.letta.com, help.getzep.com, github.com/getzep/graphiti, docs.cognee.ai, supermemory.ai, and Mnemoverse's own API reference, Rooms and agent-memory guide. No performance or benchmark number appears in this article, for any system, pending a completed clean benchmark run of our own.
Related
- Best AI agent memory in 2026: our own roundup of the same field.
Mnemoverse is a persistent-memory API for AI agents. Free key: console.mnemoverse.com · Plans and limits · Docs: Getting Started