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.
$npx -y @orangepro/mcp-server@latest start .Run this from your repository root.
No account or model key is needed for the map.
$npx -y @orangepro/mcp-server@latest agent --client claude-codeThis prints the MCP configuration and setup steps for Claude Code.
- 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 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.
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. getEmailContext()
highpackages/lib/server-only/email/get-email-context.ts
27 places use it · 126 lines changed recently · no test found that calls it.
2. getEnvelopeWhereInput()
highpackages/lib/server-only/envelope/get-envelope-by-id.ts
34 places use it · no test found that calls it.
3. syncStripeCustomerSubscription()
highpackages/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
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.
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, 2026Industry 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.
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.
- 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.
- 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.
- 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)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.
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.
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 nowSee 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.
$npx -y @orangepro/mcp-server@latest agent --client claude-codeThis prints the MCP configuration and setup steps for Claude Code.
If you sign off on releases
Today, with our teamEvaluate 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
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
No. It finds risky workflows with missing or weak test evidence and drafts a focused test only there. Each new test is run against a small simulated failure. If it does not fail there, it is not added to the record.
OrangePro is built for after merge, before release, and it is not a merge or release gate. Today, a hands-on evaluation starts with one real pull request. We are also designing a run on the combined integration or staging build. OrangePro does not resolve merge conflicts or replace your CI.
Coverage shows which code ran. Test selection picks which tests to run. OrangePro ranks important workflows with missing or weak test evidence, drafts a focused test, and checks that this new test fails when that workflow is deliberately broken.
Use them together. AI review comments on a diff before merge. App-level QA agents run user flows on previews, and some reproduce fixes or block merges. OrangePro works at the unit-test level in your repo, after merge and before release: it checks whether your existing tests fail when changed behavior is broken, and drafts a test-only patch where none do.
The analysis runs locally. Optional test generation sends selected context to the model provider you choose, using your key.
No. The map and the risk ranking run without a model. If you generate tests, only the context for the selected risky behaviors goes to your model.
It reports the result as unknown, names the blocker, and gives the manual next step. It never calls an unchecked change low risk.
The pull-request check starts with JavaScript. Our first demo runs on a JavaScript repository, and full JavaScript support is still in progress. The free local map covers more languages.
One repository, one real pull request and your existing test command. We assess validation effort, useful test protection and execution cost on that change, and return a test patch with a record of what was checked. The first call takes 30 minutes and is free. Pilot pricing is on request, fixed and agreed before work starts.
We do not promise that. Checking a test means running it again, so it adds some runner time. What we aim to reduce today is engineering effort: the time spent validating and reviewing changes. Each evaluation reports the added runner time.