Verifier Model

A verifier model is a model whose job is to judge the output of another model rather than to produce the answer itself. In a generator-verifier setup, a generator proposes one or more candidate answers — often by sampling several reasoning paths — and the verifier scores them so the best can be selected or weak ones rejected. Verifiers are central to making LLM reasoning more reliable, because generating an answer and checking an answer are genuinely different skills, and a good checker can rescue a generator that is right only some of the time.

Why checking beats generating

The asymmetry is the whole trick. Producing a correct multi-step solution requires every step to be right; recognizing whether a finished solution holds together is often an easier problem. This mirrors a deep pattern across computing — verifying a proposed solution is frequently cheaper than finding one. Practically, it means you can pair a modest generator with a competent verifier and get accuracy neither achieves alone: sample eight candidate answers, score them all, keep the winner. The verifier does not need to know how to solve the problem, only how to tell a sound answer from a confident-sounding wrong one, which is precisely the failure mode language models are notorious for. The two roles can even be played by the same base model wearing different prompts, though dedicated trained verifiers judge more reliably than a model grading its own homework.

Outcome verifiers versus process verifiers

Verifiers come in two main forms. An outcome verifier, or outcome reward model, judges only the final answer: is the end result correct. A process verifier, or process reward model, scores each intermediate reasoning step, which gives much finer-grained feedback but requires costly step-level supervision data to train. OpenAI's "Let's Verify Step by Step" work found that process supervision can significantly outperform outcome supervision on hard math problems, because it catches a flawed step before it poisons everything downstream. There is also a spectrum of verifier strength: for domains with mechanical ground truth — code that must compile and pass tests, arithmetic that must check out — the "verifier" can be an actual tool rather than a learned model, and tool-based verification is both free of training cost and immune to being sweet-talked by fluent nonsense.

Where verifiers fit in a reasoning stack

Verifiers are the scoring engine behind best-of-N sampling and search-based reasoning: they are how extra test-time compute gets converted into accuracy instead of just more samples. They also supply the evaluation signal that self-correcting loops depend on — Reflexion-style agents need a reliable judge before their reflections mean anything. And during training, the same verifier can act as a reward model, filtering or ranking generated data so the next model version learns from vetted examples rather than raw samples.

The self-hosted angle

For a sovereign AI stack running on your own hardware, a dedicated verifier — even a small one — is often the most cost-effective accuracy upgrade available. Big frontier models buy reliability with sheer scale; a homelab buys it with architecture. Let a cheap local generator produce several candidates and let a compact verifier pick the winner: the total compute is a few small forward passes, the accuracy gain can rival a much larger single model, and everything stays on machines you control. It is the same craftsman's principle that governs a good repair bench — measure twice, cut once — applied to inference: never trust a single unchecked output when a second opinion is nearly free.

Verifier scoring is how candidate answers from test-time compute get selected, and it provides the reliable evaluator that Reflexion needs to generate useful self-corrections.