THE NEW DEVELOPMENT PARADIGM

Software is no longer built the way it used to be.

Machines write the code. AURA governs the full cycle — from idea to merge — with specification, multi-agent coordination, explainable verdicts, and evidence. Without depending on any single vendor.

Start for free →See the full cycle

First verdict in under 10 minutes · No card required · Runtime free on every plan

From idea to merge● governed in real time
IdeateAURA SpecEarly accessExecuteAURA RuntimeFreeOrchestrateAURA OrchestraPro · from 2027VerifyAURA ReviewAvailableTestAURA QAUnder construction
93Approved. All four criteria in green. Merged without anyone opening the PR by hand.

Born inside a next-generation software factory. Proven in production before it was sold.

670+
reviews in production
56
governed repositories
~46%
of code is written by AI
5
modules, one cycle
The platform

Five modules. One cycle. Fully governed.

Each module covers a natural stage of development, and all share the same context: the specification born in Spec is what Review verifies at the end.

01 · IDEATEEarly access

AURA Spec

Write the idea in natural language, by voice, or with a document. AURA turns it into a specification with two versions: one to read and one for an agent to execute.

Spec →
02 · EXECUTEFree · invite-only beta

AURA Runtime

All your agents — Claude Code, Codex, Cursor, OpenCode, open models — in a single approval queue with pre-calculated risk. Without changing your tools.

Runtime →
03 · ORCHESTRATEPro · from 2027

AURA Orchestra

The Pro version of Runtime: flows, missions, and roles. Included in Pro from 2027. Organize many projects at once without switching tools.

Orchestra →
04 · VERIFYAvailable

AURA Review

Every Pull Request gets a 0–100 verdict on four criteria — intent, coherence, quality, security — and a decision: approve, comment, test, or block.

Review →
05 · TESTUnder construction

AURA QA

When Review approves the change, QA checks that it behaves as the spec required: tests, regressions, and evidence that it shipped well. Still under construction.

QA →
Why AURA exists

The bottleneck moved. No one governs the full cycle.

Before · humans wrote the code

  • 1A human writes every line. Code is scarce and expensive.
  • 2Another human reviews what they can. The rest slips through.
  • 3A third person plans in a tool disconnected from the code.
  • 4Company speed is how many of those humans you can hire.

Now · the age of artificial intelligence

  • 1Agents write 8–10× more code. Three or four vendors at once.
  • 2The developer directs, no longer writes. And approves dozens of actions a day across ten terminals.
  • 3Nearly half of new code is written by AI on teams already using Copilot.
  • 4The bottleneck is specifying, coordinating, and verifying. And no one governs all three together.

No vendor will build the neutral layer that governs their competitors' agents. That is why AURA exists. Read the paradigm manifesto →

Source: GitHub reported that Copilot generates 46% of its users' code — nearly half. GitHub, Feb. 2023. It remains the most cited public benchmark heading into 2025.

AURA Review · available today

When everything is right, AURA does not make you wait.

This Pull Request does what the spec asked for, breaks nothing else in the system, passes its tests, and has no vulnerabilities. AURA reviews it, explains it, and approves it on its own.

Plan Proacme/checkout · PR #2087 · feat(cart): apply discount coupon in the summary live

◆ Intent inherited from the spec AURA-118

Origin: Spec · linked_issue · confidence 0.97

“Apply the coupon code to the cart summary and show the discount before checkout.”

expected surface: [cart/summary, cart/coupons]
must not touch: [checkout/payment, billing/invoice]

app/services/cart/apply_coupon.rb
⏱ Human time saved on this PR estimate
0minutes

Estimated from the size and complexity of the change

Human review
≈ 22 min
With AURA
41 sec
✓ INTENT · does it do what was asked?96 / 100
The coupon is applied to the summary and the discount is calculated before checkout, exactly as the spec AURA-118.
✓ COHERENCE · does it fit the system?94 / 100
Only touches cart/summary and cart/coupons. Does not reach checkout/payment or billing/invoice: no side effects where they should not be.
✓ QUALITY · is it well built?91 / 100
New tests cover expired coupons, invalid codes, and maximum discount. File coverage: 88% (+6%). Lint clean.
✓ SECURITY · is it safe?97 / 100
No secrets, no new dependencies, no injection patterns. Coupon lookup uses prepared parameters: correct.
93
Confidence index / 100
✓ Approved
All four criteria clear the threshold the team defined. Policy says these cases merge on their own.
Intent · 96 ✓
Coherence · 94 ✓
Quality · 91 ✓
Security · 97 ✓
policy: auto-merge if all 4 criteria ≥ 85 and no critical paths are touched
✓Merged automatically · the team gets the summary and moves on to the next spec.

And when something is not right, AURA blocks it with reasons: which criterion failed, which policy applied, what evidence was there. See AURA Review →

Runtime · multi-vendor agentic management

All your agents. One queue. Free.

Every vendor wants you to use only their agent. Runtime detects traffic from all of them on your machine, groups their approval requests, and scores the risk before you decide. Without changing any tool.

Approval queue · cerebro (linux)1pending
claude-codeWrite apply_coupon.rbaura-web · within the expected surface of AURA-118✓ approved
opencodeRun rails db:migrateaura-api · creates coupons table · reversiblemedium risk
antigravityRead 14 files from checkout/aura-mobile · read only✓ approved
codexRun npx playwright testaura-web · 12 E2E tests · isolated network✓ approved
4 agents · 3 vendors · 1 human decision per action1,221 events today
Request Runtime access →

Free on every plan. Many projects at once? Orchestra organizes them by mission and role. Included in Pro from 2027.

Results

What AURA gives back to a real team.

From our own team's data: 56 repositories and more than 670 reviews in production.

estimate
0
saved per Pull Request
Versus the average time of an equivalent human review. Pending internal validation.
0
more code
With the same human team, at the same prior pace

What is this worth for your team?

A team of 10 developers opening 280 Pull Requests a month recovers about 98 human hours — nearly two and a half weeks of one full-time person, every month, without hiring anyone else.

280 PRs × 21 min saved ÷ 60 ≈ 98 hours / month
Calculate with my team →

Estimates based on real AURA usage and the average time a senior developer spends reviewing a comparable Pull Request.

The basis of every decision

Four questions. One clear answer.

Before deciding, AURA answers these four questions about every change. When all four pass, the code moves forward on its own. When one fails, you know exactly which and why.

01 · Intent
Does it do what was asked?

Compares the change against the spec, the new tests, or the instruction that generated it. Without asking anyone to write a separate specification.

extracted, not demanded
02 · Coherence
Does it fit the rest of the system?

Detects when a change touches modules it should not, or breaks something another part of the code assumed. The failure no single test catches alone.

the criterion no one else reviews
03 · Quality
Is it well built?

Linters from your own stack, coverage, types, and normalized CI evidence. The technical baseline, verified with your own tools.

your rules, always applied
04 · Security
Is it safe today and tomorrow?

Exposed secrets, dependencies with CVEs, injection patterns. And with the add-on, continuous monitoring after the code has already merged.

before and after the merge
Choose your gate

The same cycle. Two ways in.

Companies

I am a CTO, owner, or product lead

Control, evidence, and verdicts to govern the code agents write — without turning AURA into a surveillance system.

Go to AURA for companies →Developers

I am a developer or freelancer

Runtime free, Spec in early access, and Review that decides for you when the change is right. Without changing your tools.

Go to AURA for developers →
Neutrality commitment

The one who decides does not compete in the game.

Code is increasingly written by machines: Claude, Copilot, Cursor, Codex, open models, models that do not exist yet. Someone has to verify that this code does what was asked, does not break what it should not, is safe, and meets each organization's rules. That verification only holds if the verifier has no stake in the outcome.

  1. We will never build an agent that writes code. We govern everyone's code; we compete with no one.
  2. We support any model and any agent, and let you choose by region, cost, or policy. No favorites.
  3. Every AURA decision is explainable: which criterion failed, which policy applied, what evidence was there.
Read the full manifestoSigned by the founders of AURA AI.
Origin

We built it to survive our own code.

AURA was born inside a next-generation software factory. When our teams started directing agents, code grew eightfold and the CTO was reviewing every Pull Request nearly to the breaking point. There was no tool that governed the full cycle. We built it. Today it is yours.

AURA blocking a Pull Request that does not meet the linked spec

AURA in production: a PR blocked not for a bug, but because it did not meet what spec AURA-20 required.

AURA Hack

AURA Hack: The New Paradigm — 48 hours directing agents.

US$1,000 prize pool, licenses, early access, and credits. Register your team; date and venue are announced to registrants.

  • 01Runtime as the official tool
  • 02Challenges published as specs
  • 03Review verdicts as the jury
  • 04Prizes, licenses, access, and credits
Register my team →I am a university or sponsor
Frequently asked questions

What every CTO asks before connecting their code.

Review is available and can be purchased today. Spec is in early access: it works and you can use it, but still without billing and without Jira integration. Runtime is free on every plan, in invite-only beta. Orchestra is the Pro version of Runtime (flows, missions, roles), included from 2027. QA is under construction, with no date yet. Every module shows its real status across the site.

It works with your Jira. And many teams discover they no longer need it.

AURA doesn't police anyone: it normalizes using AI to build software and helps verify that it turned out right.

Anyone with permission can correct the verdict in one click, and that event is logged. We publish control accuracy in your monthly report: if we are wrong more than 5% of the time in any repository, we treat it as our incident. A decision that is wrong too often is a decision your team ignores — and then it is useless.

No, and it is in the contract. We process the change ephemerally: we do not store your code after the review. We keep findings and metadata for your history. Each organization is isolated with its own GitHub App credentials. On Enterprise you choose the model and region, or bring your own.

Because we do not ask for faith — we give you evidence: which criterion failed, which policy applied, in which file and line, with which CI evidence. And there is a commitment no major competitor can make: we will never build an agent that writes code. The one who decides does not compete in the game.

A seat is anyone who produces code against a connected repository: the developer who opened at least one reviewed Pull Request in the month. Anyone who only plans, coordinates, or approves — a Scrum Master, a Product Owner — does not pay for a seat even if they use the platform every day.

Today AURA works with GitHub. GitLab arrives in Q2 2027 and Bitbucket in Q3. Spec import from Jira is part of Spec GA (end of 2026); bidirectional sync comes later, on Enterprise.

Machines write the code.
You decide if it ships.

Connect your repository and get your first verdict in under ten minutes. No card, no sales call, no change to your workflow.

Start free →View plans

“Whoever decides doesn't compete in the game.” — Our neutrality commitment