Mutation testing
This is just mutation testing.”
They give youEvery mutant run, hours later
CScale 1 gives youYour likely misses, proven in a few runs
Your tests pass. Bugs still get through.
Your agents write the code and the tests. Both can miss the same mistake. Commitscale tries changes on a separate copy, reruns the tests, and sends weak spots back to the agent to fix.
Powered by CScale 1, our own model, trained to check tests.
Works with
Check passed
- totals: exact amount checked
- search: empty page tested
- login: edge cases tested
Back to the agent
- billing: limit case missing
- auth: timeout test skipped
The tests pass. The mistake stays.
You can't read every line your agents write. You rely on passing tests to help you decide what ships. But a test can pass without checking the thing that matters. The green check hides the gap. Your users find the bug.
More code than you can check
Agents keep opening pull requests. You still have to decide which changes are ready, and the review queue keeps growing.
A weaker test still passes
An exact answer becomes 'greater than zero'. A failing test gets skipped. The checks go green, but they now miss mistakes they used to catch.
Running a line isn't checking it
A test can run the new code without checking its result. Remove the change or try a small mistake on a copy, and every test may still pass.
The same blind spot, twice
The agent that misunderstood the task may write tests for that same misunderstanding. Passing its own tests doesn't tell you what it missed.
Why not just use what you already have?
Each answer starts with CScale 1, our model trained on results from running real tests.
AI review
I’ll have another AI review it.”
They give youAn opinion from reading the code
CScale 1 gives youA prediction from real test runs, then proved
Coverage
My coverage is already high.”
They give youLines that ran
CScale 1 gives youMistakes your tests would miss
CI
CI already runs my tests.”
They give youGreen
CScale 1 gives youTests that fail without the change
Be stricter where mistakes hurt
A help page and a payments change don't need the same treatment. Choose the rules for each part of your code. Commitscale applies them locally and in your CI, and records accepted findings so you can see who accepted them and why.
↓ Try it: pick a level for any part of the code
Docs
docs/**, **/*.md
Findings are recorded. They do not block the change.
Tests
tests/**
Findings block. Anything the agent accepts is flagged for you.
Application code
everything else (defaults)
Findings block until the agent fixes or accepts them.
Login and auth
src/auth/**
Findings block. Anything the agent accepts is flagged for you.
Infrastructure
infra/**
Findings block. With a passkey, only you can accept one.
Gaps hold changes in 4 of 5 areas, and 3 of them get every check.
.commitscale/policy.yamlversion 1
version: 1
defaults:
autonomy: 2
scopes:
- name: docs
match: { paths: ["docs/**", "**/*.md"] }
autonomy: 3
- name: tests
match: { paths: ["tests/**"] }
autonomy: 1
- name: auth
match: { paths: ["src/auth/**"] }
autonomy: 1
- name: infra
match: { paths: ["infra/**"] }
autonomy: 0
Stricter where it matters
Use Guarded or Manual for sensitive code. These settings run stricter test checks and flag findings an agent accepts.
Accepted findings stay visible
An agent can accept a finding with a recorded reason. Turn on passkey approval if you want a person to make that decision.
A change can't loosen its own rules
The check uses the rules already on your target branch. It also flags edits to the rules. Your code host still decides what can merge.
How much of your week goes on review?
If you choose to review fewer changes, how much time could that free up? Try your own numbers. This is an estimate based on your choices, not measured time saved by the check.
Start from
11 hours a week
In this example, about 5.7 working days a month.
You'd still review 18 changes a week in this example. You decide what still needs a person's review.
Meet CScale 1. Make sense of what tests miss.
A test may miss a harmless rename or a real mistake. CScale 1 helps tell the difference. Our own model answers specific questions from the check. It uses excerpts and clears them after processing.
CScale 1illustrative example
function canPay(sum, cap) { - return sum <= cap; + return sum < cap; } Tests: still pass. They cover 90 and 110. The cap is 100. CScale 1: the result changes. 100 is now rejected. Missing test: canPay(100, 100) Expected: true
Trained to check tests
Trained on changes and test runs in 21 languages. It helps identify test files, weakened tests and changes that affect behaviour.
Uncertain findings stay open
When the model's answer is uncertain, the finding stays visible. Its answer and confidence are recorded beside the test result.
Only excerpts leave
Only the code a question needs is sent, with detected secrets removed. Our hosting partner clears requests within five minutes. Sharing on Free is optional and off by default.
Find the weak spot while the agent can fix it
Example · agents/codex/limits
Allow charges up to the limit
-
1
The change’s tests passPassed
At a limit of 100, the tests allow 90 and reject 110.
-
2
Commitscale tries a mistakeMissed
<=becomes<on a separate copy. The tests still pass. -
3
CScale 1 identifies the changeFinding
An amount of exactly 100 is now rejected at a limit of 100.
-
4
The agent adds the missing testCaught
It checks that 100 is allowed at a limit of 100. A rerun now catches the tried mistake.
One missed case found, then checked by a test. This is an illustrative example.
Your agents write the tests. Commitscale checks them.
See what the tests actually catch. Commitscale checks for weakened tests and tries changes on a copy. Each finding shows what was tried and what happened.
Check reportillustrative output
$ cscale tests check Finding: a weaker test tests/invoice.test.js - assert(total === 1005); + assert(total > 0); Before: only 1005 passes. After: 1000 passes too. A wrong total can now pass. Next: restore the exact check, then fix the code if it fails. The agent gets the finding before the push leaves the machine.
from the diff
Weakened tests
Tests that were deleted, skipped or changed to accept a less precise answer.
on your machine
Independent tests
Check whether new tests fail without the change, and whether existing tests still pass with it.
on your machine
Changed lines covered
With coverage enabled, see changed lines that no test ran.
on your machine
Small mistakes caught
Try mistakes on a separate copy and see which the tests catch. CScale 1 helps set aside harmless edits.
Catch it locally. Check it again in your CI.
An agent can skip a local hook. Run the same check in protected CI and require it before merging. Commitscale signs the result for that commit, so you can verify what was checked.
~/appsetup example
$ cscale init --ci 1. Add the check to your CI. The command writes the job. 2. Add the CI secret: CSCALE_CHECK_KEY Keep it away from agents. 3. Require the check. Set this on your code host. Protect its job and rules. Your host requires the result. Commitscale runs the check.
Out of the agent's reach
Use protected CI settings and a key only CI holds. Follow the setup instructions for your code host to keep the check outside the agent's control.
Signed for that exact commit
The result goes onto the commit as a signed note. Change the code, and the signature no longer matches.
One more job
Commitscale generates the job in your CI's format. Configure its protections, make it required, and keep your other jobs as they are.
Commitscale is built with Commitscale
Hi, I'm John, the founder of Commitscale.
I don't read most of the code my agents write.
I run several agents most days, and they write more than I can keep up with.
So I let their work go in when the tests pass, and keep the parts where a mistake would really hurt for myself.
That made me nervous. I wanted to know what those passing tests were missing.
So I took an agent's change that had passed its tests and deliberately introduced a few mistakes. The tests caught some, but others went unnoticed.
I was trusting the code because of tests written by the same agent. Both could miss the same thing.
So we built the check I wanted. It tries small mistakes on a separate copy of the code and runs the tests again to see whether they notice.
Some edits that tests miss are harmless. We trained CScale 1 to help tell those apart from mistakes a test should catch. Its answer appears beside the test result.
It works where you already are: your agents, your code host, your CI. And it checks ours first.
I still decide what needs my attention. Now I can see specific weaknesses in the tests and send them back to the agent.
If this sounds familiar, try it on your agent's next change. The first 100 checks each month are free. And if you've stopped reading your agents' pull requests too, I'd love to hear how you're handling it.
John JoubertFounder and CEO
- Changes merged
- 395
- Merged without a person
- 310
- Agent accounts that pushed
- 40
From Commitscale's own record, up to 20 October.
Built for small teams that ship with agents
Built for
- Engineers and small teams that ship code written by agents
- Agents such as Claude Code or Codex, on your machines or in the cloud
- Any language, with tests that run on every change
- Any Git host, and the CI you already run
Not for (yet)
- Code without runnable tests: the check needs tests to measure what they catch
- Teams looking for a replacement for all human judgment
- Hosting it yourself: the check's model runs on commitscale.com for now
It fits what you have
git push
Any coding agent
On your machine, the hook checks it before it pushes. In the cloud, your CI checks what it pushes. Agents can also run the check over MCP.
cscale init --ci
Your existing CI
Generate the job in your CI's format, configure its protections, and require it before merging.
git clone
Plain Git
No new version control to learn, for people or agents.
your Git host
Your host stays
The check runs where your code already is. Nothing moves, and there's nothing new to host.
Questions you might be asking
Something else? Ask me directly at support@commitscale.com. I read every one.
General
Does Commitscale merge for me?
Your code host still handles merging. Commitscale checks the tests and records the result. You choose which checks and reviews your host requires.
What leaves my machine?
Only excerpts needed for the model's questions. Detected secrets are removed first; your full repository is not uploaded. Add --show-requests to see each request.
Do you keep my code?
Not after processing, unless you choose to share it. Our hosting partner clears requests within five minutes and does not log their contents or use them for training. We keep IDs, hashes and scores. Sharing on Free is optional, off by default, and can be stopped.
What if the check gets it wrong?
The agent can accept a finding, with a reason. The acceptance is recorded with the result, so you can see it later. If you'd rather decide yourself, turn on the passkey layer, and only you can accept.
Can my agent just skip it?
Your agent can skip a local hook. Configure a protected CI job and require it before merging. The generated setup instructions explain what your code host needs.
Do I need an account?
Yes, every check needs a free account. Your agent can start one from the terminal, and you confirm it from your email.
What happens after 100 checks?
The check keeps running. It still finds and blocks gaps on your machine. Only CScale 1's questions stop, until the month resets or you upgrade. See pricing.
Does a passing check prove the code is correct?
No. It shows what the tests caught in the checks that ran. It can reveal weakened tests and missed mistakes, but it cannot prove every behaviour is correct. You still decide what needs review.
Which agents and languages does it work with?
Commitscale works with agents that run the CLI or its MCP tool and any language you can run tests in. Cloud agents' changes can be checked in your CI. Setup and test selection vary by test runner.
Can we host it ourselves?
Not yet. At launch, the check's model runs on commitscale.com.
Common concerns
Won't another check slow my agent down?
On the projects we've tested, a check took 18 to 99 seconds. Where a test run would take too long, CScale 1 answers in under a second, and the report says it was judged.
Why trust a small model?
CScale 1 is trained for one job, on results from running real tests. A new version ships only if it beats the current one on projects it never saw, with nothing getting worse.
Will it say pass when it didn't really check?
No. A check that couldn't finish says it's incomplete and exits 2. A judged answer is always marked as judged.
Will it flag harmless edits?
Comment-only and documentation-only edits are left out. CScale 1 separates real gaps from changes that do nothing, and your agent can accept a finding with a reason.
Will it work with my project's setup?
It uses the install your project already documents. If it can't build a fair comparison, it says the check is incomplete and what to do.
Is a judged answer as good as a test run?
No, and the report says which is which. CScale 1 judges only when a run would take too long.
Do I have to change how I work?
No. One command adds a local hook, and the same check runs in your CI, with any Git host and agent.
Isn't this what property-based testing or fuzzing does?
They hunt for inputs that break your code. Commitscale and CScale 1 check whether your tests would notice the code breaking. They work well together.
Find out what your tests miss
Start with one repository and your agent's next change. Sign up and install the CLI. The first 100 checks each month are free.
curl -fsSL https://commitscale.com/cli/install.sh | sh
On Windows, install in WSL with the macOS and Linux command.
curl -fsSL https://commitscale.com/cli/install.sh | sh
Native Windows, not yet validated
irm https://commitscale.com/cli/install.ps1 | iex
Then, in your repository:
cscale init
Ask your agent to check its next committed change. Agents can sign up from the terminal instead, with cscale signup.