Aura is not another chat box for coding.
It is a Git-native IDE for working with AI coding agents. You can run agents, track their changes at the function and class level, compare the code against the original intent, and prove whether a task was actually completed before you commit.
Git shows you lines changed.
Aura shows you what changed in the logic.
This is the 2nd launch from Aura : Agents + GIt + Loops OSS ADE. View more
Aura: Agents + Git + Intent Open Source
Launching today
Aura is not another chat box for coding.
It is a Git-native IDE for working with AI coding agents. You can run agents, track their changes at the function and class level, compare the code against the original intent, and prove whether a task was actually completed before you commit.
Git shows you lines changed.
Aura shows you what changed in the logic.
Free
Launch Team / Built With
Aura : Agents + GIt + Loops OSS ADE
the AST-level diffing instead of parsing agent output is the smart call, that's the part that'll actually survive tool updates. question on the "intent" side though - where does the original intent come from? is it the prompt you gave the agent, a spec you write separately, or does Aura infer it from the diff itself? asking because if intent has to be written by hand for every task, that's extra overhead people will skip under deadline pressure, which is exactly when you'd want the check most
Aura : Agents + GIt + Loops OSS ADE
How do you keep function- level tracking accurate as Claude Code and Cursor update their output?
Aura : Agents + GIt + Loops OSS ADE
@kellyops
Great question, here's the honest answer:
Aura doesn't parse agent output at all. That's the key. It tracks changes at the AST level directly from the code on disk, not from anything Claude Code or Cursor emit. So when those tools change their output format, prompt, or diff style, there's nothing for us to break against, we re-parse the actual source files with tree-sitter and diff the syntax trees. The agent could hand us code by carrier pigeon; we only ever look at the resulting bytes.
Three things make the function-level tracking robust across agent updates:
Language grammars, not tool contracts. Function/class boundaries come from tree-sitter grammars per language. Those track the language, which moves slowly and independently of any agent vendor. A Cursor update can't shift where a Rust `fn` begins.
Rename-proof node identity. We identify logic nodes by structure and content, not by line number or name, so a function that gets renamed or moved is followed as the same node rather than counted as a delete + add. This is the same mechanism whether a human, Claude Code, or Cursor made the edit, the source of the change is irrelevant to identification.
Capture is at the git/filesystem boundary, agent-agnostic. Intent + AST snapshots hook in at commit/edit time on the repo itself. We deliberately built one renderer / one tracking path that any agent flows through, rather than an integration per tool, so there's no per-vendor adapter to maintain as they update.
So the maintenance burden isn't "keep up with N agents changing their output", it's "keep up with tree-sitter grammars," which is a much smaller, slower-moving surface that the whole ecosystem shares.
The one real edge is brand-new language syntax (e.g. a new language version adds a construct the grammar doesn't know yet), that's a grammar bump, not an agent-tracking problem, and it's the same fix regardless of which tool wrote the code.
I hope this helps, you can reach me at mo@auravcs.com if you want to discuss further or see how you can adopt it.
The built-in loops caught my attention since that’s usually where agent workflows start getting more interesting. Are those loops something developers configure themselves, or can Aura adapt them based on how the agent is performing?
Aura : Agents + GIt + Loops OSS ADE
@mhdashiquek That’s a helpful explanation. I like the idea of validating work against the intended goal instead of just retrying blindly—it feels like a cleaner way to keep long-running agent workflows on track. Thanks for taking the time to explain it.
An open-source ADE sitting on top of local agent CLIs like Claude Code and Cursor is the missing control layer — the agents ship fast but there's no cockpit over them. Two setup questions: does Aura run fully local against my own repo and agent binaries, or does the orchestration route through a hosted service? And where does the loop/intent state live — committed into the repo alongside git, or in a separate Aura store I'd have to sync per machine?
Aura : Agents + GIt + Loops OSS ADE
@noctis06
Local-first, yes, the loop runs entirely on your machine. The desktop app and CLI drive your agent binaries (Claude Code, Codex, Cursor, Gemini) as local subprocesses, against your git repo. There's no hosted orchestrator in the path, the kick-agent → check-diff → prove → commit loop executes locally and works fully offline. The only cloud touchpoints are opt-in and additive: team awareness/collab sync, consent-gated anonymous telemetry, and our hosted "brain" if you choose it instead of your own binaries. Nothing about running agents against your repo requires our servers.
State lives in the repo, not a side store you babysit. Aura keeps two planes. Your code stays in plain git, untouched. The meaning plane, intent log, the goal/proof ledger, session records, lives in a .aura/ directory inside the repo and is git-tracked, so it travels through your normal git push/pull with no separate per-machine sync. Purely local artifacts (rewind snapshots, caches) stay on the machine by design and aren't something you need to move around. So: committed alongside git, portable with the repo, and readable/diffable like anything else in it.
The built-in loop is the part I keep hand-rolling myself: kick the agent, check the diff, re-run. How does Aura decide a loop is done versus stuck in a rewrite spiral? That's usually the moment I have to step in and babysit mine.
Aura : Agents + GIt + Loops OSS ADE
@chielephant
That babysitting moment is exactly what we built the loop around, so the short version: Aura judges "done" by the goal, not by "the agent stopped talking." Every task carries an explicit goal, and after each pass Aura runs a proof against it, checking the logic your change was supposed to add actually exists and is wired in, plus tests and an intent-vs-change match. "Done" = that verdict comes back verified and the work commits cleanly.
The rewrite-spiral case falls out of the same mechanism: passes are bounded, and because each iteration is scored against the goal, a spiral shows up as iterations that keep running without moving the verdict (checks still failing / not wired). At that point the loop stops and hands the task back as failed, with the proof verdict attached, so instead of watching every diff, you get pulled in once, with a straight answer to "what's still not satisfied." It also flags when an agent's edits drift from the stated intent, which is usually the earliest signal a run is going sideways.
Fair disclosure: automatic rollback-on-failed-verify and worktree-parallel passes are still landing, today it stops and surfaces rather than auto-reverting, but the goal-anchored "is this actually done" check is the live core.
I was checking this out earlier, and it looks like the first ADE that won't be overkill for my simple workflow (I just use the terminal in Zed with Codex and Antigravity CLIs) while allowing me to add in some of the more advanced techniques.
I've come back to download and try it out, but the site's down, unfortunately.
Aura : Agents + GIt + Loops OSS ADE
@thedatadavis
Hey Chris, really glad it landed that way, because that's exactly what we built it for. Aura isn't trying to be another heavyweight IDE you have to move into. It's a thin layer over the Git and terminal you already use, so you keep working in Zed with your Codex and Antigravity CLIs, Aura just runs underneath them.
That's where the "more advanced techniques" come in, whenever you want them, none of it forced on you:
Drive any of your CLIs from one place and switch between them mid-task without losing the thread, one shared history across all of them.
See what an agent actually changed in plain language (not just a wall of red/green), with a verdict on whether it really does what you asked.
Hand it a backlog and let it work through tasks on its own, proving each one before it lands.
Undo a single bad function surgically instead of rolling back your whole session.
And sorry about the site, you'd caught a broken link on our end, now fixed. Here's the working one:
👉 https://auravcs.com , Download's right on the page. Free, public beta, macOS + Linux.
It's also fully open source (Apache-2.0) if you ever want to look under the hood: github.com/Naridon-Inc/aura
Would genuinely love your take once you've played with it, especially whether it stays out of your way the way it should.
@mhdashiquek Turns out my wifi was being weird! I'm going to download now and give it a try.
@mhdashiquek Can we get Antigravity CLI (agy) added to the presets since Gemini CLI is being sunset for individuals?
Aura : Agents + GIt + Loops OSS ADE
@thedatadavis Sure, you can always use the built in terminal to run any CLI agent, but can add it as a preset so that it's easier. Thanks a lot for checking, please let me know if you need any support.