# Mission and Roadmap > Make semantic version control the default substrate for AI-native engineering. Sovereign. Open source. No vendor lock-in. This page states Aura's mission in plain language and lays out the roadmap as honestly as the roadmap exists at any given moment. It will go out of date; the public changelog is the source of truth for shipped work. But the directional commitments are stable, because they are implied by the [philosophy](/aura-philosophy) and the [principles](/core-principles). ## The mission **Make semantic version control the default substrate for AI-native engineering.** Unpack each word: - **Semantic** — operating on logic, not text. The primitive is the function, not the line. - **Version control** — the system of record for how code changes over time, who changed it, why, and with what effects. - **Default** — not a specialty tool used by a few teams; the normal way to do this work, the way Git is the normal way today. - **Substrate** — a layer beneath, that other tools (CI, review, deployment, AI agents) build on. Substrate is an infrastructural role, not a product role. - **AI-native engineering** — the engineering world where AI agents are co-authors, not assistants, and where they outproduce humans by volume if not by judgment. If Aura succeeds, in a decade, the sentence "my codebase uses Aura" will carry no more marketing weight than "my codebase uses Git" does today. It will be an infrastructural assumption. If Aura fails, it will be because we did not honor the commitments — sovereignty, open source, agent-agnosticism, intent integrity — and someone else will build the substrate with those commitments, and they will deserve the win. ## The shape of the journey There are three phases to Aura's adoption curve, borrowed loosely from the Git curve. ### Phase 1: The early users (2024–2026) Aura is used by teams with acute pain — high AI agent usage, sovereignty requirements, merge-conflict fatigue. Early adopters tolerate rough edges because the alternative is worse. The project is shipping fast, breaking interfaces sparingly, and building primary features. This phase is where Aura is now. The v0.14 line is production-quality for the core use cases. Mothership runs in several organizations. Sentinel coordinates real agent fleets. The MCP server ships with Claude Code, Cursor, and Gemini integrations. ### Phase 2: The mainstream adopters (2026–2030) Aura becomes a normal tool among tooling-aware engineering organizations. Editor integrations mature. Review platforms understand semantic diffs. CI systems ship Aura hooks out of the box. Enterprise deployments grow. The ecosystem around Aura — third-party tools, training content, community plugins — starts to resemble the early GitHub era of Git. This phase requires things the engine already does plus things the engine doesn't yet do: deep editor integration (LSP-level), first-class review tooling, enterprise policy controls, compliance certifications. ### Phase 3: The substrate (2030+) Aura is the default. New tools assume it the way new tools today assume Git. AI agents are trained on structured logic-graph data rather than text diffs. Universities teach version control by teaching Aura. Git continues to exist and be maintained, as SVN still exists, but it is no longer where the frontier lives. This phase is a bet. It requires Aura's philosophy to be correct about the trajectory of the industry, and it requires the project to execute honestly for another decade. ## Release history (as of writing) A compressed version of what has already shipped. The full changelog is the canonical record. - **v0.7.0** — Semantic diffing and rename-proof identity. The first version where the core thesis was usable. - **v0.10.1** — Doctor checks, README overhaul. Stability milestone. - **v0.11.0** — **Mothership Mode**: P2P team collaboration. Fully open source across the stack. - **v0.12.x** — Live Sync, Sentinel v1, MCP tool surface expansion. - **v0.14.x** — Intent validation hardening, auto-responder, zone claims, multi-agent collision detection. The cadence has been roughly one significant release per month, with patch releases as needed. ## Near-term roadmap (next two quarters) Dates are soft; the shape is firm. ### Engine hardening - **Cross-language semantic merge** for the long tail of tree-sitter grammars. Currently strongest in Rust, Python, TypeScript, Go, Java. Expanding to Ruby, C#, Kotlin, Swift, PHP with full parity. - **Performance work** on the logic graph for monorepo scale (100k+ functions). - **Incremental parse** so large repos don't re-parse on every operation. ### Intent and audit - **Richer intent schema** — structured fields for category (feature / fix / refactor / perf / security), affected areas, risk level, rollback plan. - **Intent search** — query the intent log across history to answer "why did we change this?" - **Signed intent** — cryptographically bind intent to the author (human or agent) for audit. ### Sentinel and agents - **More agent adapters** beyond Claude Code, Cursor, Gemini CLI, Copilot Agent — including newer entrants and custom agent frameworks. - **Agent-team primitives** — named agent teams, role assignments, delegated authority. - **Handover improvements** — tighter context compression, better resume semantics. ### Mothership and sovereignty - **One-command deployment** — single binary, Docker Compose, and Kubernetes manifests. - **Federation** — multiple Motherships that sync at the edge, for multi-region sovereignty. - **SSO and enterprise auth** — OIDC, SAML, SCIM for enterprise deployments. ### Ecosystem - **First-class editor integrations** — VS Code, Neovim, Zed, JetBrains. - **Review tooling** — a purpose-built semantic review UI, and integrations with existing review platforms. - **CI integrations** — official GitHub Actions, GitLab CI, Buildkite plugins. ## Medium-term roadmap (2026–2027) ### Structured program understanding The logic graph is a substrate for more than diffs. In the medium term, Aura exposes: - **Call-graph and data-flow queries** as first-class operations. - **Test-impact analysis** — given a change, which tests are affected? - **Dead-code detection and safe deletion** — prove a function is unreachable before removing it. - **API contract tracking** — surface every breaking change to a public surface. ### Proof-backed changes Building on `aura_prove`, the ability to attach proofs to commits — not theorem-prover proofs, but traceable, reproducible arguments that a commit implements what it claims. ### Training-data production A structured, privacy-aware export format that converts Aura's semantic history into training data for future code-generation models. Aura is already a better data source than Git for this purpose; making it first-class is a natural next step. ## Long-term direction (2027+) The long-term direction is not a feature list; it is a set of bets. ### Bet 1: semantic is the new default In five years, tooling that does not understand the AST of source code will feel as dated as tooling that does not understand Unicode. Aura's job is to be the substrate other tools assume. ### Bet 2: sovereignty becomes a compliance default, not a preference Regulatory pressure on AI-touched code will make self-hosted toolchains the default for most regulated industries. Aura's Mothership model is positioned for this world. ### Bet 3: agents coordinate through a shared substrate, not bilaterally The current pattern — Claude talks to Claude, Cursor talks to Cursor — is a transient phase. The stable pattern is a shared coordination layer that every agent speaks. Sentinel is our attempt to be that layer; whether it wins or something else does, the category will exist. ### Bet 4: verification beats review Human review of AI-authored code does not scale. Verification — cryptographic, semantic, structured — does. Aura invests in verification tooling as the answer to the scaling problem. ## What Aura will never do Some commitments are about what we won't build, not what we will: - **We will never close the source.** Apache 2.0 is permanent. - **We will never require telemetry** to use the engine. No usage tracking, no phone-home. - **We will never lock semantic features behind a paid tier.** The engine is the engine. - **We will never ship an agent-specific coordination mode.** Sentinel stays agent-agnostic. - **We will never rewrite your Git history** without explicit consent. - **We will never require a cloud account** for any core workflow. These are architectural constraints, not marketing promises. Violating them would violate the [philosophy](/aura-philosophy). ## The commercial story The project is open source. The company behind it — Naridon — is for-profit. These are not in tension; they are the same pattern that GitLab, MongoDB, Elastic, and many others have run. The commercial surface is: - **Hosted Mothership** for teams that don't want to self-host. - **Enterprise support** contracts with SLAs, compliance, and priority fixes. - **Aura Dashboard** — a web UI for intent review, semantic PRs, team analytics. - **Integrations** with commercial forges, review platforms, and observability tools. The engine — CLI, merge engine, Mothership, Sentinel, Live Sync, MCP — is open and will remain so. The commercial work is on the *infrastructure around* the engine, not the engine itself. ## How to influence the roadmap The project is developed in the open. The most effective ways to shape where Aura goes: - **Open issues** with concrete workflow pain points. - **Contribute features or grammars** via pull requests. - **Run Aura in production** and report back; real usage data is the strongest signal. - **Talk to us** about your compliance, sovereignty, or multi-agent needs. We read everything. The roadmap is not a committee product, but it is heavily informed by what users actually hit. ## The one-paragraph version Aura's mission is to replace the text-based substrate of version control with a semantic one, to do so openly and sovereignly, and to become the default way AI-native engineering organizations manage code over the next decade. The near-term roadmap is engine hardening, ecosystem building, and enterprise readiness. The long-term roadmap is infrastructure ubiquity. The commitments — open source, sovereignty, agent-agnosticism, intent integrity, verifiability — are stable across every time horizon, because they are what make the substrate trustworthy enough to become a default. ## Next - [Core Principles](/core-principles) — the operational principles. - [The Aura Philosophy](/aura-philosophy) — the commitments behind the mission. - [Design Decisions](/design-decisions) — why Rust, tree-sitter, P2P, Apache 2.0, MCP. - [How Aura Works](/how-aura-works) — the architecture that executes the roadmap.