For builders who work with agents

Everything your agents build
ships with proof.

RootBlocks is the governed rail your coding agents run on. Every merge ships with a signed receipt of the human approval that governed it. Your code stays home. Only receipts travel.

Get early access
Human approval
Approved by a person
a PR approval you already have, or a ratified decision
Agent-built change
Built by an agent
Claude Code, Cursor, Copilot, any repo
Signed receipt
evidence.v1 · ed25519
verifiable offline, by anyone. No trust required.
VERIFIED ✓
The problem

AI already writes the code.
Nobody can prove who authorized it.

4%
of public GitHub commits carry Claude Code's trailer. ~10% by mid-2026 (CoreMention Claude Code tracker estimates).
SemiAnalysis, Feb 2026
41.9%
of PRs merged to master at Ramp in one week, written by its background agent.
Ramp, Head of Applied AI, Jan 2026
>80%
of the code merged into Anthropic's own codebase is written by Claude.
The Anthropic Institute, May 2026

Public repos, a fintech's merged PRs, the frontier lab's own codebase. Different scopes, one direction.

So teams put a human in front of every merge, and give back the speed they bought the agents for. The tradeoff is false: proof can be what the run leaves behind, not a gate in front of it.

ISO 42001 Clause 8 asks for operational control over your AI systems, and the AI section is now standard in enterprise security questionnaires. The evidence has to come from somewhere. Ship at agent speed. Keep the proof.

How it works

Four levels of proof.
One verifiable asset.

Pick a level to see what runs, what you get back, and how much of the chain of custody it closes.

In-flight: a live governed run in the desktop console.

In-flight: a live governed run in the desktop console.

Get your AI exposure report

What percent agents wrote, what merged unreviewed, decision merge grade.

  • Percent agent-authored and the review gap, across every repo.
  • A signed exposure report for the AI section of the security questionnaire.
  • Read-only. Runs in your infra. Your code never leaves.
via rootblocks scan · your terminal

Seven links from business intent to signed receipt. Each level closes more of them.

Compare the plans
rootblocks scan · report
AI inventory · your SDLClast 90 days · 8 repos   Export pack
47%
agent-authored merges
71%
merged without review
0%
traced to a decision
Claude Code61%
Cursor33%
Copilot6%
#471 migrate-db observed no review
#479 refactor-auth observed

Concept preview. Observe: the agent-authorship inventory and the review gap, derived from your git history.

For the technical evaluator

Tech specs

Three planes, one rail. The engine runs where your code lives. Only signed metadata reaches the control plane.

The receipt, annotated

// evidence.v1: a real receipt from our own repo, abridged. { "schemaVersion": "rootblocks.evidence/v1", "evidenceId": "observed-pr-57-d1aea6afcbf1", "operationType": "code.merge", "status": "passed", "assurance": "observed", "actor": { "type": "tool", "id": "rootblocks-scan" }, "checks": [ { "id": "review-gap", "status": "failed", "severity": "error" } ], "provenance": { "pullRequest": "Rootblocks/rootblocks-cloud#57", "review": { "decision": "merged", "reviewer": "anrasi" } }, "redaction": { "status": "not-needed", "rules": [] } } // + a detached ed25519 signature { keyId, value }
Verify a receipt offline, with only the public key: $ npx rootblocks-verify rootblocks-receipt.json --key rootblocks.pub ✓ signature valid · schema evidence.v1 · not tampered

Hand this file to anyone. They do not need us to verify it.

Apache-2.0 The receipt format is an open specification, published at standards.rootblocks.com, and so is the verifier: run it with npx, no account and no signup. Read it, fork it, or write your own from the schema. If we disappeared tomorrow, every receipt you already hold still verifies. Evidence that depends on its vendor staying alive is not evidence.
Read the full evidence spec →Browse the schemas →ISO 42001 · SOC 2 →
Pricing

Scales with your agents,
not your headcount.

Billed by governed run, never per seat. These are launch prices. Reserve them as a design partner.

ObserveFreeGet your AI exposure reportProve$99 /mo per orgGet signed receipts for your codeBuildtrace$199 /mo per orgFull agentic governed factoryEnforcefrom $120k/yrFull protection & enforcement
Compare the plans

Everything your agents build
ships with proof.

Get early access, or book a call. We are onboarding a small number of design partners before launch.

Get early access

Tell us where your agents run. We will reach out with a design-partner slot and reserved launch pricing.

We use your email only to reply about RootBlocks. No lists, no sharing.

Code stays home · receipts travel · never per seat.

FAQ

The honest answers

Is this an AI code reviewer?
No. Reviewers judge whether the code is good. RootBlocks proves what the code was authorized to do, and that it passed your gates. Keep your reviewer; RootBlocks is the layer underneath it.
We already use Vanta or Drata. Isn't this the same thing?
No, and they are complementary, not competitors. Vanta and Drata own the compliance checklist. They cannot collect the AI-governance evidence, because that lives in your git history and your agents. RootBlocks generates the AI-section evidence and feeds it into that workflow.
Can't GitHub just build this?
They can build the gate. They will not build neutrality across competing agents and forges, a self-hosted execution plane where code never leaves, or a portable, decision-linked corpus you own. And the one thing they structurally cannot copy is the decision layer, which lives outside the forge. Their incentive is lock-in; ours is neutrality.
Is the format open, or are we locked into RootBlocks?
Open. evidence.v1 is published as JSON Schema at standards.rootblocks.com under Apache-2.0, and the reference verifier ships on npm under the same license. You can validate receipts, or write your own verifier, without us and without an account. Your evidence outlives your contract with us, by design. What we sell is the rail that produces the receipts, not permission to read them.
Does the EU AI Act or ISO 42001 require evidence for AI-generated code?
The operational driver is ISO 42001 Clause 8 (operational control over AI systems) and SOC 2 CC8.1 (change management). A RootBlocks receipt maps to both. We do not lean on the EU AI Act; the security questionnaire and the ISO clause are the reasons teams act this year.
$99 plus usage: what will my team actually pay?
You pay for governed runs, never for people. At about 10 governed runs per developer per day, a 10-dev team lands around $180/mo on Prove, 50 devs around $800, 200 devs around $3,200. Use the simulator above. Buildtrace adds the console cockpit and traced receipts at a $199/mo starter cap with 5,000 runs included.
Do failed runs still get receipts?
Yes. A failed run also produces evidence: the agent tried X, the gate blocked it, which is exactly what you want for forensics. It counts as a governed run.
Do you see our source code?
No. The engine runs in your infra. rootblocks scan is read-only and runs locally; code contents are never stored. Receipts (hashes, signatures, metadata) are the only thing designed to leave, and they sync to our cloud once the control plane is enabled for your org.
Is there a desktop app, or is it all cloud?
Both. The desktop console (macOS today; Windows and Linux next) is the operator cockpit, offline-first, next to your files and local daemon. The web console is the shared dashboard. Agents run local; receipts will sync to the control plane once it is enabled for your org (rolling out with design partners).