LLM-as-a-Verifier: A General-Purpose Verification Framework

Technical Breakdown§

Core Methodology§

LLM-as-a-Verifier reframes verification as a probabilistic scoring problem. Instead of prompting an LLM to output a discrete score (e.g., "correct" vs. "incorrect"), the verifier computes the expected value of a score token's logit distribution. Given a solution $x$ and a prompt template $p$, let the model's output distribution over the next token be $P(\text{token}|p,x)$. Typically, a set of scoring tokens $S = \{s_1, s_2, \dots, s_k\}$ (e.g., tokens for 0–9) is defined, and the continuous score is:

$$\text{score}(x) = \sum_{t \in S} \text{value}(t) \cdot P(\text{token}=t|p,x)$$

where $\text{value}(t)$ maps the token to a numerical value (e.g., token "5" → 5). This expectation yields a fine-grained continuous score, unlike discrete classification.

Scaling Dimensions§

1. Score Granularity: Using more scoring tokens (e.g., 0–9 instead of binary) improves separation between good and bad solutions. The finer granularity reduces quantization error.

1. Repeated Evaluation: Multiple queries to the verifier (with different random seeds or prompt variants) reduce variance. The final score is the mean of $N$ evaluations:

$$\text{score}_{final}(x) = \frac{1}{N}\sum_{i=1}^N \text{score}_i(x)$$

1. Criteria Decomposition: Breaking the verification criteria into sub-criteria (e.g., correctness, efficiency, safety) and summing their scores reduces complexity and improves calibration.

Cost-Efficient Ranking§

To select the best solution among $M$ candidates, the verifier's continuous scores allow a ranking algorithm that avoids pairwise comparisons. The algorithm:

• Compute scores for all candidates.
• Sort candidates by score.
• Optionally, perform a top-k high-fidelity verification for tie-breaking.

Implementation Details§

A minimal PyTorch snippet for computing the expected score from logits:

import torch

# tokenizer: mapping from tokens to values (e.g., '0'->0, '1'->1, ...)
scoring_token_ids = [5, 11, 15, ...]  # e.g., tokens for '0','1',...,'9'
scoring_values = torch.tensor([0,1,2,3,4,5,6,7,8,9])

def compute_expected_score(logits, token_ids, values):
    # logits: shape (batch, vocab_size)
    probs = torch.softmax(logits, dim=-1)  # (batch, vocab_size)
    # select probabilities for scoring tokens
    scoring_probs = probs[:, token_ids]  # (batch, num_scoring_tokens)
    # normalize over scoring tokens (they sum to 1 if only those tokens are considered)
    # In practice, the prompt constrains the output to those tokens.
    scoring_probs = scoring_probs / scoring_probs.sum(dim=-1, keepdim=True)
    expected_score = (scoring_probs * values.unsqueeze(0)).sum(dim=-1)
    return expected_score

Key Results§

• Terminal-Bench V2: 86.5% accuracy
• SWE-Bench Verified: 78.2% accuracy
• RoboRewardBench: 87.4% accuracy
• MedAgentBench: 73.3% accuracy

These results surpass prior methods that use discrete judges or reward models.

Connection to RL§

The fine-grained scores serve as dense rewards for reinforcement learning. For example, in robotic manipulation tasks (using SAC) and math reasoning (using GRPO), the verifier's continuous signal improves sample efficiency compared to binary rewards.