Give your project a superpower.
Auric gives your project its own persistent intelligence — what it is, what it's trying to achieve, what changed and why, and what needs to happen next. Every agent that works on it reads that understanding, and adds to it.
Last night
You knew exactly where you were.
What you'd decided. What you were halfway through. Why the last approach failed.
Then you stopped
Nothing was lost.
Every file saved. Every commit in place. Nothing that says why.
This morning
Every agent is capable. The project is starting from zero.
Again. And again.
So you start over
You explain your own project back to it.
The context lives in the sessions. The decisions live in the conversations. The reasoning lives in your head. Every new agent starts from none of it.
Your agents can work.
Your project can't keep up.
Every session sees a piece. Every agent sees a piece. Every tool sees a piece.
The feature is half-built. Three conversations happened. An agent changed the architecture. Someone made a decision, and you can't find where.
It's all somewhere. The project itself doesn't know.
- What happened?
- Why?
- What's still open?
You've been giving the agents context.
What if you gave the project its own?
Auric gives the project its own persistent intelligence. Not what was said — where the work stands.
The project becomes the persistent center.
You start the work.
One objective, on one project.
An agent picks it up.
The work splits — investigation on one side, implementation on the other.
The plan changes.
A constraint turns up. You make the call, and the branches resolve into it.
The understanding changes with the work.
Not a growing pile of notes. What the project now is — and what's no longer true, with the reason it changed.
Tomorrow, someone else continues.
They rebuild none of it. The state is already there, waiting.
The project knows where it stands.
Participants are temporary. The project is not.
Each one writes what it learned, and reads what the project already knows. Nothing in between is inferred.
The tools change. The project stays.
Claude Code
Your agent reads the project's understanding before it starts
Any MCP client
The project's understanding, wherever you work
Auric CLI
auric init · auric config · auric doctor
Before
You manage the agents.
You pass the context around.
You explain the project again.
You reconstruct why things exist.
With Auric
The project carries its own understanding.
Different participants work around it.
The project can explain itself.
Its understanding evolves with the work.
Where this goes
Today, the project keeps its own understanding and continuity. That understanding is the foundation the rest is built on — coordinating more participants, noticing when work drifts from what you agreed, connecting what you planned with what actually shipped.
Memory
What did we say?
Auric
Where does the project stand?
Memory keeps pieces of a conversation. Auric keeps the project together.
- Local-firstThe record is a single file on your machine. 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 repo.
- No AI in the read pathRestores are data assembly. Same file in, same state out.
- Append-onlyNothing is edited away. Decisions are superseded, with the when and why.
Auric isn't the agent, the model or the tool. Pick each of those for the job it's good at, and swap them whenever something better arrives. They're capabilities. The project is the constant.
A few things worth knowing.
They each keep a real thing, and Auric doesn't replace any of them. Git keeps the files and how they changed. Chat keeps the conversation you had. A doc keeps whatever someone remembered to write down.
What none of them holds is the state of the work between them — the decision and the reason behind it, the thing you ruled out, the question still open. That's the part you rebuild by hand every time, usually by reading all three and reassembling them in your head.
No. Nothing observes your editor, your repo or your conversations, and nothing runs on its own. Auric only ever sees what you or your agent hand it, when you call one of its tools — one reads the project's state, one records what changed, one tracks something still open.
Closing out a session is the one place a model reads what it was handed and drafts the summary, and you choose when that runs. The restore path has no model in it at all — what you wrote is what comes back.
Not everything, and that's the design. It isn't a transcript archive or perfect recall — it keeps what the next person needs in order to move: what was decided and why, what changed, what's still open, and what comes next.
The test for anything is whether you'd have to reconstruct it before you could continue. If you would, it belongs in the state. If it's detail you'd look up in the code or the thread when you actually needed it, it doesn't.
Whoever opens the project next. The understanding sits in the project's record rather than in the session that produced it, so continuing is a matter of reading what's there — not being briefed by whoever worked last.
That record is a file on your machine, and the participants taking turns on it are yours: this session, the next one, a different tool, a different agent. That is the architecture in miniature — the project persists, and participants are how work reaches it. Widening who that includes, beyond one machine, is the direction the model was built for.
Four steps, and only the first two are yours. You ask to join; you confirm your address from the email we send; your request joins the queue; your invite arrives when your wave opens, carrying a license key and a download link.
Access opens in batches, oldest confirmed first — small enough that early users get actually supported. Confirming your email is what puts you in line, so it's worth doing straight away; it doesn't grant access by itself.
Give your project a superpower.
Every session used to start with: what happened? The project already knows.