Every new session with my coding agent used to start the same way: me typing some version of "this is what the project does, the API lives here, we decided against that library in March," while the agent nodded politely and forgot all of it by the next morning. In my last post I compared eight memory layers for AI coding agents and confessed that I ended up building a ninth (the comparison post is here). This one is the practical follow-up: how to give your agent a persistent memory in about five minutes, using MaxGraph, the memory server I maintain. It works with Claude Code, Cursor, VS Code, and anything else that speaks MCP.
Quick disclosure, since this is dev.to and not my landing page: I sell this thing. There is a 7-day trial that needs no card, so you can verify everything below before paying anything.
MaxGraph is a local MCP server that gives your agent a knowledge graph. The graph stores entities (projects, files, services, people), observations (atomic facts attached to those entities), and relations between them. On top of that storage you get semantic search, a context digest at the start of every session, tasks and bugs with their own statuses, and a live dashboard that renders the whole graph as a physics simulation you can drag around with a mouse. Everything lives in plain text files on your machine, inside the data/ folder of the install. It works offline. If you ever want to leave, there is an NDJSON export.
Three ways, in decreasing order of elegance.
Path one: make the agent install it. My favorite, because it needs no terminal work from you at all. Paste this into your coding agent:
Install MaxGraph: https://github.com/RuMemory/maxgraph. Follow AGENTS.md and do it all yourself.
The repo ships an AGENTS.md written for exactly this situation. The agent reads it, picks the right installer for your OS, wires up the MCP config, and reports back. Watching an agent install its own memory is also a decent preview of the relationship you are about to have with it.
Path two: the Claude Code plugin. Two commands:
claude plugin marketplace add RuMemory/maxgraph
claude plugin install maxgraph@maxgraph
Path three: manual. Clone the repo and run the installer for your platform.
On Windows:
git clone https://github.com/RuMemory/maxgraph
cd maxgraph
powershell -NoProfile -ExecutionPolicy Bypass -File .\install.ps1 -Yes
On Linux or macOS:
git clone https://github.com/RuMemory/maxgraph
cd maxgraph
bash install.sh --yes
If you are on Cursor or VS Code, the README in the repo has one-click deeplinks that register the MCP server for you, and docs/PAIRING.md walks through the pairing flow. I am not pasting those links here because they are long base64 blobs. Open the README and click.
The installer drops an icon into your system tray, registers itself for autostart, and turns on auto-updates. From that point on, the server is just there, the way a database is just there.
The first session after install feels ordinary. You work as usual. The difference is that the agent now writes things down as it goes: a decision you made together, a bug you hit, a summary when the session ends. You do not have to ask for this; the write instructions ship with the server. You can still say "remember this" when you want something specific captured, and I do that more often than I expected.
The second session is where you feel it. At session start the agent asks for its context digest and gets a budgeted block: the key facts about your project, the decisions on record, the open bugs, the open tasks, and a recap of recent sessions. The "we decided against that library in March" conversation stops happening, because the agent read the March decision before you finished your coffee.
The dashboard is the part I built partly for my own pleasure. It renders the whole memory graph as a live physics map: entities float, cluster by project, and you can drag nodes around to see what connects to what. It turned out useful beyond the aesthetics. An over-connected entity is visible at a glance, and an over-connected entity usually means it is polluting retrieval.
One number, clearly labeled as my own measurement: across my projects I see roughly 43% savings on context tokens, because the session digest replaces the "paste the whole context doc again" habit. I measured this on my own sessions, by myself, for myself. Treat it accordingly.
Three honest limits, so nobody buys the wrong thing.
There is no hosted version. The server runs on your machine and the memory never leaves it, which is the entire point, but it also means there is no API key to paste and no cloud console to log into.
It is not magic. The agent has to actually write things down for memory to exist, and it writes what it judges durable. That judgment is good but imperfect, and the safety net is that you stay in control: the storage is plain text files you can read, edit, or delete with any editor, and the export is NDJSON. Your agent's memory is yours in the most literal sense.
And it will not organize the project for you. It remembers what happened. Deciding what should happen next is still your job.
The repo is at github.com/RuMemory/maxgraph. The trial is 7 days, no card required, which should cover at least a dozen "wait, how did you know that" moments from your agent. More details live on rezon-ai.ru, English version included.
If it turns out useful, star the repo. If you hit a sharp edge, open an issue. The project is young, and every report lands in the same graph my own agent reads the next morning, which is the most literal dogfooding loop I have ever run.