Evaluating 8 Memory Layers for AI Coding Agents and Building a Ninth
- Authors
- Name
- Nino
- Occupation
- Senior Tech Editor
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.
When you scale up complex software engineering workflows using LLM APIs integrated via platforms like n1n.ai, context management becomes the ultimate bottleneck. High-speed inference and massive context windows help, but they do not replace persistent, structured memory across sessions. In early October, I decided to audit 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.
| 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) | 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) | 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 | 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 | 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.
The Commoditization of Memory Architecture
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 Model Context Protocol (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. When developing robust agent loops using endpoints provided by aggregators like n1n.ai, having standardized tool integration is crucial for avoiding vendor lock-in.
Three Structural Gaps That Survived the Audit
That was the useful part of the exercise. It killed my lazy differentiation story and forced me to ask what is actually left. Three gaps survived the audit.
- 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.
- A live physics-simulated map. Several tools visualize the graph, but MaxGraph's dashboard is a physics simulation where the memory graph floats, clusters, and can be dragged around. Watching yesterday's session collapse into the project cluster is the closest thing I have to a save file for my own thinking.
- Micro-SaaS pricing for single developers. Self-hosted memory is free almost everywhere or locked behind enterprise contracts. MaxGraph is an 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.
Benchmarks and Reality
There are no benchmarks for MaxGraph. mem0 publishes LoCoMo 92.5 and LongMemEval 94.4. 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. When routing requests through n1n.ai, optimizing your context token usage directly translates to lower latency and reduced API costs.
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. 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.
Get a free API key at n1n.ai