LLM-as-a-Verifier

// Overview

LLM-as-a-Verifier is a general-purpose framework for getting fine-grained feedback out of a judge model. The usual LLM-as-a-judge setup asks for a score and reads back whichever token the model sampled, which throws away almost everything the model knew. This project keeps that information: it uses a fine-grained scoring granularity, takes the expectation over the full logprob distribution of the score tokens rather than the argmax, and scales quality by repeating the evaluation and decomposing the rubric into separate criteria.

What comes out is a continuous reward rather than a verdict, which makes it usable in three places at once: test-time scaling (pick the best of N candidate answers or trajectories), progress tracking (watch a long-horizon agent's trajectory score move), and reinforcement learning (use the verifier's output as the reward signal). The API is deliberately small — `select` picks the best candidate given a problem and a criteria dict, and `compare` exposes the raw pairwise rewards underneath it.

The project reports state-of-the-art results across agentic benchmarks including Terminal-Bench, SWE-Bench Verified, MedAgentBench and RoboRewardBench, and documents the method in an accompanying paper. Version 0.2.0 added a prefix-cache optimisation the project measures at roughly 3.4× fewer uncached input tokens on trajectory-heavy benchmarks, a `deepseek-v4-flash` verifier backend, a Terminal-Bench 2.1 self-verification benchmark and token accounting. It runs against a hosted API or any OpenAI-compatible server that returns logprobs, including a local vLLM.

// Getting started

Install the package and point it at a model that returns logprobs — either a hosted key in .env, or a local OpenAI-compatible server.

pip install llm-verifier

# or, from a clone:
pip install -e .

vllm serve Qwen/Qwen3.5-9B
export OPENAI_BASE_URL=http://localhost:8000/v1

import llm_verifier

problem = "Write a function that reverses a string."
candidates = [
    "def rev(s): return s[::-1]", "def rev(s): return s", "def rev(s): return ''.join(sorted(s))",
]

result = llm_verifier.select(
    problem=problem,
    candidates=candidates,
    criteria={"Correctness": "Does the code actually reverse the string?"},
)
print(result.index)   # index of the best candidate: 0
print(result.scores)  # candidate scores: [0.73104, 0.38446, 0.38449]

reward_a, reward_b = llm_verifier.compare(...)

Commands and code are distilled from the project's own documentation — always check the official repo for the latest.

// When to use it

• Reach for it when a binary pass/fail judge is too coarse to rank near-identical agent trajectories
• Reach for it to add test-time scaling: sample N candidate answers and pick the one the verifier scores highest
• Reach for it as the reward model in an RL loop, where a continuous signal trains better than a thresholded one
• Reach for it to track whether a long-horizon agent is actually making progress rather than only whether it finished

// How LLM-as-a-Verifier compares

LLM-as-a-Verifier alongside other open-source evaluation & red-teaming tools AI/TLDR tracks, ranked by GitHub stars.