How Auric works
Auric gives a project its own persistent intelligence: a durable record of what the project is, what has happened to it, and where the work stands. It runs as a local MCP server and a CLI. Every session and every agent reads that record before starting, and writes back to it as the work moves.
1. The project gets a record of its own
Today a project's understanding is scattered across the people and tools that happened to touch it. The decisions are in conversations, the reasoning is in someone's head, and the code says what changed without ever saying why.
Auric moves that understanding onto the project. The record holds what the project is trying to do, the decisions taken and the reasons behind them, what has been ruled out, what is still open, and what comes next. It is not a transcript archive and not perfect recall — the test for anything is whether you would have to reconstruct it before you could continue.
2. You and your agents write to it
Nothing observes your editor, your repository or your conversations, and nothing runs on its own. Auric only ever sees what you or your agent hand it, by calling one of its tools: one reads the project's current state, one records what changed, one tracks something still open.
Ending a session is the one place a model is involved on the write side — it reads what it was handed and drafts the summary that becomes state, and you choose when that runs. It never reads anything you did not pass it, and never on its own schedule.
3. The next session starts from it
A restore is data assembly. There is no model in the read path at all: the same file in produces the same context out. The next session — yours, a week later, in a different tool — opens with the project's current state rather than with an empty context window.
That is the difference between this and a memory feature inside one tool. Memory answers what was said, inside the product that heard it. Auric maintains what the project understands about itself, and every surface reads the same record.
What the design guarantees
- Local-firstThe record is a single file on your machine, and `auric export` writes you a consistent copy of it. Delete it and Auric is gone. Offline by default.
- You write itState is what you or your agent record through Auric's tools. Nothing runs on its own, and nothing reads your repository.
- No AI in the read pathRestores are deterministic data assembly. Same file in, same state out.
- Append-onlyNothing is edited away. A decision is superseded rather than overwritten, with the when and the why kept on the record.
Where it runs
Auric is a Model Context Protocol server and a command-line tool. It is not a hosted service you send your project to, and it is not an editor plugin.
- Claude CodeYour agent reads the project's state before it starts work.
- Any MCP clientThe same record, through the same protocol, wherever you work.
- Auric CLIauric init · auric config · auric doctor
Pick the agent for the job, the model for the reasoning, the tool for the action. They are capabilities. The project is the constant.
What ships today, and what doesn't
Today
- You come back a week later and continue from where the project stands.
- You continue in a different tool, from the same record.
- Decisions carry the reason they were made, and the reason they changed.
Where this goes
- A teammate continues from where you stopped.
- An agent continues from the project's current state without being briefed.
Auric is in beta and the record format is still moving — keep your own backups.