Published July 12, 2026 · Updated July 13, 2026
RedMirror On-Prem is a self-hosted bug-finder that turns any coding agent into one whose findings are proofs, not opinions. The agent proposes a suspected bug; a compiled kernel independently verifies it and hands back a reproduction. Because the kernel, not the model, decides, it works with any LLM, and a weak model cannot flood you with false positives.
It is here. The self-hosted edition, where you bring your own model and everything stays on your machine, now ships as RedMirror Reflection: one binary, your model, your machine. First month free. Get started below.
The whole design rests on one claim: the kernel, not the model, is what makes a finding trustworthy. That is what lets it work with any model, and it is why a weak model cannot flood you with false positives. To show that isn’t just a slogan, we ran four different LLMs through the exact same harness and let the compiler grade every answer. No self-grading, no vibes.
Correct verdicts out of 25 (−1 for a false alarm on clean code)
The grey bar is the deterministic floor: RedMirror’s lifter and corpus with no model at all.
Claude Sonnet finished first with 23 of 25 correct verdicts. The surprise was second place: Gemma 4, a 31-billion-parameter open model, reached 17, and the no-model floor scored 11 in three seconds, ahead of the largest model in the test.
How many of the 4 models solved each bug shape (hardest at top)
Red bars are the two real-world files. Shorter is harder.
One shape defeated the entire field. The asymmetric-sibling bug, where one of two writer paths silently skips the admin check its twin enforces, was found by no model, and not by the deterministic floor either. The two real-world files were next hardest.
Average wall-clock per target (seconds; lower is faster)
Local CLI vs remote gateway differ in network latency, so read speed as directional.
Gemma was the fastest model, about 33 seconds per target. The local CLI and the remote gateway carry different overhead, so read these as directional rather than a clean model-to-model comparison.
Correct verdicts: synthetic suite vs real-world files (share of each set)
Two of the targets are not synthetic at all: they are real files pulled straight from a live open-source project (kept anonymous), one a rate-limiter and one a scoped-read query path. Synthetic skill does not automatically transfer to messy production code, and that is exactly where the field tends to separate.
Only Claude Sonnet cleared both real files. The three open models found neither, a reminder that skill on tidy synthetic targets does not automatically carry over to production code.
Every buggy shape, every model (✓ found · – missed)
| Model | underflow | cap | off-by-1 | rl-reset | conserv | no-authz | sibling | self-appr | idor | verify-act | lifecycle | real rl | real read |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Claude Sonnet | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | – | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |
| Gemma 4 (31B) | ✓ | ✓ | ✓ | – | ✓ | ✓ | – | ✓ | ✓ | ✓ | – | – | – |
| GLM-5.2 | ✓ | ✓ | ✓ | ✓ | – | – | – | ✓ | ✓ | – | ✓ | – | – |
| RedMirror floor | ✓ | – | – | – | – | – | – | – | – | – | – | – | – |
| gpt-oss-120b | – | – | – | – | – | – | – | – | ✓ | ✓ | – | – | – |
Claude Sonnet led at 23 of 25, its single miss the asymmetric-sibling bug that defeated everyone. A 31-billion-parameter open model, Gemma 4, took second at 17 and ran fastest of the field, while a 120-billion-parameter model came last at 5 and was the only model to raise a false alarm, doing so twice. The deterministic floor, with no model at all, scored 11 in three seconds and outranked that larger model. The real result, though, was precision: just two false alarms in a hundred runs, because a compiled kernel signs off on a finding, not the model. One honest caveat: this is a single trial on a small, harness-specific suite, and the gateway models varied a lot in speed, so treat it as directional rather than a universal ranking.
Each target is a small program with a known verdict: it either hides a specific bug, or it is provably clean. The model reads the code and reports what it finds. What makes the exam fair is that RedMirror independently checks every answer against the ground truth instead of taking the model at its word:
The suite spans eleven bug families, from integer underflow and unbounded accumulation to missing authorization, broken object-level access, self-approval, and verify-then-act. Each has a buggy and a clean variant, in JavaScript and Python, plus the two real-world files. The hard shapes cannot be pattern-matched; the model has to build a faithful model of the attack, and that is exactly where the field separated.
The benchmark is really a stress test of one design choice: the kernel is the gate. It is why precision holds even with weak models in the mix, and why you can run a cheap open model, or your own local weights, and still trust a finding, because a compiler signed off on it, not the model. In practice that means the structural half of the audit costs zero tokens, a weak proposer cannot drown you in noise, and the whole thing runs as a single binary on your own machine, so your code and your model never leave it.
RedMirror On-Prem is a self-hosted, bring-your-own-model bug-finder that turns any coding agent into one whose findings are proofs, not opinions. The agent proposes a suspected bug; a compiled kernel independently verifies it and returns a reproduction. It runs as a single binary on your own machine, so your code and your model never leave it.
Because the kernel, not the model, decides. A finding counts only when RedMirror independently confirms the reported bug is real and reachable, with a reproduction to back it. A weak model can propose noise, but it cannot get an unverified claim past the compiler, so precision does not depend on the model's confidence.
Any of them. RedMirror is model-agnostic and agent-agnostic: it works with hosted models like Claude, open models run through a gateway, or your own local weights, and it is driven by whatever coding agent you already use, such as Claude Code, Cursor, or Pi.
The hosted API at redmirror.io is public and pay-as-you-go today. The self-hosted On-Prem edition, which brings your own model and keeps everything on your machine, is in private preview. You can request access from this page and we onboard by hand.
We ran four LLMs through one shared harness on a suite of small programs with known verdicts, plus real files from a live open-source project. A compiled kernel graded every answer against ground truth, so the benchmark measures both recall across bug families and precision, meaning how often a model raises a false alarm on clean code.
No waitlist any more. The bring-your-own-model, runs-entirely-on-your-machine edition ships today as a single binary. First month free, then $4.99/month, cancel any time.
Install the binary, point it at your code and your own model (local or cloud), and your coding agent finds real bugs and proves each one.
Get started · 7-day free trial