Aura · a build log
Version control for code you didn’t write.
It started as a CLI that caught an agent deleting a function. It’s a desktop now. Here’s the whole arc.
No pitch — just the product, told the way you’d tell another engineer. Every screenshot is the real app.
01 Where it started
An agent deleted a function. Git said nothing was wrong.
You ask Claude Code to “clean up the retry logic.” It returns a tidy green-and-red diff. It compiles. You merge it. Three days later something at 2am calls a function that isn’t there — the agent quietly dropped it, the tests didn’t cover it, and the diff looked fine because git only ever saw lines of text move around.
# the agent's diff: +18 −24. looks like a cleanup. it isn't. $ git diff --stat src/retry.ts | 42 +++++++++--------------- 1 file changed, 18 insertions(+), 24 deletions(-) # git has no idea a public function vanished. it sees lines, not meaning. $ grep -r "backoffWithJitter" src/ | wc -l 0 ← it was here this morning
Git was built for humans typing at human speed, reviewing every line they wrote. Agents broke that: they write at volume, you can’t read every diff, and “who wrote this” stopped being one person. So we built the layer git is missing.
02 The first thing we shipped
A CLI that reads your repo as a tree, not a text file.
Aura started as one binary. It sits on top of the git you already use and parses every change at the AST level — functions, classes, constants, the edges between them — so it tracks logic nodes, not lines. Your repo, branches and remotes are untouched. You can walk away with plain git at any time.
$ aura status repo retry-service · branch feat/backoff tracked 1,284 logic nodes across 96 files session active · 3 checkpoints · last 4m ago strict ON — deletions need a logged reason before they commit ✓ working tree clean at the AST level
Your repos, branches and remotes stay exactly as they are. Aura adds a layer; it never takes the code hostage.
A renamed function is the same node, not a delete + an add. Diffs are about behaviour, not whitespace.
Turn it on and the pre-commit hook blocks an agent from dropping a function unless it says — in writing — why.
03 The idea that made it click
State the intent. Aura checks it against what the code actually did.
Before a commit, the author — you or the agent — says what they meant to do, in one plain sentence. The pre-commit hook then diffs that stated intent against the real AST change. When they disagree, it flags it: the commit says “add input validation” but it also deleted three functions and touched the auth layer. We call that intent poisoning, and catching it is the whole point.
$ aura log-intent \ "harden retry: exponential backoff + cap" ✓ Intent logged. Aura will bind this reasoning to your AST changes on the next commit.
$ git commit -m "harden retry" ⚠ intent poisoning stated vs actual said: harden retry logic did: − deleted authMiddleware() − deleted backoffWithJitter() + added retryWithCap() blocked — explain the deletes or rewind them
This is the thing a textual diff can’t give you: a record of what was meant, checked against what happened — at the level of functions, every commit.
04 Two verbs git doesn’t have
Undo one function. Prove a goal is actually wired.
Because Aura operates on AST nodes, you can revert a single function to its last safe state without a merge conflict — surgery, not a full reset. And you can ask whether a behaviour is genuinely implemented: aura prove walks the logic graph and tells you which nodes exist, which are connected, and where the gaps are.
$ aura rewind backoffWithJitter restoring 1 function to its last safe state… ✓ backoffWithJitter() re-attached other edits in retry.ts left untouched. no merge conflict — it's an AST graft.
$ aura prove "user can sign in with OAuth" ✓ route /auth/callback exists ✓ exchangeCodeForToken() wired ✗ session is never persisted gap partial — 2 of 3 paths connected
05 Then the agents started using it
The CLI became a tool the agents wield themselves.
Aura ships an MCP server. Point Claude Code, Cursor or Codex at it and the agent calls Aura directly — snapshotting a file before it edits, logging its intent before it commits, proving a goal before it claims done. The safety rail stops being something you remember to run; it’s wired into the agent’s own loop.
// the agent now has aura_snapshot, aura_log_intent, // aura_prove, aura_rewind, aura_pr_review … 29 tools. { "mcpServers": { "aura-vcs": { "command": "aura", "args": ["mcp"] } } } → agent, mid-task: aura_snapshot(retry.ts) ✓ → agent, before commit: aura_log_intent("…") ✓
That’s the moment the CLI stopped being a tool you ran and became infrastructure the agents run against. The next question was obvious: the work had moved off the terminal and into a cockpit. Aura needed a face.
06 Aura Desktop
The same engine, under a workspace that drives every agent.
Aura Desktop is a native app (Rust + Tauri) with the semantic engine underneath. It’s a supervisor, not another single-model editor: talk to it in plain language and it works the repo — and you can hand a live session from one engine to another without losing the thread. Aura, Claude Code, Gemini, Codex, Cursor — one window.
One workspace, every agent
Agent reads your changes
Continued on Gemini07 Source control
History you can read — not a wall of diffs.
Everything the CLI did is here, visual. Each commit carries its intent narrative and a genuine-record badge tying the story to the code. The Changes panel summarises your uncommitted work in plain language, and Go Live syncs the meaning to your team without pushing a byte of code.
History + intent
Changes · Go Live
Your uncommitted work08 The diff, explained
AI-written diffs, in plain language — with the intent check on top.
Every diff gets a “why it changed” header: what moved, why, and what to watch. Underneath, the same intent-vs-AST check from the CLI runs and flags when a claim doesn’t match the code. Reviewing agent output at volume becomes something a human can actually do.
Why it changed
Change note
Intent ↔ AST match09 Crew
Hand it a goal. A fleet of agents works it in order.
Crew lays a goal out as a dependency graph and drives multiple agents through it — collision-aware so they don’t edit the same symbol, proof-backed so each finished task is tied to the goal it delivered, and self-healing with a one-click retry when an agent fails. Run it once or on a schedule.
Work board
Goal graph
Runner10 Pull requests
Review built for agent output at volume.
A forge surface a team already knows — Overview / Files / Conversation, line-anchored comments, reviewers, labels, related tasks — made semantic underneath, with an automated safety check that surfaces layer violations and risky changes before you approve.
Overview · safety check
Conversation
Files · inline review11 The team plane
Channels and DMs, over a signed, real-time feed.
Chat sits alongside a live feed of signed INTENT and COMMIT events — every action attributed to a person, the agent they used, and a sealed record. An awareness radar shows who, or which agent, is touching what before two of them collide.
Signed intent feed
Channels & agents12 Tasks & Pages
Work an agent can pick up. Docs that sit beside the code.
Tasks, sub-tasks and goals live on one board — assignable to a person or an agent and handed straight into a working session. Pages keep guides, RFCs and handbooks in the same workspace, readable by the team and by the agents, so context isn’t scattered across five other tools.
Work-items board
Task detail
Pages · handbook13 Trace
The codebase’s whole story — provable.
Because every change is provenance-anchored, the project’s history isn’t a guess. Trace is the per-session forensic record — replay the timeline, match what the agent claimed against what the code did, and verify the cryptographic seal. Each change signed: which human, which agent.
Project timeline + stats
Session transcript
Sealed record14 Two planes
Built on git, not against it.
Repos, branches, remotes, your existing workflow. Aura never takes the code hostage; you can walk away with plain git at any time.
Intent, provenance, signatures, blast-radius, agent identity. Portable, verifiable, and where Aura’s value compounds.
15 Where it’s going
The version-control layer for the agentic era.
Most code is now agent-written. Whoever owns version control and collaboration for that code owns the next platform — and that layer doesn’t exist yet. Next up: provenance-anchored agent memory that’s grounded in your real code, a goal-alignment spine so every build is provably tied to its goal, and open-sourcing the desktop. The engine and CLI are Apache-2.0 today.
Built in the open, shipped every day. The desktop app is in public beta and closed-source for now — we plan to open-source it later; the semantic engine and CLI are Apache-2.0 already.
Aura · Naridon, Inc. · auravcs.com