Title

Eight AI Coding Agent Memory Layers Reviewed—So the Author Built a Ninth

Meta Description

A developer audited eight AI coding agent memory layers including mem0, Zep, and Letta, comparing stars, self-hosting, pricing, and autonomous write capability—then openly discusses the shortcomings of his own ninth product, MaxGraph, and three market gaps: task state in the graph, real-time graph visualization, and a personal self-hosted subscription.

Article Content

Eight AI Coding Agent Memory Layers Reviewed—So the Author Built a Ninth

Every time I start a new conversation with a coding agent, it's like rebooting with amnesia: I have to spend ten minutes repeating "this is a Next.js app, the API is here, in March we decided not to use Redis, stop suggesting it." The agent nods politely, helps for an hour, and forgets everything by the next session. I tried rules files. I tried hand-written context docs. I got tired of being my own retrieval system.

So this October I stopped doing real work and audited the memory layer market: GitHub API for stars, official pricing pages for prices, READMEs for feature claims—eight serious options in total, data as of October 2026. A conflict-of-interest disclosure up front: this comparison annoyed me so much that I went ahead and wrote my own server-side MaxGraph, and it's in the eight-row table too. I'll try to be fair to the other seven; you be the judge.

The battlefield at a glance

Tool	GitHub Stars	UI	Self-hosting	Starting price	Autonomous memory writes
mem0	66,894	Yes, dashboards for both OSS server and Cloud	Yes (Docker)	$0, then $19/mo	Yes (LLM extraction, Dream consolidation)
Zep / Graphiti	4,953 / 31,591	Zep console has graph visualization; Graphiti none	Graphiti only (needs Neo4j or FalkorDB); Zep server closed-source	Free 10k credits/mo, Flex $125/mo	Yes (extracted 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 native graph UI	Yes, local-first	$0, Cloud $15/seat/mo	Partial (LLM writes notes during conversation)
supermemory	31,172	Yes, console plus consumer app	Yes (OSS); paid self-hosting at $399/mo Scale tier	$0, Pro $19/mo	Yes ("agents learn from it in real time")
Official MCP memory server	91,088 for the whole monorepo	None	Yes (npx, single JSONL file)	Free	No (agent only calls the tool when the system prompt tells it to)
mcp-memory-service	2,006	Yes, 8-tab dashboard with interactive D3 and 3D graph	Yes (SQLite, Hybrid, Milvus)	Free, donations accepted	Yes (autonomous consolidation, insight cards)
MaxGraph (mine)	2	Yes, real-time physics map of the full graph	Yes, and it's the only mode	7-day trial, then a few dollars a month	Yes

A few honest annotations are needed to read the table. The official MCP server's 91k stars belong to the entire modelcontextprotocol/servers monorepo, not the memory package alone. The Zep repo with 4,953 stars now holds examples and integrations; the real server is closed-source, and the open-source path is Graphiti. The last row really does have only 2 stars—the repo is a week old. More on that later.

MCP (Model Context Protocol) is an open protocol proposed and open-sourced by Anthropic in late 2024, designed to provide a standardized way for AI models to connect with external data sources and tools. It uses a client-server architecture: an AI application acts as the client and calls resources, prompt templates, and tools exposed by various MCP servers through a unified JSON-RPC interface. The official modelcontextprotocol/servers repo collects a set of reference implementations for file systems, databases, Git, and more—including a memory server that stores entities, observations, and relations in a single JSONL file. Because the protocol is open and simple to implement, MCP quickly became the common foundation for coding agents to access memory, retrieval, and external tools—the technical backdrop for this article's observation that "MCP support is table stakes for every tool."

What has already become commodity

I expected the comparison to reveal a clear winner, but instead I found that the core ideas had long since been standardized.

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 variants of the same triple. When I designed MaxGraph's storage I thought I was making a choice; in fact I was following an already-frozen convention.

The observer pattern is equally ubiquitous. Nearly every serious tool now has an LLM pass that reads conversations and proactively writes structured memory: mem0 calls it single-pass extraction plus Dream consolidation, Letta runs sleep-time agents that rewrite core memory while the main agent is idle, Zep offers Observations on the Flex Plus tier, and even the free mcp-memory-service does autonomous consolidation and insight cards. The romantic idea that "the agent remembers on its own" had shipped in at least seven products before mine.

Semantic search and MCP support are standard on every tool on the list, and so is Docker self-hosting (except the Zep server) and dashboards. I kept a count as I researched, and by the end the commodity column had stolen most of my "what makes MaxGraph special" list.

That was the most useful part of this exercise: it killed my lazy differentiation story and forced me to ask what's left.

Observer pattern here doesn't refer to the classic object-oriented design pattern, but to a write architecture in memory systems: an independent LLM pass reads raw conversations or episodes, proactively extracts, summarizes, and writes structured memory, thereby removing "what to remember" from the main agent's reasoning loop. The advantage is that memory writes don't consume the main task's context or latency and can be batch-consolidated, deduplicated, and reconciled; the cost is that extraction quality depends heavily on prompts and models, and it may write inferences the main agent never endorsed. mem0's single-pass extraction plus Dream consolidation, Letta's sleep-time agents, and Zep's Observations are all variants of this idea, differing mainly in trigger timing (post-session, idle, or scheduled) and whether background rewriting of existing memories is allowed.

Three things the market doesn't have

Three gaps survived. (I'm obviously biased here; I'll state market facts and let you weigh them.)

Tasks and bugs as first-class citizens of the memory graph. Every tool I looked at stores facts about the world: user preferences, entities, episodes, decisions. None of the eighteen repos I examined models "work state." In MaxGraph, tasks are nodes on the same graph with open/done status; bugs are nodes with open/fixed. The agent can ask at the start of a session "what's left unfinished in this project" and get an answer from the same store that holds architecture decisions. I did this because my worst agent failure mode is forgotten TODOs rotting in chat logs—worse than forgetting any fact. Nobody sells this. If you know a counterexample, I really want the link.

A living map. Several tools can visualize the graph: the Zep console, mcp-memory-service's D3 and 3D views, cognee's graph rendering. But those are static or lightly interactive images. MaxGraph's dashboard is a physics simulation—the memory graph floats, clusters, and can be dragged. I admit there's founder self-indulgence here—watching yesterday's session collapse into a project cluster is the closest I've come to "save states for my own thinking." But it also changed how I debug memory itself: I can see when an entity is over-connected and polluting retrieval.

The business model. Self-hosted memory is almost always free (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 only public self-serve tier that includes self-hosting is supermemory's Scale at $399/mo. I found nobody selling a self-hosted memory server to individual developers for the price of a cup of coffee. MaxGraph is that experiment: a 7-day trial, then a micro-subscription of a few dollars a month, software running on your machine, stored in plain local text files, works offline. Whether anyone in 2026 will pay for self-hosted software is the open question I'm personally funding.

One more thing worth mentioning: licensing. MaxGraph uses BSL-1.1—source-visible, with each version converting to MIT four years after release. If I abandon the project or get hit by a bus, the code goes fully open source on a timer.

BSL-1.1 (Business Source License 1.1) is a "source-available" rather than traditional open-source license, introduced by MariaDB. It allows anyone to view, modify, and redistribute the code but restricts using it in production environments that commercially compete with the software; the license must also specify a "change date" (typically several years after each version's release) and a change license, after which that version automatically becomes fully open source (MaxGraph chose MIT). This arrangement lets independent developers preserve commercialization space early on while promising the community that the code won't stay closed forever. Note that BSL software is generally not considered OSI-approved open source, and enterprises typically need legal review of the exact wording of its "competing use" clause before adopting it.

Where MaxGraph is genuinely weaker

I promised fairness, so here's the part my marketing brain wants to skip.

MaxGraph has no benchmarks. mem0 publishes LoCoMo 92.5 and LongMemEval 94.4 (April 2026 numbers, measured on its hosted platform, with a note that OSS is "directionally similar"). Hindsight has a public benchmark site and a paper. MaxGraph has only my own ~43% context token savings measured on my own projects—measured by me, so discount accordingly.

No managed cloud. If you want to paste an API key and never touch a Docker container, MaxGraph is the wrong tool; mem0, Zep, or supermemory serve you better today. My bet is that developers who care about memory also care where memory lives, but that's a bet, not a fact.

No enterprise compliance materials. Zep has SOC 2 Type II and HIPAA, Vectorize behind Hindsight has SOC 2, supermemory offers SOC 2 on the Scale tier. MaxGraph has one founder and one GitHub repo.

The project is 2 stars and one week old. The README is better than the docs, the docs are thinner than the vision, and there are rough edges I haven't found because the number of people who've run it fits on one hand. mcp-memory-service, with 2,006 stars and a very active independent maintainer, is the mature version of the "local MCP memory with a dashboard" idea; if my feature list appeals 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'm publishing the audit anyway

This comparison was supposed to stop me from building something redundant. Instead it did the opposite: it showed me that the commodity layer (graphs, observers, MCP, dashboards) is now just the price of admission, and the interesting fights are at the edges—work state in the graph, memory you can see move, pricing aimed at one developer's wallet rather than a procurement department.

To check my work, every row above traces back to public repos and pricing pages. To check the product, MaxGraph is at github.com/RuMemory/maxgraph, 7-day trial, details at rezon-ai.ru (English version available). Star it if it's useful; at my current count of 2, you'll make the chart move.

If you've already solved "agents forget between sessions" with one of the other seven, tell me which and why. I have a chart to update.

One-line Summary

The author reviews eight AI coding agent memory layers, finds the core capabilities have become standard, and builds MaxGraph to bet on work-state modeling and personal subscriptions.

Paragraph Summary

Frustrated by coding agents forgetting across sessions, the author audited eight memory layer tools in October 2026 and built a comparison table across stars, pricing, self-hosting, and autonomous memory writes. The conclusion: knowledge-graph models, LLM observer extraction, semantic search, MCP support, and Docker self-hosting are now industry standard, leaving little room for differentiation. Three market gaps survive: tasks and bugs as first-class memory graph nodes, interactive real-time graph visualization, and a self-hosted micro-subscription for individual developers. The author builds MaxGraph on this basis and candidly admits its weaknesses—no public benchmarks, no managed cloud, no compliance certifications, only 2 stars and a week old—recommending mature users consider alternatives like mcp-memory-service first.