Who verifies the verifier, and why AI eventually needs a floor it cannot argue with
There is a question in AI right now that a whole research field has walked into from one side, and that we keep meeting from the other. The field is asking whether we can trust a model to judge another model's output. We build systems where the answer to that question decides whether money moves or a regulator is satisfied. So our view comes from load-bearing decisions, not from a benchmark.
Here is the question in one line. When you put an AI answer in front of something that matters, and you want to know the answer is right, what checks it? And then, what checks the thing that checked it?
The pattern everyone reaches for
The standard move is to add a second model. One model writes the answer. A separate model reads the answer against the source material and scores whether the answer is actually grounded in it. This is a good move. It is the right move in a lot of places. The industry calls the scoring model a faithfulness judge, and there is 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, someone asks the obvious question. 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? You are now standing inside a regress, and it does not close on its own.
For a while you could wave this away as a philosophy-seminar objection. As of 2026 you cannot. 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 should stop you: 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. High test-retest stability, above 0.95, sitting on top of severe position bias, in models already deployed 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 are judging. Not the meaning. The formatting. This is not one contrarian paper. RAND released a reliability harness in 2026 and concluded no judge they tested was uniformly reliable across benchmarks. There is a NeurIPS workshop this year with the title "Can We Trust the Judge?" That title is not rhetorical. It is a field admitting it built a tool it cannot fully vouch for.
None of this means judge models are useless. They are genuinely good at what they are good at. It means a judge model cannot 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 does not have an opinion. It is a rule that is either satisfied or it is not. A hash that recomputes to the same value or a different one. A signature that is present or absent. A number that reconciles to zero or does not. A state transition that is permitted by the machine or rejected. There is no bias to audit, no prompt to jailbreak, no formatting trick that flips it, because there is no judgment happening at all.
The important property is not that it is smart. It is that it is honest about failure. A deterministic check can crash. It can refuse to run. What it cannot do is tell you it passed when it did not. 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 is the only thing in the stack that does not need a judge sitting above it, because it is not making a claim you have to trust. It is stating a fact you can recompute yourself.
The real skill is where you draw the line
This is where it gets interesting, and where most of the actual engineering lives. The answer is not to make everything deterministic. You cannot. If a system is summarizing a document or answering a question in prose, there is no rule that says the summary is correct, because correctness there is a matter of degree, not a yes or no. That is exactly the place 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 are 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 have shipped an answer you cannot defend. Force a rigid rule onto something genuinely fuzzy, and you have 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 is not. 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 does not. 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 do not stay local. They compound into the next step and the next. A biased judge feeding an autonomous agent is not a measurement error. It is a decision no one signed off on.
The systems that will be trusted with consequential work are not the ones with the most capable models. They are 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" is not "our best model checked it." It is "here is the rule it had to satisfy, and here is 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.
We build verification systems for regulated environments, where a wrong answer that looks right is worse than no answer at all. If you are putting AI anywhere the output has to be defensible, we would like to know where you have drawn your own line between what gets proven and what gets scored. We have moved ours more than once.
