We keep running into the same question, and we've never seen it answered cleanly: when you put an AI answer in front of something that actually matters, what checks that the answer is right? And then, what checks the thing that checked it?
We build verification systems for regulated environments, so this isn't a thought experiment. The answer decides whether money moves or a regulator walks away happy. Here is where we've landed, and we want to know if you've landed somewhere different.
The pattern everyone reaches for
The standard move is to add a second model. One model writes the answer. A separate model reads that answer against the source material and scores whether it's actually grounded. This is a good move. It's the right move in a lot of places. The industry calls the scoring model a faithfulness judge, and there's real research showing it agrees with human reviewers most of the time.
Most of the time is the whole problem.
The moment you decide a judge model is trustworthy, the obvious question shows up. The judge is also a model. It has its own failure modes. So do you need a judge for the judge? And a judge for that one? Now you're standing inside a regress, and it does not close on its own.
For a while you could wave this off as a philosophy-seminar objection. As of 2026 you can't. The evidence is in.
The floor the field is discovering it needs
The largest systematic study of judge models to date, by Norman, Rivera and Hughes, looked at twenty-one judges from nine providers across roughly 541,000 individual judgments (arXiv:2606.19544, 2026). The finding that stopped us: a judge can be highly self-consistent and severely biased at the same time. It gives you the same verdict every time you ask, which feels like reliability, while that verdict is skewed in a way the consistency completely hides. Test-retest stability above 0.95, sitting on top of severe position bias, in models already in production. They call it the consistency-bias paradox.
It gets more concrete. On harder bias tests, frontier judges have crossed fifty percent error rates, and judges that pass a standard accuracy check can be flipped by changing the formatting of the thing they're judging. Not the meaning. The formatting. This isn't one contrarian paper. RAND put out a reliability harness in 2026 and concluded no judge they tested was uniformly reliable across benchmarks. There's a NeurIPS workshop this year titled "Can We Trust the Judge?" That title isn't rhetorical. It's a field admitting it built a tool it can't fully vouch for.
None of this makes judge models useless. They're genuinely good at what they're good at. It means a judge model can't be the bottom of the stack. Something has to be.
What actually stops the regress
The regress stops the instant one layer in the stack is not a model.
A deterministic check doesn't have an opinion. It's a rule that is either satisfied or it isn't. A hash that recomputes to the same value or a different one. A signature that's present or absent. A number that reconciles to zero or doesn't. A state transition the machine permits or rejects. There's no bias to audit, no prompt to jailbreak, no formatting trick that flips it, because there's no judgment happening at all.
The important property isn't that it's smart. It's that it's honest about failure. A deterministic check can crash. It can refuse to run. What it can't do is tell you it passed when it didn't. A crash is loud and you go fix it. A false pass is silent and it ends up in front of a regulator. If you have to choose which failure your system is allowed to have, you choose the loud one every time.
So the deterministic check is the floor. It's the only thing in the stack that doesn't need a judge sitting above it, because it isn't making a claim you have to trust. It's stating a fact you can recompute yourself.
The real skill is where you draw the line
This is where most of the actual engineering lives. The answer isn't to make everything deterministic. You can't. If a system is summarizing a document or answering in prose, there's no rule that says the summary is correct, because correctness there is a matter of degree, not a yes or no. That's exactly where a judge model belongs. Faithfulness genuinely is a spectrum, and a model scoring it from zero to one is measuring the right thing.
The skill is knowing which is which. Some outputs have a true-or-false answer and must never be scored, because a confidence number on a binary fact is just doubt wearing a lab coat. Other outputs are genuinely shades of grey and must be scored, because pretending they're binary is its own kind of lie.
Draw that line in the wrong place and you get one of two failures. Put a probabilistic judge in charge of something that had to be provable, and you've shipped an answer you can't defend. Force a rigid rule onto something genuinely fuzzy, and you've thrown away the thing AI was good for.
Everyone can call a model. Almost no one designs where the model's judgment is allowed to be the final word and where it isn't. That boundary is the product. The regress is what happens when you forget to draw it and just keep stacking judges, hoping depth substitutes for a floor. It doesn't. Depth without a floor is just a taller thing with nothing under it.
Why this only gets more urgent
Agentic systems make this sharper, not softer. An agent that takes actions, moves money, files a record, changes a state, is a generator whose output has consequences before a human ever reads it. The judge-model literature already shows that when judges sit inside a pipeline, their errors don't stay local. They compound into the next step and the next. A biased judge feeding an autonomous agent isn't a measurement error. It's a decision no one signed off on.
The systems that get trusted with consequential work won't be the ones with the most capable models. They'll be the ones that know exactly where their deterministic floor is, and can show it to you. When something goes wrong, and it will, the only defensible answer to "how do you know this was right" isn't "our best model checked it." It's "here's the rule it had to satisfy, and here's the proof it did."
Build the floor first. Then you can put as much intelligence on top of it as you like, because you finally have something honest holding it up.
So here's what we actually want to ask you: if you've put AI anywhere the output has to be defensible, where did you draw the line between what gets proven and what gets scored? And what made that line hard to draw? We've had to redraw ours more than once.
Top comments (0)