AI made writing code cheap. Proving it works is the new bottleneck.

Green CI isn't proof.

Catch the bugs that slip past a green build before your customers do.

A passing build only tells you that nothing your tests check has broken. It does not tell you whether any test would fail if the code an AI agent just changed were wrong. OrangePro checks exactly that, independently of the agent that wrote the code, and leaves the proof in your repo.

The engine is MIT licensed and runs on your machine. No account, and your source is not uploaded.

  • MIT-licensed engine, runs on your machine
  • Any model provider, your own key
  • Tests and receipts stay in your repo
  • Works with Claude Code, Cursor, Codex and Copilot
See what a green build misses, on a real report

See what you're missing

Your build can be green while the code that changed has no test behind it.

Nothing fails, so nothing looks wrong. Here is why that happens, and what it looks like on a real codebase.

  • A test that never touches the change still passes.

    CI reports what your existing tests checked. If no test calls the function a pull request changed, the build stays green and says nothing about it.

  • Coverage counts lines that ran, not bugs that would be caught.

    A line can run during a test whose assertions would not notice a wrong result. High coverage and an unprotected change can sit side by side.

  • Agents now write the tests that grade their own code.

    A test written from the new code tends to confirm what the code does, not what it should do. The check that matters has to come from outside the tool that wrote it.

local engine · risk map

Real engine run · documenso/documenso

The ten riskiest functions in the public code.

TypeScript · 15,652 GitHub stars · read in 32.9 seconds

Functions mapped

758

With test evidence

13

  1. 1. getEmailContext()

    high

    packages/lib/server-only/email/get-email-context.ts

    27 places use it · 126 lines changed recently · no test found that calls it.

  2. 2. getEnvelopeWhereInput()

    high

    packages/lib/server-only/envelope/get-envelope-by-id.ts

    34 places use it · no test found that calls it.

  3. 3. syncStripeCustomerSubscription()

    high

    packages/ee/server-only/stripe/sync-stripe-customer-subscription.ts

    2 places use it · 297 lines changed recently · no test found that calls it.

+ 7 more ranked rows in the full report

Real OrangePro engine run (v0.2.59) on the public documenso/documenso repository, measured 4 November 2026. Not a customer. “With test evidence” means an existing test names or calls the function, not that the test is good. The engine ranked 500 of 758 rows in this build.

Two steps, two kinds of answer

The free local engine maps your code and ranks the functions with the least test behind them. The map alone runs no test. An evaluation goes further, after merge and before release: it breaks the changed behavior on purpose and keeps a test only if it passes on your code and fails on the broken copy.

The new bottleneck

The bottleneck moved from writing code to trusting it.

25×

more CI jobs in six months at Anthropic, as its engineers shipped far more code.

More tests run than ever. A green build tells you the tests you have passed. It cannot tell you what they missed.

Source: Anthropic, September 14, 2026

Industry context, not an OrangePro result.

Friday · CI

Tests passed

  • Unit testspassed
  • Integration testspassed
  • Build and lintpassed

Merged and shipped.

Saturday · Customer call

What wasn't tested?

  • The payment retry flow changed in this pull request.
  • No test fails if a retry charges twice.
  • A customer finds it first.
Green build Friday. Customer call Saturday.

For the person who signs off on the release

A green build is not a sign-off. Release on evidence.

  • Escaped bugs

    The customer should not be your test suite.

    When a green build ships a broken checkout or a double charge, the cost is churn, credits and a weekend incident. The question is not whether tests passed. It is whether any test would have failed.

  • Release speed

    Agents write faster than people can review.

    Coding agents also write the tests that grade their own work. A separate check, outside the tool that wrote the code, lets you ship faster without taking that on trust.

  • Auditability

    Show what was checked, not just that it passed.

    For healthcare, fintech and other high-stakes teams, every check is saved against the exact commit: what was tested, what caught a fault, and what still needs a person.

How OrangePro proves it

Green CI shows what passed. OrangePro shows what's protected.

Three things, in plain terms. Each one ends in something your team can read, rerun and keep.

  1. 01

    Proof your tests catch a real fault

    For each risky function a change touched, OrangePro breaks that behavior in an isolated copy and reruns your tests. A test counts only if it passes on your code and fails on the broken copy. Coverage percentages cannot tell you that.

    receipt · applyRefund()

    • Your code, unchangedpass
    • Same code, behavior broken on purposefail

    Test caught the fault. Counted.

    A name match or a test that never fails is not counted.

  2. 02

    Checks the combined release, after merge

    Pull requests are reviewed one at a time. Bugs hide where two merged changes meet. OrangePro looks at what changed together before you release, without adding another gate to every pull request.

    PR 1 · shorter payment timeout green

    PR 2 · new order-state code green

    both merged into the release build

    Retry after timeout runs through the new code. No test covers it.

    Illustrative. Each PR passed on its own.

  3. 03

    Runs on your machine, with your model

    The engine is MIT licensed and runs in your environment. The local scan never uploads your source code. If you want tests drafted, you pick the model provider and use your own key. No lock-in to one AI vendor.

    $ npx @orangepro/mcp-server start .

    scan: runs on this machine

    source upload: none

    model: none needed for the map

    test drafting: optional, your provider and key

    MIT license. Read every line on GitHub.

What lands in your repo: a test-only patch you own.

New tests for the gaps, a pass and fail receipt for each, and the run logs. No product code is changed. Nothing is merged for you. They are plain tests in your own framework, so the proof keeps working when you change models or coding agents.

Open an example evaluation report (synthetic app)(opens in a new tab)
Read the engine on GitHub

Watch the walkthrough

The whole flow in 33 seconds.

Many merged pull requests, one release decision. Captions available. The checkout example is illustrative.

Voice-over: The PRs keep coming, but your team still has to know: will these changes work together? After merge, before release, OrangePro maps the combined changes to critical workflows and prioritizes the risk. Where test coverage is missing, it adds a test and runs that test against a simulated failure in an isolated build. Your team gets a reviewable test patch and an auditable record of what was checked, what passed, and what still needs attention. Less manual verification, better-informed release decisions.

Today: we run it with your team, starting with one PRNext: automatic runs on release builds, in evaluation with design partners
See the real report

Where it fits

Keep your review bot and your QA agent. Add the question a green build skips.

OrangePro does not replace CI, code review or end-to-end testing. It adds one answer before you ship.

AI code reviewWhen: Before merge, one pull requestAsks: “Does this diff look right?”You get: Comments on the change
App-level QA agentsWhen: On previews and pull requestsAsks: “Does the user flow still work here?”You get: End-to-end runs, some with merge blocking
Coverage reportsWhen: Every CI runAsks: “Which lines ran during tests?”You get: A percentage
OrangeProWhen: After merge, before releaseAsks: “Would our tests fail if the changed behavior broke?”You get: A test-only patch with a pass and fail receipt for each test

Categories describe common tools, not every product in them. Some QA tools also reproduce fixes at the app level. OrangePro works at the unit-test level, inside your repo.

The bigger picture

Models and agents will keep changing. Your proof should stay.

AI made writing code cheap. Knowing a change is safe to ship is still expensive, and it grows with every agent you add. OrangePro is a layer of proof between the code your agents write and the release you ship: after merge, before release, separate from the tools that wrote the code, and kept in your own repo.

  • Independent of the agent that wrote the code

    The tool that wrote a change should not be the one that grades it. OrangePro checks the change from outside the coding agent, against behavior broken on purpose.

  • Owned by you, in your repo

    Every test, receipt and run log is a file in your repository, tied to the exact commit it checked. It stays with you when tools, vendors or contracts change.

  • Works with any model, now and later

    The map needs no model. Test drafting uses the provider and key you choose. The engine is MIT licensed, so the proof does not depend on one AI vendor.

Start

Find the missing test before your customer finds the bug.

Two ways in, depending on who you are.

If you write the code

Free, available now

See your weakest-tested code

Run the open-source engine on your own machine. No account, no card, and your source is not uploaded.

$npx -y @orangepro/mcp-server@latest start .

Run this from your repository root.

No account or model key is needed for the map.

If you sign off on releases

Today, with our team

Evaluate one real pull request

We measure hands-on time, review effort and added runner time on your own change, and leave you a record you can show an auditor.

You bring
One repository, one real pull request, your test command.
You get
A test patch to review and a record of what was checked.
Time
A 30-minute first call to scope it.
Cost
First call free. Any fee agreed before work starts.

Next, we are building automatic runs on the combined release build, with history on the Platform. In evaluation with design partners, not generally available.

What engineering leaders noticed

Teams that care what their tests actually protect.

Teams and leaders we have worked with

Entalpa
CISCO
BELCORP
RESPONSIBLESOLUTIONS

Local adoption

“One npx command and the engine was running on our own machine. No signup, and our code never left the building. What came back was a short list of risky functions, and new tests only counted once they failed on a deliberately broken copy.”

Tamaz Khunjua

CEO, Entalpa

Product perspective

“A green build only tells you the tests you have passed. OrangePro showed us which changed functions no test would catch if they broke, and gave us tests we could keep in our own repo.”

Adnan Ashraf

Director of Product Management, Cisco

Engineering perspective

“Even with high code coverage, gaps slipped through. OrangePro checks whether a test actually fails when the behavior is broken on purpose. That is the question coverage never answered for us.”

Ram K.

Engineering Director, Belcorp

Independent evaluation

“We compared OrangePro with tools we already use. It did not replace them. It added a check after merge that our tests catch real faults, with a receipt for each test that we could show the team.”

Russell Brand

Managing Director, Responsible Solutions

Questions engineers and leaders ask

Before you bring us a pull request