Aura: Agents + Git + Intent Open Source

Product Introduction

1. Definition: Aura is a Git-native Integrated Development Environment (IDE) and control layer for AI coding agents. It is a fully open-source (Apache-2.0) desktop application that integrates directly with local Git repositories to provide semantic version control and provenance tracking for AI-generated code.
2. Core Value Proposition: Aura exists to solve the trust and control problem in AI-assisted software development. While AI agents can write code in seconds, Aura ensures developers can understand, verify, and own the changes by providing AST-level semantic diffs, intent logging, and a cryptographic proof ledger that ties every commit to its original goal, all without migrating from standard Git workflows.

Main Features

1. Mission Control (Unified Agent Interface): Aura provides a single window to drive multiple AI coding agents—including Claude Code, Gemini CLI, Antigravity, Cursor Agents, and any MCP-compatible agent—on a shared project history. It functions as an MCP server, allowing different agents to operate from one composer and context, eliminating tab sprawl and lost context between tools.
2. Semantic Engine & Source Control: At its core, Aura uses a Rust-based semantic engine that tracks code changes at the Abstract Syntax Tree (AST) level, providing rename-proof identity for logic, not just lines. This enables semantic diffs that show what changed in the logic under a "why it changed" header, moving beyond traditional red-and-green line diffs. It grafts onto existing Git via hooks and git notes, requiring no migration.
3. Crew (Autonomous Work-Loop): Crew is an autonomous task execution system. Developers can hand it a prioritized stack of tasks or a dependency graph. Agents then claim unblocked tasks, working in isolated Git worktrees (eliminating branch juggling), and each completion is automatically verified against the specified goal before being eligible for merge.
4. Trace & Proof Ledger: Every code change is cryptographically sealed into a "genuine-record." This ledger definitively ties each commit to the agent session, conversation transcript, and the specific goal it was meant to deliver, providing a verifiable provenance trail. This allows for git blame that traces back to the exact AI reasoning behind any function.
5. Team Radar & Memory: Team Radar provides a live awareness plane showing which agents or developers are editing which parts of the codebase to prevent collisions. Memory is a provenance-anchored, code-grounded recall system that agents can query for context before making edits, improving consistency.

Problems Solved

1. Pain Point: The "black box" nature of AI-generated code. Traditional Git shows line changes but cannot explain the intent or logical impact of AI edits, making review and regression analysis difficult.
2. Target Audience: Software engineering teams and individual developers who regularly use AI coding assistants (like Cursor, Claude Code, or GitHub Copilot) and need to maintain code quality, auditability, and ownership in fast-paced, agent-driven development environments.
3. Use Cases: Auditing and verifying AI agent contributions before merging; running multiple AI agents in parallel on a single project without conflict; automating the processing of a backlog of small bugs or features with autonomous agents; providing sealed, verifiable records of AI work for compliance or code review.

Unique Advantages

1. Differentiation: Unlike AI-powered IDEs (Cursor) or single-agent CLIs (Claude Code), Aura is agent-agnostic and operates as a meta-layer on top of Git. It provides unified control, semantic understanding, and proof-of-work across all tools, whereas competitors focus on the code generation itself.
2. Key Innovation: The combination of AST-level semantic tracking with a cryptographic proof ledger. This allows Aura to answer not just "what changed?" but "did this change fulfill its goal?" and "can you prove it?", creating a new category of intent-aware version control.

Frequently Asked Questions (FAQ)

1. Does Aura replace Git or require changing my workflow? No, Aura does not replace Git. It is a control layer that grafts onto your existing local Git repository using hooks and notes. You continue to use git commit, git push, and your standard branching workflow as normal. You can disconnect Aura at any time and continue with a plain Git repository.
2. Is my code data sent to the cloud or used for training? No. Aura is designed to run fully locally. Your code, Git history, agent transcripts, and intent records remain on your machine. The platform captures provenance for verification but does not harvest or train on your code data.
3. How does Aura handle Git operations like rebase or merge? Aura stores checkpoint and provenance data on a dedicated orphan shadow branch with sharded storage. It detects HEAD migrations during operations like rebase, stash, or pull and automatically preserves all semantic history and proof records, ensuring traceability is not lost.
4. Can I use Aura with my current AI editor like Cursor or VS Code? Yes. Aura integrates via multiple methods: as an MCP server for native agents (Claude Code, Gemini) and via automatic transcript capture hooks for editors like Cursor and Aider. This three-layer enforcement ensures edits are captured regardless of the entry point.
5. Is Aura really free and open source? Yes. The entire project—including the Rust semantic engine, CLI, desktop app, and extensions—is released under the Apache-2.0 license on GitHub. The desktop application is currently in a free public beta for macOS and Linux.