Every new chat with my coding agent started the same way. Ten minutes of me typing some version of "this is a Next.js app, the API lives here, we decided against Redis in March, please stop suggesting it." The agent would nod politely, help me for an hour, and forget everything by the next session. I tried rules files. I tried pasting a hand-written context doc into each conversation. I got tired of being my own retrieval system.
So in early October I sat down and did what any reasonable person does instead of finishing actual work: I audited the memory layer market. GitHub API for stars, official pricing pages for money, READMEs for claims. Eight serious options. All numbers below are as of October 2026.
I should mention my conflict of interest up front. The comparison annoyed me enough that I ended up building my own server, MaxGraph, and it is one of the eight rows in the table. I will try to be fair to the other seven anyway. You can judge whether I managed.
The field, on one screen
| Tool | GitHub stars | UI | Self-hosted | Entry price | Writes memory on its own |
|---|---|---|---|---|---|
| mem0 | 66,894 | Yes, dashboard in the OSS server and in Cloud | Yes (Docker) | $0, then $19/mo | Yes (LLM extraction, Dream consolidation) |
| Zep / Graphiti | 4,953 / 31,591 | Zep console has graph viz; Graphiti has none | Graphiti only (needs Neo4j or FalkorDB); Zep server is closed | Free 10k credits/mo, Flex $125/mo | Yes (extraction from episodes) |
| Letta (MemGPT) | 25,091 | Yes, web app and CLI | Yes (OSS server) | $0, Pro $20/mo | Yes (sleep-time agents rewrite memory in the background) |
| Basic Memory | 4,123 | Your editor or Obsidian; no own graph UI | Yes, local-first | $0, Cloud $15/seat/mo | Partially (LLM writes notes during the chat) |
| supermemory | 31,172 | Yes, console plus a consumer app | Yes (OSS); paid self-host on the $399/mo Scale plan | $0, Pro $19/mo | Yes ("agents learn from it in real time") |
| Official MCP memory server | 91,088 for the whole monorepo | No | Yes (npx, one JSONL file) | Free | No (the agent calls tools if the system prompt tells it to) |
| mcp-memory-service | 2,006 | Yes, 8-tab dashboard plus interactive D3 and 3D graphs | Yes (SQLite, Hybrid, Milvus) | Free, donations | Yes (autonomous consolidation, insight cards) |
| MaxGraph (mine) | 2 | Yes, live physics map of the whole graph | Yes, that is the only mode | 7-day trial, then a few dollars a month | Yes |
A few honest notes on reading this table. The official MCP server's 91k stars belong to the entire modelcontextprotocol/servers monorepo, not to the memory package alone. Zep's 4,953-star repo holds examples and integrations now; the actual server went closed, and the open source path is Graphiti. And yes, the last row really says 2 stars. The repo is one week old. More on that later.
What turned out to be a commodity
I expected the comparison to reveal clear winners. Instead it revealed that the core of the idea got standardized while I was not looking.
The knowledge graph data model, entities with observations and relations, is literally the schema of the official MCP reference server. mem0, Graphiti, cognee, Hindsight, and mcp-memory-service all store some flavor of the same triple. When I designed MaxGraph's storage I thought I was making a choice. I was following a convention that had already hardened.
The observer pattern is also everywhere. Almost every serious tool now has an LLM pass that reads your conversation and writes structured memory without being asked: mem0 calls it single-pass extraction plus Dream consolidation, Letta runs sleep-time agents that rewrite core memory while the main agent idles, Zep has Observations on its Flex Plus tier, and even the free mcp-memory-service does autonomous consolidation with insight cards. The romantic idea of an agent that "remembers on its own" shipped in at least seven products before mine.
Semantic search and MCP support come with literally every tool on the list, and Docker self-host too, except for the Zep server itself. A dashboard of some kind: mem0, Zep, Letta, supermemory, cognee, Hindsight, mcp-memory-service. I kept a tally while researching, and by the end my list of "things that make MaxGraph special" had lost most of its rows to the commodity column.
That was the useful part of the exercise. It killed my lazy differentiation story and forced me to ask what is actually left.
What I could not find anywhere
Three gaps survived the audit. (This is the part where I am obviously biased, so I will describe them as facts about the market and let you weigh them.)
First, tasks and bugs as first-class citizens of the memory graph. Every tool I checked stores facts about the world: user preferences, entities, episodes, decisions. None of the eighteen repos I looked at models work state. In MaxGraph a task is a node in the same graph as everything else, with an open or done status, and a bug is a node with open or fixed. The agent can ask "what is still open on this project" at session start and get an answer from the same store that holds the architecture decisions. I wanted this because my worst agent failure mode is forgotten TODOs that rot in a chat log, worse than any forgotten fact. Nobody sells that. If you know a counterexample, I genuinely want the link.
Second, a live map. Several tools visualize the graph: Zep's console, mcp-memory-service with its D3 and 3D views, cognee's graph rendering. Those are static or lightly interactive pictures. MaxGraph's dashboard is a physics simulation where the memory graph floats, clusters, and can be dragged around. I will admit this is partly for the founder's own pleasure. Watching yesterday's session collapse into the project cluster is the closest thing I have to a save file for my own thinking. But it also changed how I debug the memory itself; I can see when an entity is over-connected and polluting retrieval.
Third, the business model. Self-hosted memory is free almost everywhere (mem0, Graphiti, Letta, cognee, Hindsight, mcp-memory-service, supermemory's OSS app) or locked behind enterprise contracts (Zep BYOC, mem0 on-prem, cognee BYOC). The one public self-serve plan that includes self-hosting is supermemory's Scale at $399 a month. Nobody I found sells a self-hosted memory server to an individual developer for the price of a coffee. MaxGraph is that experiment: a 7-day trial, then a micro-subscription of a few dollars a month, for software that runs on your machine, stores plain local text files, and works offline. Whether anyone will pay for self-hosted software in 2026 is an open question I am funding personally.
There is also a licensing choice worth one sentence: MaxGraph is BSL-1.1, source available, and every version converts to MIT four years after release. If I abandon the project or get hit by a bus, the code becomes fully open on a timer.
Where MaxGraph is honestly weaker
I promised fairness, so here is the part my marketing brain wanted to skip.
There are no benchmarks for MaxGraph. mem0 publishes LoCoMo 92.5 and LongMemEval 94.4 (April 2026 numbers, measured on their managed platform, with the caveat that OSS is "directionally similar"). Hindsight has a public benchmarks site and a paper. MaxGraph has a claim of roughly 43% context-token savings from my own session-start measurements, taken on my own projects, by me. Treat it accordingly.
There is no hosted cloud. If you want to paste an API key and never run a Docker container, MaxGraph is the wrong tool and mem0, Zep, or supermemory will serve you better today. My bet is that developers who care about memory care about where the memory lives, but it is a bet, not a fact.
I have no enterprise paperwork either. Zep has SOC 2 Type II and HIPAA, Vectorize (behind Hindsight) has SOC 2, supermemory puts SOC 2 on its Scale tier. MaxGraph has a founder and a GitHub repo.
The project has two stars and is one week old. The README is better than the documentation, the documentation is thinner than the vision, and there are sharp edges I have not found yet because only a handful of people have run it. mcp-memory-service, at 2,006 stars with a very active solo maintainer, is the mature version of the "local MCP memory with a dashboard" idea, and if my feature list speaks to you, you should try it too. Seriously. Competition here is good for everyone, including me, because it means the category is real.
Why I am publishing the audit anyway
The comparison was supposed to save me from building something redundant. It did the opposite: it showed me that the commodity layer (graph, observer, MCP, dashboard) is table stakes now, and that the interesting fights are happening at the edges. Work state in the graph. Memory you can see move. Pricing aimed at one developer's wallet instead of a procurement department.
If you want to check my work, everything above traces back to public repos and pricing pages. If you want to check the product, MaxGraph is at github.com/RuMemory/maxgraph, with a 7-day trial and more details on rezon-ai.ru (there is an English version of the site). Star the repo if it turns out useful; at my current count of 2, you would be moving the chart.
And if you have already solved the "agent forgets the project between sessions" problem with one of the seven other tools, tell me which one and why. I have a graph to update.
Top comments (0)