💻 computer science

Reasoning Jury: Multi-Model Consensus for Evaluating Reasoning Traces

The paper introduces "Reasoning Jury," a cost-effective system that employs a moderated consensus mechanism among multiple open-weight LLMs to significantly outperform frontier models in accurately identifying and evaluating reasoning defects within long reasoning traces.

Original authors: Congchao Wang, Diwakar Singh, Qiaozi Gao, Spyros Matsoukas, Yang Liu, Mahdi Namazifar

Published 2026-08-14

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Congchao Wang, Diwakar Singh, Qiaozi Gao, Spyros Matsoukas, Yang Liu, Mahdi Namazifar

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

The Detective's Dilemma: Why One Brain Isn't Enough

Imagine you are trying to teach a super-smart robot how to solve a mystery. You don't just want the robot to shout out the final answer; you want to see its entire thought process, step-by-step, like a detective writing down every clue, theory, and dead end in a notebook. This is what researchers call a "reasoning trace." In the world of Artificial Intelligence, these traces are the lifeblood of learning. If the robot makes a mistake, we need to know exactly where in its long chain of thoughts it went off the rails so we can fix it.

But here's the catch: these reasoning traces can be incredibly long, sometimes stretching for hundreds of steps. It's like asking a single person to read a 500-page mystery novel and point out every single logical flaw in the plot. Even the smartest human (or the most advanced AI) might miss a subtle error because they get tired, distracted, or just stuck on one interpretation. This is the problem the paper tackles: how do we reliably find mistakes in these massive, complex thought processes? The authors propose a solution that moves away from relying on a single "super-judge" and instead uses a whole panel of judges to reach a consensus, much like a courtroom jury.

The Reasoning Jury: A Panel of Minds vs. The Lone Wolf

In this paper, the authors introduce a system called Reasoning Jury. Think of it as a high-stakes game show where a long, complicated reasoning trace is the contestant. Usually, we'd ask one super-smart AI (a "frontier model") to watch the show and say, "Pass" or "Fail." But the authors found that even the smartest single AI often misses the subtle errors hidden in those hundreds of steps. It's like asking one person to find a needle in a haystack; they might find it, but they might also miss it if they blink at the wrong moment.

So, the authors decided to try something different: The Jury.

Instead of one judge, they assembled a panel of several AI models. These models act as "jurors." Here is how the game plays out:

Phase 1: The Independent Verdicts
First, every juror reads the problem and the long reasoning trace on their own. They don't talk to each other yet. Each one writes down a list of defects they found, pointing to the exact step where the mistake happened (like saying, "In Step 14, the math went wrong because..."). They also tag how bad the mistake is: is it a tiny typo (minor), a big logic error (major), or a fatal flaw that ruins the whole answer (fatal)?

Phase 2: The Deliberation
This is where the magic happens. The jurors gather in a virtual room with a Moderator. The Moderator is like a strict referee who doesn't know the answer to the problem themselves; they only listen to the jurors arguing their cases.

The Debate: The jurors argue back and forth. One might say, "I think Step 14 is wrong," and another might say, "No, Step 14 is fine, but Step 15 is the real culprit!" They debate until they reach a consensus.
The Consolidation: Alternatively, the Moderator can just take all the lists from Phase 1 and merge them into one final, clean report, removing duplicates and keeping the best explanations.

What They Found: The Power of the Crowd

The results were surprising and exciting. When the authors tested this system on a benchmark called Hard2Verify (which contains very difficult math problems with long reasoning traces), they found that a jury of open-weight models (models that are free to use and not locked behind a paywall) could actually outperform the most expensive, "frontier" AI models available.

Here is the breakdown of their discovery:

Better Accuracy: A single top-tier AI model (like Opus-4.6) got a score of about 73.7 (on a scale of 0 to 100) at finding these reasoning errors. But a jury made of three cheaper, open models (specifically gpt-oss-120b) that debated together reached a score of 82.3. That's a huge jump! Even a jury of just three open models beat the single best model by a significant margin.
The "Lift" Effect: The paper shows that the jury didn't just average the scores; it actually improved them. When the jurors debated, they caught errors that any single juror missed. It's like a group of friends solving a puzzle: one person spots a piece, another sees how it fits, and together they finish the picture faster and more accurately than any one of them could alone.
Cheaper and Faster: Perhaps the most practical finding is the cost. Running a single "super-model" to judge these traces is expensive. The authors calculated that using their jury system was 6.4 times cheaper than using a single frontier model for the same task. In fact, the jury cost only about 8% to 16% of what it costs to run the expensive models. It's like getting a team of expert detectives for the price of a single intern.

Why This Matters: Fixing the Robot's Brain

The paper also tested if this system could actually help the AI learn. They took a model that had made mistakes, showed it the jury's detailed feedback (not just where the mistake was, but why it was wrong), and asked it to try again.

The Result: When the model received the rich feedback from the jury, its accuracy on retrying the problems jumped from 71.2% to 76.2%.
The Takeaway: This suggests that having a detailed, step-by-step diagnosis of errors is much more helpful for an AI than just being told "you're wrong." It's the difference between a teacher saying "Get this wrong" and a teacher saying "You added these two numbers incorrectly in Step 14; here is the right way to do it."

What the Paper Rules Out

The authors were careful to test if their results were just a fluke. They explicitly ruled out a few ideas:

It's not just about having more models: They tried a "majority vote" (where the answer is just what most jurors said). This didn't work well because the jurors rarely agreed on the exact same steps. The deliberation (the arguing and debating) was the key ingredient that made the difference.
It's not just about diversity: They tested a jury made of three copies of the same model. Even without different types of models, the jury still improved the score significantly. This suggests that the act of independent thinking and then debating is what helps, even if the "brains" are identical.
It's not a magic bullet for everything: The paper admits that while the jury is great at finding where the error is, they haven't fully proven that every single explanation the jury gives is 100% factually perfect. However, the system is robust enough to be useful for training and debugging.

The Bottom Line

The Reasoning Jury proves that when it comes to checking the complex, long-winded thoughts of AI, a group of minds is better than one. By letting multiple models debate and refine their findings, we can find errors that even the smartest single AI misses, all while saving a massive amount of money. It turns the evaluation of AI reasoning from a lonely, expensive task into a collaborative, cost-effective process, paving the way for smarter, more reliable AI systems in the future.

Technical Summary: Reasoning Jury

Problem Statement

The evaluation of Large Language Models (LLMs) capable of complex reasoning faces a critical bottleneck: the inability of single-model judges to reliably identify defects in long reasoning traces. Unlike non-reasoning models where evaluation focuses on short, self-contained answers, reasoning LLMs generate chains of thought containing tens to hundreds of interdependent steps. A single error in an early step can propagate, rendering the entire trace invalid.

Current "LLM-as-a-judge" paradigms, which rely on a single frontier model (e.g., GPT-5, Opus, Sonnet), struggle with this complexity. They often miss defects or fail to pinpoint the exact step where reasoning breaks down. Furthermore, using frontier models for online training or reinforcement learning (RL) is often prohibited due to usage guardrails and cost constraints. There is a need for a system that can provide high-fidelity, step-grounded defect detection at a lower cost and with greater reliability than single-model judges.

Methodology: Reasoning Jury

The authors introduce Reasoning Jury, a framework that replaces the single judge with a panel (jury) of LLMs and a moderated consensus mechanism. The system operates in two distinct phases:

1. Trace Segmentation

To enable precise grounding, long reasoning traces are segmented into steps. While many prior works use double newlines (\n\n), the authors employ a more robust regex pattern ((?<=[.!?])\s*\n\s*\n+) that respects sentence boundaries. This ensures steps are not split mid-code or mid-algebraic derivation. Each segment is marked with a [STEP-x] identifier.

2. Phase 1: Independent Judgement

A panel of jurors (LLMs) independently analyzes the problem, the step-segmented trace, and the final solution. Each juror emits a structured JSON verdict for every defect found, containing:

what_went_wrong: A self-contained description of the defect.
statement_refs: A list of specific [STEP-x] markers where the defect occurs.
impact: A severity label (neutral, minor, major, fatal).
evidence: Direct quotes from the trace supporting the claim.
Constraints: The prompt enforces a "genericness test" (rejecting comments applicable to any problem) and a "specificity self-check" (scoring 1–5, keeping only $\ge$ 4) to ensure defects are grounded and actionable.

3. Phase 2: Consensus

The independent verdicts are aggregated into a final consensus via one of two modes:

Consolidation: A moderator (judge) reviews the original trace and all Phase 1 verdicts. It verifies, merges, and fills gaps, producing a single structured output. The moderator has full access to the trace.
Deliberation: A moderated multi-turn debate occurs among jurors. Crucially, the moderator is blind to the original problem and trace; it only sees the transcript of the jurors' arguments. The moderator manages turn-taking, identifies disagreements, and detects convergence. Jurors re-read the trace when speaking to defend or concede points. The final verdict is synthesized from the full transcript.

Key Contributions

Architecture for Defect Detection: A two-phase system (Independent Judgement + Consensus) specifically designed for step-grounded defect localization in long reasoning traces.
Open-Weight Superiority: Demonstration that a jury of open-weight models (e.g., gpt-oss-120b) can significantly outperform frontier proprietary models (e.g., opus-4.6, sonnet-4.6, gemini-3.1-pro) in identifying reasoning defects. When a single frontier model (like gpt-5.4) dominates a jury, the consensus performance saturates near that single model's level; however, in the absence of such a dominant model, aggregating independent judgments from open-weight models yields substantial gains over their individual capabilities and over other frontier models.
Cost Efficiency: The system achieves higher accuracy than frontier models at a fraction of the cost. A deliberating jury of open models costs approximately 8–16% of the cost of running a single frontier model as a judge.
Actionable Feedback for Training: The structured output (defect location, description, severity) provides rich signals for data curation, Reinforcement Learning (RL), and inference-time correction, moving beyond simple scalar scores.

Experimental Results

The system was evaluated on Hard2Verify (200 records, advanced math) and DeltaBench (1,236 records, STEM/coding/general reasoning).

Accuracy:
- On Hard2Verify, a single gpt-5.4 achieved a Balanced F1 of 83.9. A Frontier jury (including gpt-5.4) reached 84.4, showing that the jury is nearly saturated by the single dominant model, gaining only ~0.5 points.
- Removing gpt-5.4, a jury of open-weight models (gpt-oss-120b x3) achieved 82.3 (Deliberation) and 80.3 (Consolidation), outperforming opus-4.6 (73.7) by a significant margin.
- Homogeneous juries (3 samples of the same model) also showed significant gains over single samples (e.g., gpt-oss-120b jury: 82.3 vs. solo: 65.4–69.3), indicating that independent sampling contributes to performance even without model diversity.
Cost Analysis:
- Running a 3x gpt-oss-120b jury in deliberation mode on 200 records cost $12.35, compared to $79.13 for a single opus-4.6 pass.
- Consolidation mode cost $6.50 (12x cheaper than opus-4.6).
- Despite using ~7.6x more tokens and ~10.9x more API calls, the lower per-token cost of open models resulted in massive savings.
Downstream Utility (Defect-Guided Retry):
- In an experiment with nemotron-3-super on AIME2026, providing the model with rich feedback (defect description + severity) during a retry increased accuracy from 71.2% (step locations only) to 76.2%.
- This confirms that the "what went wrong" diagnosis and severity labels provide actionable value beyond mere step localization.

Significance and Claims

The paper positions Reasoning Jury as a practical solution for offline reasoning evaluation and data curation where single judges are insufficient. Its primary significance lies in:

Democratizing High-Fidelity Evaluation: Enabling the use of open-weight models to achieve evaluation quality previously thought to require frontier models, particularly when no single model in the jury dominates the task.
Enabling RL and Training: Providing the rich, step-level signals necessary for advanced RL approaches (e.g., NuRL, scaf-GRPO) that rely on defect detection rather than just outcome scores.
Scalable Inference-Time Correction: Offering a mechanism to feed back specific reasoning errors to models during runtime to correct mistakes.

The authors remain modest regarding the validation of the factual accuracy of the defect descriptions themselves, noting that while the system improves localization and downstream retry performance, the specific correctness of every generated explanation requires further human validation. The system is presented as a framework that shifts reasoning evaluation from a scalar score to an inspectable, aggregated, and actionable verdict.