🤖 machine learning

LLMs as a Jury: Cross-Model Consensus Can Outperform Process Reward Models for LLM Reasoning

This paper introduces "LLM-jury," a parameter-free test-time scaling method that leverages cross-model consensus among independently trained models to outperform self-consistency and trained reward models in selecting correct reasoning chains by exploiting error decorrelation, while providing a closed-form law to predict its accuracy and identify its failure ceiling.

Original authors: Ning Liu

Published 2026-07-14

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Ning Liu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to solve a really tricky math problem or a science riddle. You ask a super-smart AI for the answer. But sometimes, even the smartest AI gets stuck in its own head, making the same mistake over and over again because it's too confident in its own wrong logic.

This paper introduces a new way to check the answer: the LLM-Jury.

The Problem: The "Echo Chamber" Trap

Usually, when we want to be sure an AI is right, we ask it the same question many times and take the most common answer. This is called Self-Consistency.

Think of it like asking your best friend for advice, but you ask them 12 times in a row. If your friend is having a bad day and gets the answer wrong, they will likely get it wrong 12 times in a row. They will confidently vote for the wrong answer, and because they are the only one you asked, the "majority" will be wrong. The paper shows that this method inherits the friend's blind spots.

Another way people try to fix this is by training a special "Judge AI" to score the answers. But this judge needs a lot of homework (labeled data) to learn how to grade, and if you ask it a question from a subject it hasn't studied, it often fails.

The Solution: The "LLM-Jury"

The authors propose a different idea: Cross-Model Consensus. Instead of asking one friend 12 times, you ask four different friends who were raised in different houses, went to different schools, and think in totally different ways.

The Setup: You have a "Generator" AI that creates a list of possible answers. Then, you have a "Jury" of three other AIs (like Qwen, DeepSeek, and Claude) who each solve the problem once, independently. They never see each other's work.
The Verdict: If three out of the four jurors agree on an answer, that's the one you pick.

Why It Works: The "Scatter" Effect

The paper explains this with a clever metaphor about errors.

Wrong answers from the same model are like a group of friends who all trip over the same rock. They all fall in the same spot.
Wrong answers from different models are like a group of friends who trip over different things. One trips on a banana peel, another on a loose stone, another on a puddle. Their mistakes "scatter" all over the place.

Because the wrong answers from different models are scattered, they cancel each other out. The correct answer, however, is the only thing that makes sense to everyone, so it gathers all the votes. The paper measured this and found that on hard math competitions, this jury method captures 100% of the possible improvement over the old "ask one friend many times" method, while a single model trying to grade its own work captures almost 0%.

The "Magic Law" and the "Ceiling"

The researchers didn't just guess this would work; they wrote a math law (a formula with no hidden settings) that predicts exactly how well the jury will do. They tested this law on seven different benchmarks, from grade-school math to graduate-level science, and it predicted the results with an average error of just 0.03 (that's incredibly close!).

However, the paper also found a hard ceiling (a limit) to how good this can get.

The Shared-Error Floor: Sometimes, all four jurors might share the same misconception. For example, if they all learned a specific science fact wrong in their training, they might all unanimously agree on the wrong answer.
The paper measured this "floor." On math problems, it's almost 0 (they rarely share the same math mistake). But on science questions (like the GPQA benchmark), the floor is about 0.03, meaning there's a small chance they will all confidently agree on a wrong answer because they share a blind spot.

The Results: Beating the Experts

The paper compared this free, training-free Jury against four different types of "trained judges" (special AI models built specifically to grade answers).

Inside their training zone: On math problems, the Jury tied or beat the best trained judges.
Outside their training zone: On science questions where the trained judges had never seen data before, the Jury was the top performer, while the trained judges struggled.

The Jury does this without needing any extra training or labeled data. It just uses the models we already have.

The "Agreement Cascade": Saving Money

The paper also suggests a smart way to save computer power. You don't always need to ask all four jurors.

Ask just two jurors first. If they agree, you're done (cheap!).
If they disagree, then ask the other two to join the party (more expensive, but only for the hard problems).
This "cascade" method saves a lot of computing power while still getting the same high accuracy as asking all four every time.

What It's NOT

The paper is very clear about what this method is not:

It is not a magic wand that fixes everything. If all the models share a specific wrong idea (like a specific chemistry unit conversion), the Jury will confidently get it wrong, and no amount of voting will fix it.
It is not just "more models are better." The paper proved that asking one model 32 times is worse than asking four different models just once. The magic comes from the difference between the models, not just the number of votes.
It is not a replacement for the smartest single model if that model is already perfect. But since no model is perfect, the Jury is the best tool we have to pick the right answer from a pile of guesses.

In short, the paper shows that if you want to know if an AI is right, don't ask it to grade itself. Ask a panel of different AIs to vote. If they agree, you can trust them. If they disagree, you know you need to dig deeper. And best of all, you can predict exactly how much you can trust them before you even start.

Technical Summary: LLMs as a Jury

Problem Statement

Modern reasoning systems increasingly rely on test-time scaling, where compute is spent by sampling many candidate solutions and selecting the best one. As the sample count grows, a correct answer almost always appears in the pool, shifting the bottleneck from generation to selection. The paper identifies that existing selection verifiers suffer from structural limitations:

Self-consistency (majority voting over repeated samples of a single model) inherits the systematic errors of that single model. A confidently wrong model will repeatedly generate the same error, voting its own mistake into the majority.
Trained reward models (Outcome Reward Models and Process Reward Models) require annotated training data and transfer poorly outside their specific training distribution.
Single-model LLM verifiers (where a model scores its own candidates) are weak, as a model cannot adjudicate its own blind spots.

The paper seeks a label-free, general, and training-free verifier that can detect errors a single model is blind to.

Methodology: The LLM-Jury

The authors propose Cross-Model Consensus, conceptualized as an LLM-jury.

Mechanism: A panel of $M$ independently trained models (the "jurors") each solves a problem once. They never see the candidates generated by a separate generator, nor do they see each other's work.
Selection Signal: The selection is based on the structure of agreement. The answer corresponding to the modal class (the most frequent answer) is selected. The fraction of models agreeing ( $g$ ) serves as a confidence signal.
Core Hypothesis: The mechanism relies on error decorrelation. Independently trained models make different mistakes. When they err, their wrong answers scatter; when they are correct, they converge. In contrast, resampling a single model (self-consistency) repeats correlated errors, manufacturing a confident but wrong majority.

Theoretical Framework: A Parameter-Free Law

The paper derives a closed-form, parameter-free law to predict the behavior of the jury based on three measurable panel statistics:

$a$ : Mean member accuracy.
$\rho$ : Mean pairwise error correlation.
$s$ : The shared-misconception rate (the probability that, when a model is wrong, it lands on a specific "attractor" wrong answer shared by other erring models).

Key Theoretical Insights:

Consensus Accuracy: Predicted by the law, it rises as error correlation ( $\rho$ ) falls.
Shared-Error Floor: The law defines an irreducible error floor: the probability that the entire panel unanimously agrees on a single wrong answer. This occurs when models share a misconception. The law predicts this floor is near zero for math (where errors scatter) but non-trivial for science (where models share specific misconceptions).
Predictive Power: The law predicts consensus accuracy and the full selective-prediction curve (accuracy vs. coverage) with a Mean Absolute Error (MAE) of 0.03, without fitting parameters to the prediction target.

Key Contributions

Agreement as a Verifier: The LLM-jury selects correct answers better than self-consistency and single-model LLM verifiers across seven benchmarks. On competition math (AIME), it captures 100% of the achievable selection gain over self-consistency, whereas a model scoring its own candidates captures ~0%.
Predictive Law and Ceiling: A closed-form law predicts consensus behavior and its failure mode (the shared-error floor) from panel statistics. It quantifies that the method's ceiling is determined by how alike models' errors are, not by the method itself.
Performance Against Trained Verifiers: The free LLM-jury matches or exceeds state-of-the-art trained verifiers (discriminative PRMs, outcome RMs, and generative verifiers) both inside and outside their training domains, with zero training cost.
Mechanism Isolation: Through matched-size and matched-accuracy experiments, the paper isolates error decorrelation as the operative cause of the gain, rather than mere multi-model combination. A panel of four decorrelated models outperforms a single model resampled 32 times.

Experimental Results

The study evaluates the LLM-jury against self-consistency, single-model verifiers, and four trained verifiers across seven benchmarks (AIME-2024/2025, MATH-500, OlympiadBench, GSM8K, GPQA, MMLU-Pro, and HumanEval+).

Selection Accuracy: On a fixed pool of $N=12$ $N = 12$ candidates, the LLM-jury is the strongest non-oracle selector on every unsaturated benchmark.
- AIME-2024: Jury achieves 56.7% accuracy, closing the entire gap to the oracle (56.7%). Self-consistency achieves 36.7%. The single-model verifier achieves 30.0%.
- GPQA (Science): The jury (35.9%) significantly outperforms the single-model verifier (26.3%) and trained PRMs, though the gain over self-consistency is smaller due to the higher shared-error floor in science.
Generalization: The jury outperforms trained verifiers in out-of-domain settings (e.g., GPQA), where trained reward models degrade.
Code Domain: On HumanEval+, behavioral consensus (agreement on execution outputs) predicts correctness with an AUROC of 0.748, demonstrating the signal's applicability beyond text matching.
Cost Efficiency: An "agreement-gated cascade" (running a cheap 2-model panel first, escalating to 4 only on disagreement) achieves full-panel accuracy at near-cheap cost (e.g., 2.2 calls/problem on MATH-500), significantly outperforming self-consistency at the same budget.

Significance and Claims

The paper claims that Cross-Model Consensus is a fundamental, predictable verification primitive that does not require training data or labels.

Predictability: The method is characterized by a law that tells practitioners when to trust it (based on measured panel statistics) and where it fails (the shared-error floor).
Domain Agnosticism: Unlike trained reward models that are domain-specialized, the jury generalizes because the signal (decorrelated errors) is inherent to independent training, not specific to a dataset.
Efficiency: It offers a strong default for test-time scaling using only the models a practitioner already has, avoiding the cost of training separate reward models.
Limitations: The method has a hard ceiling defined by the shared-error floor. If independently trained models share a misconception (common in science domains), the jury will unanimously agree on the wrong answer, and no agreement-based signal can detect this. The paper notes this floor is near zero for math but non-trivial for science.

The authors conclude that as the selection process (rather than generation) increasingly bounds end-to-end accuracy, a decorrelated panel is a robust, label-free solution that rivals and often exceeds trained verifiers.