Your AI reviewer blocked the same PR twice. Deterministic judges fix that.
Somewhere in your CI, a reviewer agent approves a pull request one day and blocks it the next. Same diff, same rules, same model. Nobody can reproduce the block, so a human re-reviews by hand and the whole "automation" exists to add a second queue to wait in.
I run into this story a lot when I benchmark AI code review tools, and it's almost never the reviewer model's fault. It's the judge.
The verdict is the problem, not the model
Most code-review agents are LLMs that read a diff and write a verdict in natural language, including a self-reported confidence figure. To actually gate on that verdict, the harness has to parse the prose back into a number. That gives you two places for the verdict to move between runs: the model can change its mind, and the parser can change what it extracts from the text.
An AI reviewer that "blocks" a PR once and passes it the next run is a flaky test. You'd never ship a unit test that passed one day and failed the next on identical input. But we ship LLM judges in the CI critical path that do exactly that, because nothing forces the judge to be deterministic in the first place. The model's temperature may be nonzero, or the same prompt can route to a different deployment, or the confidence phrase lands on a token the parser didn't expect. Any one of those flips your gate, and none of them had anything to do with the diff.
Independent benchmark: typed decision model vs LLM judges
An independent benchmark released last week puts hard numbers on the gap. Jevals benchmarks TypeSafe's Jev, described as the first "System One" decision model, against six LLM judges (Gemini 3.8 Flash, GLM-5.3, DeepSeek V4.1 Flash, Qwen3.8 Flash, Mistral Medium 3.5, Mercury 2.5) on 31,500 human-labelled yes/no, pick-one, and rubric decisions. The data is public on GitHub under CC-BY-4.0, with the per-decision logs and boards. The measured spend for the whole suite was $15.07.
The headline isn't the accuracy, it's the mechanism. Every model ran on the same 300 items five times each, per the changelog. The LLM judges report confidence by "verbalizing" it as prose that the harness parses back. Jev doesn't write a sentence at all: it returns typed probabilities, one dense pass, nothing to parse. Identical input maps to identical output. That determinism is exactly the fix for a double-blocking reviewer.
The numbers are what you'd want from a gate. On a yes/no task (PubMedQA), Jev scored 69.0 on the 0-100 decision scale and was statistically tied with the best LLM at 73.0, while costing 1/28 of the price. The evaluation literally hands you the control-flow shape: if (p_yes > 0.9) approve().
Why the verbose judge is the flaky one
An agent that writes "This looks safe, confidence 0.94" in prose makes two claims at once: a factual one about the code, and a self-report about its own certainty. To act on the verdict, the harness has to trust the second claim. Run it twice and either the model hedges differently or the parser lands on a slightly different token, and your gate flips from green to red with no diff in between.
A typed decision model collapses both claims into a single artifact, a probability you can threshold. You get reproducibility from a gate, which is the property you actually care about when the gate is running unattended on every PR. The value here is not "the deterministic model is smarter," it's that the deterministic model is a decision function, and decision functions are testable.
The honest limit: rubrics still break everyone
The same data shows the typed-decider advantage does not survive fuzzy scoring. On HelpSteer2 helpfulness, a five-level rubric, no model clearly beats guessing: Jev 9.2, best LLM 7.8, one model at negative 5.5.
That's the narrow version of the lesson. Deterministic beats verbose specifically when you can express the decision as a clean yes/no or pick-one, where a typed probability maps directly onto a threshold. When the task is an open-ended rubric, determinism stops being the discriminator, because nobody is reproducible there yet. The decider model buys you stability and cost on the decisions you can turn into gates, and nothing on the ones you can't. Pick your gate accordingly.
Audit your current judge before you replace it
You don't have to wait for the vendor to add a deterministic mode. You can find out today whether your review gate is a source of flaky blocks. Run this on any AI reviewer you currently rely on:
Take the last two PRs it evaluated, one it approved and one it blocked. Run both through the reviewer ten times on identical input, model and harness config pinned, and record the verdict each time.
Count how many of the ten runs agree on each PR. A deterministic judge returns ten identical verdicts on the same diff. An LLM judge that flips even once on either PR is a source of noise in your gate, and that noise is what produces the unreproducible block.
Then look at how the tool turns a verdict into a number. If the confidence is parsed out of prose, treat the parse as a separate moving part and account for it. If the tool returns a typed score you can threshold yourself, you have something reproducible to build the gate on.
What this means for your review pipeline
Pin down what a valid verdict looks like before you pick a judge, because the judge choice no longer rides on raw accuracy alone.
If your rule is expressible as a threshold on a typed probability, a deterministic decider is cheaper and won't wobble run to run. That's the case for unattended automation in CI.
If your rule is a fuzzy quality judgment, say so loudly, because no current approach is reproducible there. Whatever tool you choose should come with a note that its verdict needs a human.
Keep a human gate on anything that touches authorization or credentials. A judge's confidence is the one thing you can't verify, and it's exactly what you'd be trusting on the highest-risk lines.
The postmortem
Your mystery block is probably not the model being smart or dumb. It's that you asked a text generator to act like a decision function, and measured it twice. The data released this week shows a cheaper, deterministic alternative exists for the decisions you can make go/no-go, and that the flaky-prose approach is a self-inflicted reproducibility bug on every gate that can't be reproduced.
