Claude Code Cursor Antigravity OpenClaw
The session ends.
Your decisions stay.
Your coding agent is brilliant for two hours. Then the context fills up. You open a new conversation, and it goes exploring your repository again: grep, whole files read, thousands of tokens before its first useful answer. Run three at once and each one repeats the trip, and none of them knows what the other two decided.
Mnemosyne OS keeps what a session understood. You declare a memory vault on your project folder, and the next session reads it back locally, over an open MCP server. It starts where the last one stopped.
We built it because we hit the wall first, every day, making this product with these agents.
Your IDE Claude Code · Cursor · Antigravity 
The MCP server on your machine, on loopback 
App running your vaults, the to-do, the calendar, your session card 
Without the app your sessions, the files they wrote, the collisions The bill
Five costs that appear on no invoice.
They all come from the same hole: the work of a session has nowhere to live once the session is finished.
The conversation you start over
Exploration restarts from zero with every new conversation. You pay that part before you have even asked your question.
The decision you make twice
A feature takes dozens of decisions. A fresh agent reopens them all, and settles some of them the other way.
The trap you already paid for
A bug that took you an afternoon to understand comes back three months later. You pay the afternoon again.
The work that leaves the repository
“Add this migration to my todos.” The agent understands the sentence. It has nowhere to write it.
Agents that know nothing about each other
The session in your terminal ignores what the one in your editor did. Both write to the same files.
The ecosystem
MCP servers do their job very well.
There are hundreds of them. Each one plugs your agent into a precise tool and does it well: a repository, a ticket, a database, a browser, a terminal. We use them every day.
They all give your agent hands. None of them gives it a whole memory. It divides in two:
The one your agents write
What a session understood, settled, got wrong. Today that lives in a transcript nobody reopens, and the next session starts from zero.
The one you govern
Your vaults, your architecture decisions, the traps you paid for. You decide what goes in, what mixes and what goes out. Your agent reads and writes there, under your rule.
An agent writing into the void teaches nobody. And if your agent cannot read your notebook, you copy it by hand into every prompt.
The two parts meet in the same process
Everything runs on your machine. Your editor starts an MCP server that
talks on loopback, on 127.0.0.1:7799. Nothing leaves. When
the app is open, the app answers: your agent reads the vaults you have
in front of you, with no copy and no sync.
The wiring goes both ways. The agent reads what the app knows. The app shows what the agent does. A session card lands on your board: its state, its duration, the files it wrote. You can answer it without cutting what it is doing.
The app is the server. Close it, and the memory, the to-do, the calendar and the session card have nobody left to talk to. They tell you so.
The size of the problem
What a memory has to hold.
First commit on 17 April 2026. Run the same commands on your own repository to learn the size of yours.
4,979
commits on main
git rev-list --count HEAD
2,131
of them in the last 30 days
git log --since="30 days ago" --oneline | wc -l
800,222
lines of TypeScript, 44 apps
287,340 in the main product
127
architecture documents
ls docs/architecture/*.md | wc -l
475
memory notes
find memory -name "*.md" | wc -l
Taken on · git commands, line and file counts, on this repository.
None of these numbers proves we work well. A commit can be tiny, a line can be bad, and part of it was written by agents. These numbers measure the quantity of decisions that exist somewhere, and that will have to be found again.
AI kept its promise: we go faster. It kept a second one nobody talks about: quantity.
We open work we would have dropped before starting, and we keep several surfaces going at once. On this repository, that gives the 2,131 commits of the last thirty days.
This second promise depends on the architecture. The same pace leads to two opposite places.
Architecture thought through
Quantity becomes product. Every piece of work builds on what already exists.
Architecture absent
Quantity becomes debt. And debt arrives at the same speed as the rest.
And the more we produce, the more we decide. Every piece of work adds its trade-offs, its traps and its reasons.
We are in the same boat as the models. They will get far more capable, and they will not swallow a whole project's context for years. The corpus grows faster than the window, and it does not survive the session.
So it takes an efficient MCP server: keep the context outside, and give back the right piece at the right moment.
From the agent's side
How an agent works here.
Three numbers, in the order they arrive.
1. It opens the session
≈ 50,000 tokens
It loads the conventions file, the memory index and the work in progress. It is a map of the project. The content stays outside.
2. What the map opens
≈ 12,000,000 tokens
127 architecture documents, 475 notes and 800,222 lines of code, indexed on your machine. It knows they exist and where they are.
3. It asks a question over MCP
≈ 1,100 tokens
It gets the answer and the files it comes from. That is the price of one round trip, and it can make several.
Tokens estimated from counted bytes, never tokenised · taken on .
The five costs from the top of the page, one by one.
| The situation | Without memory | With Mnemosyne OS |
|---|---|---|
| Opening a new session | The agent explores the repository: grep, whole files read. The bill climbs before the first answer. | The agent loads a map of ≈ 50,000 tokens, then asks for what it is missing. |
| Finding a decision from three weeks ago | You find it from memory, or it gets settled the other way. | The agent finds it for ≈ 1,100 tokens, with the file it comes from. |
| A trap you already paid for once | Nobody wrote it anywhere but in a closed conversation, so it comes back. | It is written and dated, and the agent reads it before touching the same area. |
| A task dictated mid conversation | It stays in the chat log. | It lands in your list or your calendar, in a file that belongs to you. |
| Two agents on the same branch | They find out at merge time. | A collision check warns you before you commit. |
The two numbers in the right column are the ones from the ladder above.
An agent carries less than 0.5% of this project in its window and reaches any fact in the rest for about a thousand tokens. Even a one million token window would hold only a twelfth of it.
Retrieval gives back the passages and names the file each one comes from. You check a claim against the note.
A chat sends its history back every turn, so the longer the conversation, the more the next answer costs. A question asked of the memory costs the same on the first turn and on the hundredth.
The shape
Your editor acts. Mnemosyne OS remembers. You decide.
Three different jobs. Today the middle one is missing. Your agent is very good at changing files. It has nowhere to put what it learned doing it.
The editor writes the code.
Mnemosyne OS holds the vaults, the links and the history.
You arbitrate, because you are the only one who knows what it is for.
The agent reads the memory, and it repairs it. Last week a benchmark pass left orphan rows in a lexical index. The agent saw them, fixed them, and wrote down why they had appeared.
Sessions also talk to each other. You write on a session's card without
interrupting it, and it reads the message at its next update. Wire the
mnemosyne-cockpit-hook that ships with the MCP server and a
session about to stop reads its mail before leaving, so two sessions warn
each other through that channel about what they are touching.
Get started
Plugging in Claude Code, Cursor or Antigravity.
Claude Code
Over MCP. With Ariadne, Mnemosyne OS also reads the transcripts it already writes on your disk.
Cursor
Over MCP, and over the dedicated bridge it shares with VS Code.
Antigravity
Over MCP, and Ariadne reads its transcripts like Claude Code's.
OpenClaw
Its sessions live in SQLite. You export a trajectory, Mnemosyne OS reads it.
Any MCP client
The same file is enough. What MCP is, and the tools it exposes.
Two steps to plug your agent in. Only the first one needs a download.
Télécharger Mnemosyne OS The code on GitHub
Then add the server to your project's .mcp.json:
{ "mcpServers": { "mnemosyne": {
"command": "npx",
"args": ["-y", "@mnemosyne_os/mcp"],
"env": {
"MNEMO_DEFAULT_VAULT": "DEV",
"MNEMO_VAULTS": "DEV,PERSONAL,SOCIAL",
"CLAUDE_CODE_SESSION_ID": "${CLAUDE_CODE_SESSION_ID}"
}
} } }Point a vault at your project folder. Your agent can now read what you decided, and write what it decided. Everything stays on disk, in files you can open without us.
Declaring your IDE, and keeping the wheel
Your IDE already writes transcripts on your disk. For Mnemosyne OS to read them, you install the Ariadne cartridge and you point it at the folder. You say where to read, once.
Three tools read files, so they answer with nothing installed: the list of your agent sessions, the files they wrote, and the collision check. The rest needs the app running. The question to the memory is one of them, along with the session cards you write on to an agent at work.
Ariadne is in beta and is added by hand from its repository.
The flaw you should know about
An agent plugged into the MCP server does not query the memory on its own. It has the tools, nobody told it to use them first. So it does what it has always done: it greps, it reads whole files, and it pays for the exploration you had just avoided.
The instruction fits in three lines, in your project rules
(CLAUDE.md, .cursorrules, whatever you use):
Before searching the code, ask the memory:
mnemosyne_memory_ask on the project vault.
A grep costs thousands of tokens, a question costs a thousand.On this repository, we put it at the top of the conventions file. The agent loads it with its 50,000 tokens of opening.
If you build on top of Mnemosyne OS rather than beside it, the dev surfaces page points you at the right package in two lines.
Try it on your own project.
Ask your agent about a decision you made last month. This test takes ten minutes.
And if something breaks, or works better than expected, we are on the Discord.
Leave your email if you want what comes next: what works, what breaks, and the figures that move.