Raw capture ā raw/llm-as-a-verifier.md
url: https://arxiv.org/pdf/2607.05391 title: "LLM-as-a-Verifier: A General-Purpose Verification Framework" author: Jacky Kwok, Shulu Li, Pranav Atreya, Yuejiang Liu, Yixing Jiang, Chelsea Finn, Marco Pavone, Ion Stoica, Azalia Mirhoseini date_fetched: 2026-07-18 date_published: 2026-07
Jacky Kwok, Shulu Li, Pranav Atreya, Yuejiang Liu, Yixing Jiang, Chelsea Finn, Marco Pavone, Ion Stoica, Azalia Mirhoseini
Stanford University, UC Berkeley, NVIDIA Research
arXiv: 2607.05391v2
License: CC BY 4.0
Verification is a new scaling axis for improving LLMs. This paper presents LLM-as-a-Verifier, a general-purpose verification framework that provides fine-grained feedback for agentic tasks without requiring additional training. Unlike standard LM judges that produce discrete scores, it computes the expectation over the distribution of scoring token logits for continuous scores. The approach scales along three dimensions: score granularity (better separation between positive and negative solutions), repeated evaluation (variance reduction), and criteria decomposition (complexity reduction). They introduce a cost-efficient ranking algorithm, Probabilistic Pivot Tournament (PPT), for selecting the best candidate solution using continuous scores.
Standard LM judges collapse scoring distributions into coarse discrete scores, producing ties and poor discrimination. Learned reward models are constrained by training data and fail to generalize across domains. When repeatedly sampled with an oracle verifier, models achieve 98.9% on Terminal-Bench V2 ā meaning most models already can solve tasks, but lack a verifier reliable enough to select correct trajectories from incorrect ones. Standard judges produce a 27% tie rate on this benchmark.
Instead of taking the highest-probability discrete score token, the framework computes the expectation over the distribution of scoring token logits to produce continuous scores:
R(x,Ļ) = (1/CK) Ī£_c Ī£_k Ī£_g p_Īø(v_g|x,c,Ļ) Ā· Ļ(v_g)
Where C = number of evaluation criteria, K = repeated evaluations, G = score token granularity.
These continuous rewards are converted into pairwise preferences via a Bradley-Terry model:
P(Ļ_i ā» Ļ_j | x) = 1 / (1 + exp(-(R(x,Ļ_i) - R(x,Ļ_j))))
1. Score Granularity (G): Enlarging the ordered token set from 1 to 20 gives the decoder a finer space to project internal beliefs. SNR increases from 0.775 at G=1 to 0.799 at G=20 on Terminal-Bench. This reduces tie rates and improves calibration.
2. Repeated Evaluation (K): Averaging K independent evaluations acts as a Monte Carlo estimator whose variance shrinks as O(1/K). Accuracy rises from 74.7% at K=1 to 77.5% at K=16. A single-pass verifier (K=1) already matches a heavily ensembled judge (K=16).
3. Criteria Decomposition (C): A single monolithic rubric is replaced with an ensemble of sub-criteria. For code agents: Specification, Output, and Errors. Any single criterion achieves 75.2ā76.4% accuracy; the ensemble reaches 78.3%.
A cost-efficient ranking algorithm reducing budget from O(NĀ²) to O(Nk):
The candidate with the highest count-normalized win score is returned.
The verifier's continuous score correlates strongly with chronological task progress (Value-Order Correlation ā Spearman rank correlation between step index and verifier score):
A concrete example: the successful MNIST inference trajectory's verifier scores rise monotonically through steps (Read model.py ā Install g++ ā Install CPU-only torch ā Update hidden_dim ā DONE), while the failed trajectory that unnecessarily installs torchvision and exhausts disk space receives consistently low scores.
A drop-in extension for Claude Code and OpenAI-API compatible clients. Operates as an inference-time proxy sitting between client and LLM provider, dispatching N parallel candidate trajectories and selecting the best via PPT. Also provides a web-based interface for visualizing verifier outputs and real-time agent progress monitoring.
Verification accuracy consistently improves along all three dimensions simultaneously, rising from 73.1% at baseline when all three are combined. The axes are complementary: granularity sharpens individual estimators, repeated evaluation averages out noise, and criteria decomposition reduces prompt bias.
On query-optimize case study over 100 repeated evaluations: - Discrete judge (G=5): 12/100 correct rankings, 88/100 ties, 0/100 wrong - Continuous verifier (G=5): 69/100 correct, 0 ties, 31/100 wrong - Continuous verifier (G=20): 77/100 correct, 0 ties, 23/100 wrong
The verifier eliminates ties entirely and substantially improves discrimination.
For models like GPT-5.5 and Claude Opus 4.7 that don't expose logprobs, a two-stage pipeline: closed model emits free-form reasoning, then an open verifier (Gemini 2.5 Flash) reads logprobs from scoring tokens. Recovers +5.2-point accuracy gain over discrete scoring at K=1 and eliminates the 10.9% tie rate.
On 20-candidate pools (89 Terminal-Bench V2 tasks): - PPT with k=3 surpasses V1 baseline (66.17% accuracy with 4,723 pairs) - PPT with k=9 reaches 67.13% with 9,630 pairs, approaching full round-robin (67.42% with 13,111 pairs) at ~73% of the budget
Situated at intersection of: Test-Time Scaling, LLM-as-a-Judge, and Verifiable Reward. Differs from trained reward models (PRMs, ORMs, robotic reward models) by being training-free and general-purpose.
Verification is an underexplored scaling axis. LLM-as-a-Verifier delivers fine-grained feedback via logit expectation, enabling scaling across granularity, repeated evaluation, and criteria decomposition. SOTA across coding, robotics, and medical domains. Beyond ranking, the signal serves as a task progress estimator and dense reward for RL, improving sample efficiency in both SAC and GRPO settings. The framework is training-free, plug-and-play, and applied identically across all domains without per-domain fine-tuning.