What is LLM-as-a-Verifier?

LLM-as-a-Verifier (arXiv 2607.05391) is a method that scores an agent's candidate solution by reading the verifier model's full probability distribution over its scoring tokens and taking the weighted average, producing a continuous score instead of a single discrete label. The paper frames verification — deciding whether a solution is correct — as a new axis you can scale, and reports state-of-the-art results including 86.5% on Terminal-Bench V2 and 78.2% on SWE-Bench Verified.

Why does reading the score distribution beat a single label?

A single label — pass/fail or one sampled number — throws away how confident the model was, so two solutions that both land on the same label are tied and can't be ranked. Taking the expectation over the scoring-token logits keeps those small confidence differences, turning the score into a continuous number that separates near-ties and calibrates better. Crucially, it reuses the distribution from the verifier's existing forward pass rather than adding another model call.

How does this relate to RLVR and agent training?

In Reinforcement Learning with Verifiable Rewards, the verifier's score is the reward. A discrete pass/fail is a sparse reward — most rollouts get the same value, so there's little gradient to learn from. A continuous verifier score is a dense reward: every rollout carries a usable, fine-grained signal, and repeated evaluation plus criteria decomposition sharpen it further, which is why the paper calls verification a scaling axis for agent feedback.

LLM-as-a-Verifier scales agent feedback with logit-score expectations — Verification as a scaling axis

Jargon

Verifier: The model or check that scores whether a candidate solution is correct. Its score is what selects the best attempt and, in training, becomes the reward — so the whole pipeline is only as good as the verifier.
Logits: The raw, pre-softmax scores a model assigns to every possible next token. A softmax turns them into a probability for each token; the shape of that distribution is how confident the model is.
Scoring-token logits: The logits over just the tokens that stand for a score — the digits of a scale, or yes/no. Their distribution says how much the model believes each possible score, not just its top pick.
Expectation (weighted average): Each possible score times its probability, all summed. It collapses a distribution over scores into one continuous number — the core move in this paper.
Discrete vs continuous score: Discrete = one label out of a few (pass/fail, an integer). Continuous = a real number that can sit between the labels, so two answers that tie on a discrete score can still be ranked.
Calibration: Whether a model's stated confidence matches how often it is actually right. A continuous score preserves the confidence a hard label discards, which makes ranking and thresholding more reliable.
Criteria decomposition: Splitting one hard judgment into several simpler sub-judgments (correctness, safety, formatting…), each scored on its own and then combined — easier to get right than one all-or-nothing verdict.
RLVR / dense reward: Reinforcement Learning with Verifiable Rewards. A continuous verifier score gives a dense (fine-grained) reward instead of a sparse pass/fail, so every rollout carries usable gradient. Full explainer →

The news. On July 6, 2026, researchers posted LLM-as-a-Verifier to arXiv, arguing that verification — the ability to determine whether a solution is correct — is a new axis you can scale. Instead of asking a judge model for a discrete label, they compute an expectation over the scoring-token logits to get a continuous score, then scale three knobs: score granularity, repeated evaluation, and criteria decomposition. They report 86.5% on Terminal-Bench V2 and 78.2% on SWE-Bench Verified, plus strong results on RoboRewardBench and MedAgentBench and an extension for Claude Code. Read the paper →

Picture an Olympic diving judge. The old way, the judge watches a dive and holds up one card: a 7. It's a clean verdict, but it hides everything the judge was unsure about — and when the next diver also gets a 7, the two are tied and the scoreboard can't separate them. Now imagine the judge instead reveals their whole spread of confidence — how likely they thought each score was — and you take the weighted average. One dive lands a hair above the other, and the tie breaks. That shift, from a single card to the weighted average of the judge's whole spread, is exactly what LLM-as-a-Verifier does to an AI verifier. The judge is the verifier model, the single card is a discrete label, the spread is the model's scoring-token logits, and the weighted average is a continuous score fine enough to rank near-ties.

Drop the metaphor and the mechanism is precise. You prompt a verifier model with the scoring criteria and ask it for a score. Normally you take the single token it samples or its top pick — one label, exactly like the pass/fail signal most evals stop at. LLM-as-a-Verifier instead keeps the model's full probability distribution over the scoring tokens and computes its expectation — each possible score times its probability, summed into one continuous number. Because that number preserves small differences in probability mass, it ranks and calibrates better than a hard label, and it reuses the logit distribution the verifier already produces — no extra model, no second scoring pass.

The deeper claim is that this makes verification a scaling axis, not a fixed component. Once your score is continuous, three cheap knobs each buy more verification signal without ever touching the agent — the same way you'd scale a diving panel by using finer cards, polling more judges, and scoring each element of the dive on its own:

Scaling knob	What it does	Why it helps
Score granularity	reads a finer scale from the logit distribution	preserves gaps a coarse label rounds away, so near-ties separate
Repeated evaluation	scores the same solution several times and averages	cuts the variance in any single noisy judgment
Criteria decomposition	splits one hard verdict into simpler sub-scores	each sub-decision is easier and less gameable than an all-or-nothing call

Here is the granularity knob made concrete (illustrative numbers; the paper's benchmark figures are below). Two agent solutions, A and B, both get a top pick of 7 on a ten-point scale — a discrete tie. But their distributions differ. A puts probability {6: 0.10, 7: 0.55, 8: 0.30, 9: 0.05}, so its expectation is 6(0.10) + 7(0.55) + 8(0.30) + 9(0.05) = 7.30. B puts {6: 0.30, 7: 0.50, 8: 0.18, 9: 0.02}, so its expectation is 6(0.30) + 7(0.50) + 8(0.18) + 9(0.02) = 6.92. The discrete label calls it a tie at 7; the continuous score says A (7.30) clearly beats B (6.92) — a ranking the old label simply couldn't express, recovered from probabilities the model already produced. In production terms, that sharper score is what teams increasingly grade live agents and feed back as a dense training reward.

On real benchmarks the paper reports the continuous verifier reaching 86.5% on Terminal-Bench V2 and 78.2% on SWE-Bench Verified, alongside 87.4% on RoboRewardBench and 73.3% on MedAgentBench (paper). The point isn't any single number — it's that the same lever, a richer score, keeps paying off across very different agentic domains.

Goes deeper in: AI Agents → Evals & Diagnostics → Pass/Fail vs Score

Related explainers

The Verification Horizon — Co-evolving verifiers — the companion argument: verification is now the bottleneck, and a fixed verifier saturates as the agent improves
MaxProof — defense-in-depth generative verifier — a verifier model up close, hardened so a strong solver can't fool it
Reasoning Arena — Bradley-Terry trace ranking — what to do when a binary verifiable reward ties: rank the traces instead of scoring them pass/fail
CoPD — Reinforcement Learning with Verifiable Rewards (RLVR) — the training regime a continuous verifier feeds a dense reward into

Frequently Asked Questions

Check what you knowMap your AI & GPU knowledge across every track — free, role-based