Give your project a superpower.
Persistent project context for your AI coding tools.
Your agents save where the project stands — the goal, what was decided and why, what's open, what's next. The next session, tool or agent reads it back and carries on, instead of starting from zero.
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.
What works today
What you can do with Auric
Auric runs on your machine and connects to your AI coding tools through MCP. When an agent saves where the project stands, any later session, tool or agent connected to Auric can read it back.
Example · one project, two sessions, two tools
Session 1 · Claude Code
Works on password reset, then saves where it stands.
Auric · on your machine
- Goal
- Ship password reset
- Decided
- Single-use tokens, 30-minute expiry — so no plaintext tokens are stored
- Open
- Reset email template
- Next
- Fix the token expiry check
Session 2 · Cursor
“Catch me up.” Starts from the next step — no re-explaining.
Continue across sessions
End a session whenever you like. The next one asks Auric where things stand and gets the goal, decisions, open items and next step back — not a blank page.
Switch AI coding tools
Claude Code and Cursor don't need to share a conversation. Connect both to Auric and each can read what the other saved.
Hand work between agents
One agent records what it found and what's next. The next agent reads that before it starts, so it doesn't start blind — then adds what it did.
Keep decisions with their reasons
Decisions are saved with why they were made. Open questions and blockers stay listed until someone resolves them.
Stop re-explaining your project
New sessions start from what was saved, not from your memory of it.
Not in the beta
- It doesn't capture anything on its own. Your agent saves to Auric when you, or your project instructions, ask it to.
- It doesn't copy chats between tools. Tools share the saved project context, not conversations.
- It doesn't assign work or coordinate agents running at the same time. Agents hand over in turn, and the latest update is what the next one sees.
- It stays on one machine. Sharing with teammates or across computers isn't part of the beta.
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 saves and restores the project's context through Auric's tools
Cursor
The same project context — no chat copied across
Any MCP tool
The project's understanding, wherever you work
Auric CLI
auric license → 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. Works offline.
- 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.