Verification
for AI agents

Runs your real tests on a copy of your project. If anything breaks, nothing gets written.

Get early accessDocumentation
) works with every agent
Claude Code
Codex
Cursor
GitHub Copilot
Windsurf
Cline
Gemini CLI
OpenCode
Zed
) See it verify[01/07]

Verified before it lands.

A real Claude Code session: it migrates to the SQLAlchemy 2.0 session API, calls Refactron to check its own diff, and merges only on a SAFE verdict.

✻claude code~/services · main
Claude Code v2.1.206
Fable 5 with xhigh effort · Claude Max
~/services
>migrate BalanceService.reconcile to the SQLAlchemy 2.0 session API, land it only if it is provably safe
⏺I'll migrate reconcile to the 2.0 API, then verify the diff in a shadow tree before anything lands.
⏺Update(services/balance.py)
⎿Updated services/balance.py with 5 additions and 4 removals
118-session = Session()
118+with self.session_factory() as session:
124-rows = session.query(Ledger).filter(...)
124+rows = session.execute(select(Ledger)...)
… +4 lines (ctrl+o to expand)
⏺refactron - verify_change (MCP)(diff: working tree)
⎿scoped to blast radius · 23 call sites · 6 files
✓parse diff · 5 symbols mapped
✓coverage preflight · 6/6 changed lines exercised
✓shadow-tree run · 142 passed · 0 failed · 2m 38s
VERDICT:SAFE· signed sha256:9f3c…a10b
⏺SAFE, so I'm landing it. The signed report ships with the commit.
⏺Bash(refactron land --report .refactron/verify-9f3c.json)
⎿landed atomically on green · rollback point saved
⏺Done. reconcile now runs on the 2.0 session API, proven against your real suite before it touched main.
>
⏵⏵ accept edits on (shift+tab to cycle)refactron mcp · connected

The agent calls verify_change over MCP before it lands. The same gate runs in CI or on a migration.

) How verification works[02/07]

Verify a diff Refactron didn't author.

Point it at any change, an agent's, a codemod's, or your own, and it runs the same deterministic gate, scoped to exactly what the change touches.

  1. 01
    PARSE DIFF

    Map the changed symbols: agent, codemod, or human.

  2. 02
    BLAST RADIUS

    Trace the import + call graph to everything affected.

  3. 03
    COVERAGE PREFLIGHT

    Is the changed code actually exercised by a test?

  4. 04
    SHADOW-TREE RUN

    Run the scoped suite in an isolated copy of the repo.

  5. 05
    VERDICT + REPORT

    SAFE · UNSAFE · UNPROVEN, with signed evidence.

verification flowiso · scoped
) The verdict[03/07]

Three answers, and one is honest in a way no one else is.

“Tests pass” can be a lie of omission. This document is exactly what Refactron returns: signed, reproducible, three possible outcomes. When the changed code isn't exercised, we call it UNPROVEN instead of pretending.

refactron verifybalance.py · +5 −4
▸parse diff5 symbols mapped···
▸blast radius23 call sites · 6 files···
▸coverage preflight6/6 changed lines exercised···
▸shadow-tree run142 passed · 0 failed···
SAFEsigned sha256:9f3c…a10b · reproducible
The gate

Every diff runs against your real tests in an isolated shadow tree before it can land. Watch the gates clear, or not.

UNPROVEN2m ago
rates.py · +7 −2tests passed, and that proves nothing here
bycodemodonCI
UNSAFE9m ago
retry.ts · +18 −6blocked before it touched disk
byCursoronlinux
SAFE31m ago
balance.py · +5 −4landed atomically on green
byClaude CodeonmacOS
The verdict feed

SAFE, UNSAFE, or UNPROVEN. Signed and reproducible, streamed to your PR with the agent that authored the change.

) Where it plugs in[04/07]

Wherever the change happens.

The verdict is only useful at the moment of the merge. So we meet it there: as the tool your agent calls, the check that guards your CI, and the gate on your scariest migration.

01·MCP SERVERearly access

The tool your agent calls before it lands

Your agent proposes a diff, calls verify_change, and gets a verdict + report back, so it can decide whether to land.

$ verify_change(diff)
) Wire it in[05/07]

Drop it into your stack.

One gate, every surface: run it from the CLI, gate it in CI, hand it to your agent over MCP, or point it at a migration. Python and TypeScript, today.

1
$ pip install refactron
2
$ refactron verify --diff agent.patch
3
 
4
→ SAFE · 142 passed · 0 failed
5
→ signed report → ".refactron/verify-9f3c.json"
View on GitHubRead the CLI docs
) How we're different[06/07]

Everyone runs tests. We stake a verdict on them.

feature
Correctness guarantee
Verifies an arbitrary diff
Tells you when it's UNPROVEN
Signed, reproducible record
Python + TS, shipping today
the gateRefactron
codemod runners“Review the diff.”
syntax only
AI agents“They generate the change.”
capabilities as shipped today
01/codemod runners

“Review the diff.”

We prove the diff is safe, and flag it when it isn't provable.

02/the AI twin crowd

“Our model says it's correct.”

Your own tests say it's correct. Python and TS, today.

03/coding agents

“They generate the change.”

We're the gate that lets you trust what they merged.

) How the guarantee holds[07/07]

The guarantee holds by construction.

Roughly a quarter of AI-generated codemods introduce silent breakage. Refactron can't ship one: a change lands only after it clears three gates against your real test suite: atomically, in an isolated copy, or not at all. It's slower than a blind rewrite. That's the point.

how a change landsatomic · on green
A verified change landing atomically into a machined socket, proven first in an isolated shadow copy
0%

of AI-generated codemods are wrong: the silent-breakage class we gate (industry estimate)

0

unsafe changes reach disk. A change lands atomically, only on green

0 gates

every diff clears: syntax · imports · your real test suite

0 langs

Python + TypeScript, verified against the suite you already run

See how migration mode gates a real SQLAlchemy 1→2 change
) get early access

Verify your agent's PRs before anyone else.

The MCP server and CI gate are being built in the open. Join as a design partner and shape the trust layer your team will run.

No spam, just the verification layer, early. By joining you agree to our Privacy Policy.

) frequently asked[FAQ]

Questions, answered.

What the verdict means, what leaves your machine, and what ships today versus next.

Still curious? Read the docs

That's the point. Refactron verifies a diff whoever authored it: Cursor, Claude Code, Copilot, Codex, a codemod, or you. Via MCP your agent can call it before it lands (early access).