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.
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 local runtime and App Server, Cognee's core, Graphiti, and Supermemory's local binary. Mnemoverse cannot, and that is named here as our own weakness rather than 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 three signals at read time. Its own search documentation exposes them in score_details: "the semantic score, normalized BM25 score, entity boost". Time is not one of them; the docs describe Temporal Reasoning separately, as something "time-aware queries use... internally" on Platform v3 rather than a component of the retrieval score. An earlier version of this article counted it as a fourth fused signal, which overstated what the vendor documents. 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 MCP server lists "Group management for organizing related data" among its features, which is the closest thing to a named mechanism, and the README goes no further about multi-user or multi-agent isolation. An earlier version of this article quoted "Build your own" here; that cell is real but answers a different row of Graphiti's comparison table, "User & conversation management", where Zep has built-in users, threads and message storage and Graphiti does not (README).
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 local runtime and self-hosted App Server, Cognee's core, Graphiti, and Supermemory's local binary are all real, working, no-cloud paths. Letta documents two shapes, a CLI that "runs agents in-process" and an App Server for a central machine, with an official letta/letta image, Docker Compose, Railway and Fly.io among the deployment options, and states that "no Letta account is required". 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 things worth naming plainly. Letta does put a number on its free tier, and an earlier version of this article said it did not. 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's pricing page, re-read on 2026-09-03, listed all plugins ("Claude, Cursor, OpenClaw, Hermes, Grok bot & more") and "Supermemory MCP" inside the Free ($0/mo) plan itself. An earlier read of its billing feature-gate table had marked those plugins unavailable on Free; that reading did not survive the re-check against the live page, so the contradiction this paragraph used to report was ours, not theirs. Re-read once more on 2026-09-11, the page has moved again: the line "All plugins: Claude Code, Cursor, Hermes and more" now sits in the Pro plan at $19 a month, the Free plan lists five dollars of monthly credits, "Full search and memory API", "1 team seat, unlimited end users" and "Email support" with no plugin or MCP line at all, and the Max plan at $100 a month repeats "Plugins and priority support". So the plugins are a paid feature as of that date. The 2026-09-03 sentence stays because it was true of the page on that day; it is not true of the page today.
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 boost; temporal reasoning is separate (Platform v3) | 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.
Related
- Best AI agent memory in 2026: our own roundup of the same field, written to sell, so read it against this page rather than instead of it