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.
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 own admitted gap.
- The finding the comparison turns on: almost none of the six document a real outcome-feedback mechanism, despite near-universal "self-improving" language. Only Cognee (off by default) and Mnemoverse have one. Zep is actively removing the closest thing it had.
- Cross-tool memory (the same store reachable from Cursor, Claude Code, VS Code and so on) is real and documented for three of six: Supermemory, Zep's hosted product, and Mnemoverse. Letta's own docs never address it either way.
- Five of six can be self-hosted for genuinely nothing, no vendor account: Mem0's OSS library, Letta's Docker image, Cognee's core, Graphiti, and Supermemory's local binary. Mnemoverse cannot — named here as our own weakness, not softened.
- 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, fetched the day this article was checked, and every one of the six gets at least one real weakness named.
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 fuses four signals at read time — vector similarity, keyword match (BM25), an entity-overlap boost, and a time-based score. 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 flagship product, MemFS, stores memory as plain Markdown files in a git repository, searched the way files are searched, not embedded. 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, each carrying the window of time it was actually true, 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 — framing itself explicitly against plain retrieval: "Classic RAG embeds text chunks and retrieves by similarity. Cognee adds a knowledge graph... on top, so recall can follow connections, not just match text" (docs.cognee.ai).
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 actually proves it, who only implies it
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).
Zep's hosted product documents the same for its own client list. Mnemoverse uses the same shape architecturally: one account, one API key, every connected client — Claude Code, Cursor, VS Code, Windsurf and Claude Desktop — pointed at the identical backend and documented against the identical configuration.
Letta is the honest gap in this comparison. Its own documentation describes it as an MCP client — something that connects out to other people's tools, not a server other tools connect into. Nowhere in its docs does it state whether a memory written in one editor shows up in another. Not a documented no. Simply never addressed.
Almost nobody here learns from being wrong
This is the finding the whole comparison turns on. Every one of these six products uses language like "self-improving," "adaptive," or "intelligent" somewhere in its own marketing. Check what actually happens when a memory turns out to be wrong, and the category gets quiet fast.
Mem0 has a Feedback endpoint. Its entire documented 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) — no mechanism named. Compare that to a second feature on the same product, Memory Decay, which is exactly specified: "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 — an upfront label a developer assigned when a fact was extracted. 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 documentation names no outcome-based mechanism at all. Supermemory's does not either — its docs describe memories fading on a timer or being reinforced by repetition, but nothing tied to whether a memory was actually useful when an agent retrieved it in production.
Cognee and Mnemoverse are the two with something real. Cognee lets a session be rated after the fact and folds that rating into future ranking weights — off by default (feedback_influence defaults to 0.0). Mnemoverse's memory_feedback call updates an atom's valence, and relevance = similarity * valence_modulation at read time means a memory that keeps failing loses ground without being deleted. The honest caveat, applied here with the same standard as every vendor above: the call has to actually happen. It is not a background process running on a clock — if the connected agent never calls memory_feedback, nothing updates, 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 account, 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. Zep calls its shared graphs Groups, discoverable through a project-wide directory. Supermemory's team product, Company Brain, splits sharing into three pools depending on whether something was said to one person, inside one private channel, or to the whole organization.
Graphiti, the open-source half of Zep, answers this one differently from every other name here. Its own comparison table states it plainly: "Build your own" (github.com/getzep/graphiti).
What it costs to start, and what "free" hides
Five of the six competitors compared here can be run with no account at all, self-hosted, on a machine you control, for genuinely nothing: Mem0's open-source library, Letta's own Docker image, Cognee's core, Graphiti, and Supermemory's local binary are all real, working, no-cloud paths. Cognee's own docs card the fastest of the three options plainly: "Docker Quickstart," "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. There is no public self-hosting path. The only sentence in its own API reference that even implies a self-hosted engine exists is about a disabled endpoint's response shape, not a public onboarding guide.
Two live contradictions worth naming plainly rather than resolving. Letta publishes no numbers at all for its free tier on any page checked — only "$0/month, limited agents." Supermemory's own pages disagree with each other about whether the free tier includes IDE plugins at all: one marketing page lists them as included, its billing feature-gate table marks them unavailable on Free.
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, no self-host path |
| Mem0 | hybrid: vector + BM25 + entity + time signals | claimed via hosted MCP | Decay (precise), Feedback API (vague) — Platform-only | Group Chat, manual scoping | OSS fully free, self-hosted |
| Letta | MemFS: git-backed Markdown, no vector index by default | undocumented either way | none documented | shared memory blocks, org repo | self-hosted free, Docker |
| Zep / Graphiti | temporal knowledge graph, hybrid retrieval | Zep hosted: yes; Graphiti: undocumented | Fact Rating — being deprecated | Zep: Groups/ABAC; Graphiti: "build your own" | Graphiti fully free, self-run |
| Cognee | hybrid: relational + vector + LLM-built graph | yes, named "API Mode" | yes, off by default | Principal/ACL system | fully OSS, self-hostable |
| Supermemory | proprietary learning model + typed-edge graph | yes, explicit and repeated | none outcome-based | "Company Brain," 3 pools | self-hosted npx supermemory local |
Where we are not the best choice
Said once, directly: if what is needed is a memory layer run entirely on infrastructure nobody else touches, this is not that, and five of the six systems compared here already are.
Sources fetched 2026-09-01 with full browser headers: docs.mem0.ai, docs.letta.com, help.getzep.com, github.com/getzep/graphiti, docs.cognee.ai, supermemory.ai/docs, 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.