AURA SPEC · MULTI-AGENTIC ERA · BETA IN OCTOBER

Every paradigm for the new agentic era.

AURA Spec and the full platform govern the software lifecycle in the multi-agentic AI era: from idea to merge, with explainable verdicts and evidence. Early access in October.

Request early access →See the full cycle

October beta · First verdict in minutes · No card required

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

Who decides does not compete in the game.

+1,200
PRs reviewed in production
66 h
of review time saved / month
+48
fixes applied before merge
Oct
beta · early access
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 · October

AURA Spec

Write the idea in natural language, by voice, or with a document. AURA Spec turns it into a dual specification for humans and agents. Early access in October.

Spec →
02 · EXECUTEFree in October · 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 multi-agentic artificial intelligence era

  • 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. Go deeper into the new paradigm →

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 in October.

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 in October with early access. Many projects at once? Orchestra organizes them by mission and role. Included in Pro from 2027.

Results

The time you recover shows up every sprint.

Clear review-time savings: +1,200 PRs, 66 hours a month, and +48 fixes before merge.

0
PRs
reviewed in production
estimate
0
review hours saved per month
On a real team already governing its cycle with AURA.
0
fixes before merge
Findings applied in time, without reopening the cycle.

How much time does your team get back?

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

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

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

Time calculator

How much development time you recover with AURA.

Tune team size and PR pace. The result is review hours and days recovered every month.

Based on the typical time of a comparable human review.

Your team recovers, every month

98review hours
12.3workdays (8 h)
280governed PRs
Reserve early access →

Directional estimate. Real savings depend on diff size and your thresholds.

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

AURA Spec early access in October, Runtime free in October, and Review that decides when the change is right.

Go to AURA for developers →
The line that defines us

The one who decides does not compete in the game.

In the multi-agentic era, code is written by Claude, Copilot, Cursor, Codex, and models that do not exist yet. Someone has to verify it does what was asked, does not break the rest, and is safe. 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. On Enterprise you choose provider and region. No favorites.
  3. Every AURA decision is explainable: which criterion failed, which policy applied, what evidence was there.

This is how the new agentic era is governed.

Origin

The new paradigm of agentic development — with purpose.

AURA was born inside a next-generation software factory. When our teams started directing agents, code grew eightfold and the impact of AI no longer fit inside human reviews. 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.

Frequently asked questions

What every CTO asks before connecting their code.

Review is available today. AURA Spec opens early access in October. Runtime is free in October, invite-only beta. Orchestra is the Pro layer of Runtime from 2027. QA is under construction. Every module shows its real status on 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.

Per organization. You pay the monthly plan total; people are a seat cap. Usage is measured in credits shared across the whole team. Someone who only plans or approves still counts toward the seat cap, but there is no separate per-seat charge.

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.

Request early access →View plans