A shift from discrete pass/fail grading to continuous probability scoring allows developers to scale verification, unlocking higher accuracy across agentic tasks.

Source note: Jacky Kwok, Shulu Li, Pranav Atreya, Yuejiang Liu, Yixing Jiang, Chelsea Finn, Marco Pavone, Ion Stoica, Azalia Mirhoseini. “LLM-as-a-Verifier: A General-Purpose Verification Framework.” arXiv:2607.05391 (July 6, 2026). Link

Why This Paper Matters

Scaling laws have reliably predicted that adding more data and compute to pre-training and test-time generation improves the capabilities of large language models. However, evaluating the output of these models has not benefited from the same predictable scaling. Traditional large language model judges typically output a single discrete score, such as a binary pass or fail, or a number on a limited five-point scale. This coarse grading often results in ties and fundamentally fails to discriminate between complex, near-perfect solutions produced by advanced autonomous agents.

This paper identifies verification as a possible new scaling axis, distinct from generation. By introducing a framework called LLM-as-a-Verifier, the researchers show that extracting fine-grained probabilities from the scoring tokens of language models can turn verification into a scalable dimension. This probabilistic formulation improves the ability to evaluate agents in complex, multi-step environments ranging from coding to robotics, suggesting verification scaling could become a critical technique for boosting system reliability and unlocking the full potential of large candidate pools.

The Idea in Plain English

When developers ask an artificial intelligence model to act as a judge or evaluator, they usually ask it to pick a discrete number from one to ten, or to choose between correct and incorrect. In practice, under the hood, the AI model generates a probability distribution over many possible tokens. Traditional methods discard this nuanced information by selecting only the single most likely token as the final answer.

The researchers propose a fundamentally different approach. Instead of collapsing the model’s internal beliefs into a single discrete output, they capture the entire distribution of probabilities across the grading scale. If an evaluator model assigns a 60 percent probability to a score of ten, a 30 percent probability to a score of nine, and a 10 percent probability to a score of eight, the framework calculates the mathematical expectation. This results in a continuous score of 9.5.

This continuous scoring allows the system to clearly distinguish between candidate answers that a standard judge would rate as ties. Because the score is now a continuous variable rather than a rigid integer, developers can systematically improve verification accuracy by tuning three independent dials. First, they can increase the granularity of the grading scale, offering the model more tokens to express its judgment. Second, they can average the results of multiple repeated evaluations to smooth out random noise and variance. Third, they can break down the evaluation criteria into simpler, distinct components. The combination of these techniques forms a robust verification system that works across domains without requiring specialized training data.

What the Researchers Tested

The research team evaluated their LLM-as-a-Verifier framework across four distinct benchmarks designed to rigorously test autonomous agents in complex, long-horizon tasks. These benchmarks included coding and terminal environments (Terminal-Bench V2 and SWE-Bench Verified), robotics simulations requiring visual reasoning (RoboRewardBench), and medical decision-making scenarios operating over electronic health records (MedAgentBench).

For each task in these benchmarks, a standard generation policy produced multiple candidate trajectories. The researchers then used an off-the-shelf language model acting as the verifier to score every pair of trajectories using the continuous probability method. They compared this continuous approach against baseline generation models and traditional discrete language model judges.

Evaluating every possible pair in a large pool of candidates scales quadratically, making it prohibitively expensive. To make the process cost-effective, the researchers also tested a novel algorithm called Probabilistic Pivot Tournament. Instead of comparing every candidate against every other candidate, this algorithm uses a quick initial pass to identify a few strong candidates known as pivots. It then compares the rest of the pool only against these pivots to efficiently rank the best solution. Furthermore, the team tested whether the continuous scores could act as a dense reward signal to improve the sample efficiency of both off-policy and on-policy reinforcement learning algorithms in separate robotics and mathematical reasoning tasks.

What They Found

State-of-the-Art Benchmark Improvements

The continuous verification framework established new high-water marks across all four tested domains. By applying LLM-as-a-Verifier to candidate pools generated by standard frontier models, the system achieved 86.5% accuracy on Terminal-Bench V2, outperforming previous specialized systems. On SWE-Bench Verified, a highly challenging software engineering benchmark, it reached 78.2% by successfully selecting the strongest trajectory from a diverse set of candidates generated by different models. In the visual domain, it achieved 87.4% trajectory preference accuracy on RoboRewardBench, outperforming reward models explicitly trained on massive amounts of robotics data. In the specialized medical domain, it secured 73.3% on MedAgentBench.

Scaling Score Granularity

The researchers demonstrated that expanding the number of possible score tokens directly improves the system’s ability to separate correct solutions from incorrect ones. In a detailed case study regarding database query optimization, a standard judge collapsing a five-point scale produced unhelpful ties in 88 out of 100 evaluation runs. Taking the probabilistic expectation over the exact same five-point scale eliminated ties entirely. When the granularity was scaled up further to a twenty-point scale, the signal-to-noise ratio increased again. This finer granularity allowed the model to express hedged, nuanced language as a precise continuous value, resulting in more calibrated comparisons and a direct increase in pairwise verification accuracy.

Repeated Evaluation and Criteria Decomposition

Alongside token granularity, the framework benefited from two other scaling dimensions that address different sources of error. Repeating the evaluation process up to sixteen times and averaging the continuous scores effectively smoothed out the variance and spurious biases of any single evaluation pass. The researchers also found that decomposing a single, monolithic question about correctness into simpler sub-criteria allowed the verifier to capture complementary aspects of quality. For coding tasks, breaking the rubric into specification compliance, output format, and absence of log errors, and then ensembling the results, consistently improved the final verification accuracy over any single criterion.

Efficient Ranking with Probabilistic Pivot Tournaments

Evaluating a large number of candidates usually scales poorly because the number of necessary comparisons grows quadratically. The Probabilistic Pivot Tournament algorithm reduced this verification budget significantly. By using a random cycle to score candidates once and identify top-ranking pivot candidates, and then comparing the remaining pool only against these pivots, the algorithm concentrated the verification budget on differentiating the most uncertain top candidates. This approach achieved comparable accuracy to full round-robin tournaments while cutting the required number of comparisons by a large margin.

Tracking Task Progress and Dense Reinforcement Learning Feedback

Beyond simply ranking final outcomes, the continuous verifier scores proved highly correlated with chronological task progress. In successful trajectories, such as an agent correctly installing compilers and updating parameters, the continuous score rose monotonically step-by-step. Conversely, it remained flat or declined in failed runs, such as an agent exhausting disk space by installing unnecessary packages. This allowed the verifier to serve as a real-time progress monitor. Additionally, these fine-grained signals functioned as dense feedback for reinforcement learning. When used to shape rewards, the verifier improved sample efficiency by a factor of 1.8 on a robotics task using Soft Actor-Critic and by a factor of 1.1 on a mathematical reasoning benchmark using Group Relative Policy Optimization.

Why It Happens

The effectiveness of this continuous approach stems from preserving the uncertainty inherent in the language model’s output layer. When a language model acts as a standard discrete judge, it acts like a teacher forced to assign a rigid letter grade even if the student’s true performance sits precisely on the border between two grades. This forced rounding destroys valuable information.

By calculating the expected value across the entire distribution of grading tokens, the framework projects the model’s internal, nuanced belief into a continuous space. This continuous space naturally resists ties, because two distinct, complex solutions are highly unlikely to produce the exact same probability distribution across twenty different grading tokens. Once the scores are continuous and strictly ordered without ties, averaging multiple independent evaluations becomes a mathematically sound way to reduce Monte Carlo noise. Decomposing criteria further helps because it prevents the evaluator model from latching onto a single salient feature in a complex trajectory and ignoring other critical aspects of the solution.

What This Means for Builders

For developers building autonomous agents, this framework offers a plug-and-play method to improve agent reliability without the need to curate data and train custom reward models. Builders can implement this probabilistic verification layer on top of their existing generation models, leveraging the intelligence of off-the-shelf frontier models.

The ability to tune the verification budget is particularly valuable for engineering teams. Builders can scale up granularity, repetitions, and criteria for high-stakes asynchronous tasks where accuracy is paramount, or dial them down for latency-sensitive applications. Furthermore, the strong correlation between the verifier score and task progress means developers can build sophisticated monitoring dashboards that track long-running agentic jobs. If the continuous score flatlines or begins to drop, the system architecture can be designed to pause execution or roll back the agent before it commits broken code or makes an irreversible error in a live environment.

What This Means for Buyers and Operators

Organizations deploying AI agents have historically struggled to evaluate whether a complex, multi-step agent is actually performing well or wandering off track until the very end of a lengthy task. The introduction of scalable, continuous verification provides a new mechanism for enterprise oversight.

Operators can expect future agentic platforms to include continuous confidence or progress scores as standard features, making it easier to trust the systems deployed in production. This approach also reduces the industry’s reliance on highly specialized, expensive reward models trained for narrow domains. Because the framework generalizes remarkably well across disparate fields such as coding, robotics, and medical tasks, enterprise buyers can evaluate agent platforms based on the robustness of their verification architecture rather than focusing exclusively on their raw generation capabilities.

What to Watch Next

The artificial intelligence field will likely test the extreme limits of verification as a scaling axis over the next few years. While generation scaling laws are well-established and predictable, it remains to be seen if verification scaling exhibits similar predictable returns over vastly larger orders of magnitude, or if it hits a premature ceiling.

Future research will likely explore dynamic compute allocation, where the system automatically increases repeated evaluations only when the verifier’s initial confidence is dangerously low. There is also significant potential in having the model learn optimal criteria decomposition dynamically based on the specific task, rather than relying on hand-designed rubrics. Finally, integrating these continuous verifier rewards into multi-turn reinforcement learning for very long-horizon tasks could unlock entirely new levels of autonomy in complex digital and physical environments.

Limitations and Caveats

This framework relies entirely on using large language models as verifiers, which means it inherits all of their foundational vulnerabilities. It is explicit that this approach does not eliminate judge or model failure; if the underlying verifier model fundamentally misunderstands the physics of a robotics task or the logical architecture of a codebase, continuous scoring will only provide a higher-resolution picture of that flawed understanding.

Additionally, while scaling repeated evaluations and decomposing criteria consistently improves accuracy, it proportionally increases inference costs and system latency. Organizations must carefully manage this budget trade-off. The Probabilistic Pivot Tournament mitigates some of the quadratic ranking costs, but the overall compute burden of verification scaling remains higher than a traditional single discrete pass. Finally, while the benchmark gains demonstrated in the paper are substantial, they require thorough validation in messy, unconstrained production environments where failure modes are often less predictable than in standardized tests.

Source

Jacky Kwok, Shulu Li, Pranav Atreya, Yuejiang Liu, Yixing Jiang, Chelsea Finn, Marco Pavone, Ion Stoica, Azalia Mirhoseini. “LLM-as-a-Verifier: A General-Purpose Verification Framework.” arXiv:2607.05391 (July 6, 2026). https://arxiv.org/abs/2607.05391