HumanEval-Java mutation score
77.9%vanilla LLM prompt→89.5%mutation-guided
MutGen's mutation-guided pipeline produced tests with stronger fault-detection capability than vanilla prompting.
MutGen studyPrivate betaMutation testing for AI-speed development
Prove your tests catch what AI gets wrong.
Radforge tests human- and AI-written changes in your diff by making small, controlled mutations—flipping conditions, changing return values, and moving boundaries—then runs the relevant tests. If the tests still pass, Radforge shows you the exact behavior they failed to protect.
Active subscription required • Managed remote execution • Go • TypeScript/JavaScript • Python
$ rad changed --since-ref origin/main
planning changed sources…
3 source files selectedfocused
2 generated files ignored.radignore
survivedsrc/billing/entitlement.ts:84
- return subscription.status === "active"
+ return trueYour tests pass when inactive subscriptions are granted access.
42 tested38 killed4 survived
Evidence, not another vanity metric.
Verify your tests, not just your code
- Mutate changed behavior
- Select relevant tests
- Report surviving changes
- Run on every pull request
01 / The gap
Coverage tells you what ran. It doesn’t tell you whether your tests protect the behavior you actually care about.
You can reach 100% line and branch coverage while asserting nothing about the behavior that matters. A test may execute every path and still pass when a condition flips, a boundary shifts, or the wrong value is returned.
Radforge deliberately makes those changes and checks whether your tests notice. It creates temporary mutations in an isolated copy—such as changing > to >=, true to false, or a returned value—then observes whether the existing tests fail. A killed mutation means the tests detected it. A surviving mutation pinpoints an assertion or case that is missing.
Mutation testing has historically been too slow and compute-intensive for routine use. Radforge turns it from an occasional audit into a pre-merge feedback loop—fast and reliable enough to run on every pull request, even alongside multiple coding agents.
02 / AI changes the equation
AI can generate coverage. You still need evidence.
AI-generated tests can look plausible, pass, and cover the happy path while weak assertions miss the behavior they execute. Mutation testing asks the harder question: would those tests detect a deliberate fault?
Across 22,374 test-generation tasks
More than 99%
of tests that failed against semantic changes still passed against the original behavior—evidence of semantic anchoring.
Software evolution studyMeta production trial
73%
Meta privacy engineers accepted the generated tests across thousands of mutants and hundreds of tests on Facebook, Instagram, WhatsApp, and wearables.
Meta ACH field trialWhat coverage misses
Boundary blindness
In the MutGen example, the model tested day 0 and values above the boundary, but missed day 1—the exact case needed to catch < becoming <=.
What generated tests repeat
Semantic anchoring
A test can stay aligned with familiar or original behavior instead of the code's changed semantics. Passing and coverage do not reveal that mismatch.
How the loop closes
Survivor becomes targeted feedback
Radforge names the changed condition, return, or boundary. Give that survivor to the developer or agent, add the missing test, and rerun until the mutation dies.
Radforge turns uncertainty about AI-written tests into a concrete answer: the exact behavior they fail to protect, and a clear target for the next test.
03 / How it works
From diff to evidence.
A focused loop that explains both the simulated mistake and the test gap that allowed it to survive.
- 01
Find the changed behavior
Radforge reads the diff, identifies useful mutation candidates in source your team maintains, and maps them to relevant tests. Generated files are skipped.
- 02
Create temporary mutations
In an isolated workspace, it flips conditions, changes return values, and moves boundaries to simulate realistic mistakes without modifying your working tree.
- 03
Run tests and report gaps
Relevant tests run against each mutation. A failure kills it. A passing suite leaves a survivor that identifies the exact behavior your tests do not protect.
04 / Why Radforge
Why not just run Stryker or mutmut directly?
Stryker and mutmut are strong mutation engines. Radforge adds an expert execution layer shaped by published academic research, our own research and innovations, and repeated use across real repositories and both small and large diffs. The result is mutation testing engineered for continuous use—on every pull request or on demand.
Built by the biggest teams. Now available to yours.
Radforge
Proprietary engine. Managed infrastructure. Evidence before merge.
- 01
Fast enough for every pull request
Radforge’s proprietary engine is designed to return focused, actionable mutation evidence before merge—not hours later.
- 02
Built for parallel coding agents
Run mutation analysis while multiple agents, builds, and test suites keep working. Radforge supplies the compute instead of consuming developer machines.
- 03
Automatic across the team
Protect every eligible pull request automatically or launch a run from the CLI. Shared hosted results accelerate repeated work across branches and teammates.
Managed execution included
Radforge operates the infrastructure, isolation, scheduling, and caching. Your team gets results—not another mutation platform to maintain.Fast enough to run before merge.
Run mutation tests on Radforge infrastructure and get actionable results substantially faster than running a general-purpose mutation engine yourself.Selected benchmark evidence
faster on a realistic pull-request change
Under 40 seconds instead of over 6 minutes · caught both seeded bugs
less time on a real-world build-tool change
42.8s vs 77.5s · found every test gap in the baseline
less time on a larger application change
148.5s vs 275.4s · found all 149 baseline test gaps
Selected, scenario-specific open-source replays against Stryker on the same code and test slices. Cold means Radforge result caches were bypassed.
05 / One workflow
One subscription. Multiple ways to run.
Every Radforge run requires an active subscription and executes on managed infrastructure. Start it from the CLI or a pull request without changing the planner, evidence, or entitlement model.
CLI-initiatedrad changed
Use the CLI to plan locally from your working tree, staging area, or branch. Radforge executes the focused mutation run remotely on managed infrastructure.
GitHub-initiatedPull request
Trigger managed remote execution with Checks feedback, durable history, organization controls, and shared findings.
06 / Private beta
A serious pilot, without enterprise theater.
We will configure Radforge with your repositories, tune the signal, and work directly with your team on the evidence that changes how you test.
Founder-led onboarding. We help tune scope, runtime, and findings to your repositories.
Team
$30per seat / month
Billed monthly in USD through Paddle. Cancel anytime.
- Up to 1,000 seats
- 2 concurrent hosted runs
- Active subscription required for CLI and GitHub runs
- Managed remote execution for every mutation run
- Founder-led setup and support
- No automated overage charges
We will confirm fit and scope before sending a subscription link.
07 / Questions
Before you hand us a pull request.
Is this another coverage dashboard?
No. Coverage shows that a line executed. Radforge changes that line's behavior and checks whether the tests notice. The result is evidence about test effectiveness, not test activity.
Does Radforge replace my test runner?
No. It works with your existing tests and test runner. Radforge plans the useful mutations, selects the relevant tests, executes the work, and reports what survived.
Where does mutation execution run?
Every mutation run executes remotely on Radforge infrastructure. Planning and dry-run inspection stay local, but the customer CLI never runs mutation tests on your machine. CLI- and GitHub-initiated runs use the same planner, entitlement model, and managed execution backend.
Does Radforge mutate generated code?
No. Radforge skips generated files as mutation targets, so it does not create findings in code you do not maintain. Your application and tests can still import and run that generated code normally.
Which languages are supported?
Radforge supports Go, TypeScript/JavaScript, and Python repositories. Mutation runs use the same hosted infrastructure and produce the same evidence and reporting model across languages.
Why a design-partner program?
Mutation testing touches real build and test systems. Founder-led onboarding lets us tune scope, runtime, and reporting with your team before opening fully self-serve access.
Your tests cover the change.
Prove they fail when the code is wrong.
Bring one Go, TypeScript/JavaScript, or Python repository. We will help you run the first focused mutation analysis.