What is Aura?

A semantic version control engine for the AI era. Aura tracks logic, not text.

Aura is a semantic version control engine that tracks source code as a graph of logic nodes — functions, classes, methods — rather than as lines of text. Every logical unit in your codebase receives a content-addressed hash derived from its Abstract Syntax Tree (AST), giving each function a stable identity that survives renames, reformatting, and file moves. Aura is written in Rust, ships as an open-source tool under the Apache 2.0 license, and integrates with Git while offering a full sovereign runtime through its peer-to-peer Mothership Mode. It is the third generation of version control: after centralized SVN (2000) and distributed Git (2005), Aura (2026) is the first VCS designed from first principles for a world where AI agents write the majority of new code.

That definition is dense on purpose. The rest of this page unpacks it.

The one-sentence version

If Git is a text database with commits on top, Aura is a logic database with commits on top. The unit of version control is the function, not the line.

Why this matters now

For twenty years the dominant version control model — Git — has treated source code as a sequence of characters grouped into files. A diff is a minimal edit script between two text snapshots. A merge is a three-way line-level reconciliation. This model served the era of human-authored code admirably. Two humans rarely edit the same lines at the same time, and when they do, the conflict is usually obvious and small.

That era is ending. Internal reports from GitHub, Anthropic, and major AI labs indicate that more than half of new code in modern engineering organizations is now written by AI agents — Claude Code, Cursor, Gemini, Copilot, and their successors. When three AI agents refactor the same module in parallel, each producing semantically equivalent but textually divergent patches, Git's line-level merge algorithm fails catastrophically. Recent research on agentic workflows (AgenticFlict, 2025) measured a 26.86% merge conflict rate for parallel AI-generated patches — an order of magnitude higher than human developer baselines.

Aura was built because the substrate has to change. You cannot version-control AI-authored code the way you version-controlled human-authored code. The units are wrong. The diffs are wrong. The merges are wrong. The identity model is wrong.

The core idea: content-addressed logic

Git identifies content by hashing the bytes of a file. Rename auth.py to authentication.py and Git sees a delete plus a create (rename detection is a heuristic layered on top, not a first-class property). Move a function from one file to another and Git loses its history entirely.

Aura identifies content by hashing the normalized AST of each logical node. A function's identity is its logic, not its location. Concretely:

• Every function, method, and class gets an aura_id derived from a canonical AST representation.
• Rename the function, move it to another file, reformat it, re-indent it — the aura_id is stable.
• Change the logic by one operator and the hash changes, but the semantic link between the two versions is preserved in the logic graph.

This is the shift that unlocks everything else: semantic diff, semantic merge, intent validation, agent coordination, sovereign sync.

What Aura ships with

Aura is not a prototype. The v0.14 line is production-ready and used in-tree for its own development. The engine comprises:

Semantic merge engine

A cross-language AST-level merge engine built on tree-sitter. When two branches touch the same function, Aura merges the parse trees, not the text. When two branches touch the same file but different functions, there is no conflict to merge. See Aura vs Git for worked scenarios.

Mothership Mode

A self-hosted peer-to-peer team hub. TLS-terminated, JWT-authenticated, and fully sovereign — you run it on your own hardware, in your own jurisdiction. No third-party cloud, no vendor lock-in, no data leaving your network. See Mothership Overview.

Sentinel

A protocol for coordinating multiple AI agents working on the same repository. Claude, Cursor, Gemini, and Copilot can message each other, claim zones, detect collisions, and hand off work — all through Aura. Agent-agnostic by design. See Sentinel.

Live Sync

Real-time function-level synchronization between teammates, refreshed every five seconds. When a colleague (or their AI agent) modifies calculate_tax, your local Aura instance sees the new logic before the commit lands. See Live Sync.

Intent tracking

Every commit is accompanied by a logged intent — a human- or agent-written statement of why the change exists. A pre-commit hook validates that the stated intent is consistent with the actual AST changes. Deleted a function without explaining why? Aura blocks the commit. Claimed to "refactor for clarity" but silently added a network call? Aura flags it as intent poisoning.

MCP tools

Aura exposes 29+ tools through the Model Context Protocol, making it a native citizen in any AI coding environment that speaks MCP. Your agent can query the semantic state, request snapshots, log intent, and coordinate with other agents without bespoke integration code. See MCP Integration.

Git compatibility

Aura runs alongside Git. You can adopt Aura in an existing Git repository without rewriting history, migrating tooling, or changing your hosting provider. Aura's on-disk artifacts live in .aura/ beside .git/. You can also run Aura standalone if you want to skip Git entirely.

A new definition of "the repository"

Under Git, the repository is a content-addressed store of blobs, trees, and commits. Everything is text, and every text unit is independent. Under Aura, the repository is a graph of logic nodes connected by calls, imports, and inheritance, annotated with intent, history, and cryptographic proofs.

This graph is the substrate for everything Aura does:

• A semantic diff is a delta on the graph.
• A semantic merge is a graph merge.
• An impact alert is a graph query: "which nodes that I depend on have changed?"
• A proof is a graph traversal: "is there a wired path from this user action to this database write?"
• An agent handover is a graph serialization: "here is the logical state of the work in progress."

Text is still the serialization format on disk — source files remain source files — but the versioned artifact is the logic graph, and the logic graph is what Aura reasons about.

What Aura is not

Aura is not a replacement for your editor, your build system, or your test runner. It is not a code-review platform, though it exposes structured data a review tool can consume. It is not a hosting provider; Mothership Mode means you host it yourself. It is not a closed-source product with an open-source teaser. The entire CLI, the merge engine, Sentinel, Mothership, Live Sync, and the MCP server are all Apache 2.0 licensed as of v0.11.0.

Aura is also not opinionated about your language stack. Because the parser is tree-sitter, Aura supports every language tree-sitter supports — Rust, Python, TypeScript, Go, Java, C, C++, Ruby, and dozens more — without per-language merge engines.

Who is Aura for

In short: anyone whose codebase is being edited by more than one actor at a time, where at least one of those actors is an AI.

That is, in 2026, effectively everyone. But concretely the early adopters are:

• Teams where AI agents open more pull requests than humans do.
• Teams running parallel agent workflows (three Claudes refactoring three modules simultaneously).
• EU, UK, and APAC organizations with data-sovereignty requirements that rule out US-hosted forges.
• Research labs and defense contractors that need cryptographic audit trails for every logic change.
• Open-source projects overwhelmed by low-quality AI-generated pull requests, where intent validation can filter signal from noise.

See Who Should Use Aura for the long list.

How to read this documentation

This Introduction module (ten files including this one) establishes the conceptual foundation. If you read only one more page, read Why Aura Exists — it makes the case for the category. If you want the architectural tour, read How Aura Works. If you want the history, read The Third Era of Version Control.

From there, the docs branch into practical modules: semantic merge, Mothership, Sentinel, Live Sync, intent tracking, MCP integration, CLI reference, and migration guides. You can adopt Aura incrementally — start with semantic diff in an existing Git repo, add intent logging, then enable Sentinel when you bring in your first AI agent, then stand up a Mothership when you go team-wide.

The long thesis in one paragraph

Version control is not a solved problem. It is a substrate problem, and substrates get replaced when the workload changes. The workload changed when AI started writing code. Text diffs cannot express what AI-generated patches actually do, line-level merges cannot reconcile them safely, and text-based identity cannot survive the aggressive refactoring that agents perform. Aura replaces the substrate. Logic is the unit. Intent is the metadata. AST is the diff. Graph is the repository. Sovereignty is the default. Agents are first-class. This is the thesis, and every design decision in Aura — down to the choice of Rust, tree-sitter, P2P, Apache 2.0, and MCP — flows from it.

Next

• Why Aura Exists — the case for the category.
• The Third Era of VCS — CVS, SVN, Git, Aura.
• Aura vs Git — the side-by-side.
• Core Principles — the seven rules.