Don't Ask How Confident a Reasoning Model Is — Ask Whether Its Arguments Contradict Each Other

🧭 When reasoning models start "thinking," how do we know they're not dreaming

Over the past year, AI has undergone a quiet but profound paradigm shift: models no longer answer immediately, but first fill a scratchpad with derivations before concluding. These are reasoning models — producing a chain of thought that can span thousands of tokens before delivering a final answer. They crush predecessors on math competitions and science benchmarks, so attention naturally turns to more dangerous stages: medical diagnosis, legal advice, agentic systems that act with tools. These settings share one premise: the cost of a model's error is no longer a wrong answer on a test — it can ruin a person.

Before sending a reasoning model into an operating room, we must answer an old question: how certain is it? Not "did it get it right" — that's hindsight — but "before the answer is revealed, can we estimate whether this reasoning chain should be trusted?" This is uncertainty quantification (UQ), the last gate before deploying models in high-stakes scenarios.

In practice, UQ most often takes the form of abstention: the system assigns each prediction an uncertainty score and refuses to answer above a threshold — escalating to a human or admitting "I don't know." The mechanism is only as good as the score: it should rank wrong answers at the top, blocking "dangerous confidence." So evaluating a UQ method boils down to: does its "suspicious list" actually rank by error probability?

The paper *Argument Graph Uncertainty* (AGU) proposes an elegant reframing: don't stare at the model's face (token probabilities), don't repeatedly ask it the same question (sampling consistency) — instead, read the reasoning itself. Is a chain of thought a self-consistent argument? Do its premises support or undermine each other? Is the conclusion actually derived from warranted reasoning?

It's like evaluating testimony in court. A seasoned lawyer doesn't just check how calm the witness looks (token probabilities) or whether three retellings match (consistency sampling); they cross-examine sentence by sentence: "You said you were at the library at three, on your way home at four — what is the entailment relation between these propositions?" AGU automates and mathematizes that cross-examination.

🕳️ Two old roads, each collapsed

Consistency methods: sample the same question five times and check whether answers agree. Reasonable, but costs an order of magnitude more — one trace can be thousands of tokens, and five samples means five times the inference bill. Worse, it only votes on the final answer, discarding the reasoning in those thousands of tokens — like hiring five detectives and only asking whether they name the same suspect, ignoring that one of them found decisive counterevidence mid-investigation.

Token entropy: sum the model's per-token "hesitation" across a sequence as a proxy for confidence. On reasoning models this nearly collapses, for three reasons. First, deep context mechanically inflates token confidence — longer prefixes flatten subsequent token distributions regardless of reasoning quality. Second, RL training sharpens output distributions — entropy collapse pins the gauge at "very confident." Third, it can't distinguish semantic uncertainty from lexical variation. The paper's Figure 2 shows a striking result: token entropy trajectories for correct and incorrect answers almost overlap — the needle doesn't deflect at the critical fork. Heuristics like trace length and backtracking-phrase counts are similarly contaminated by problem difficulty, RL length bias, and overthinking artifacts.

In short: existing methods ignore the real determinant of whether a reasoning chain should be trusted — its logical structure. If the second premise of a syllogism contradicts the first, the chain is broken no matter how confident it sounds. That structural signal sits plainly in the trace, unread.

🏛️ A 1995 paper court: an academic aside

AGU builds on Phan Minh Dung's Abstract Argumentation Frameworks (Artificial Intelligence, 1995): arguments become graph nodes, attacks become directed edges, and acceptability is derived purely from graph-theoretic properties — conflict-freeness and defense. Truth isn't decided by volume but by one's position in the attack network. The framework's restraint is its greatness: it doesn't care what arguments say, only the topology of attacks, laying the foundation of computational argumentation.

AGU borrows one idea: an argument's trustworthiness is a structural property of the graph, not of nodes. But it modernizes Dung: instead of binary attacks, AGU uses probabilistic NLI scores — entailment, neutral, contradiction summing to one. Black-and-white duels become measured cross-examination.

The second source is Evidential Deep Learning (Sensoy et al., 2018): output Dirichlet distribution parameters — "a distribution over probability distributions" — representing accumulated evidence. AGU keeps the Dirichlet machinery but swaps the evidence source: not output-layer logits, but the structural integrity of the argument graph. This transplant is the paper's most elegant conceptual move.

🔧 Putting the chain of thought on the dissecting table

AGU is post-hoc — it doesn't touch the evaluated model's parameters; the task is multiple-choice QA (MCQA), with a single chain of thought as input. Five steps:

1. Reasoning segmentation. Split the trace into n propositions v₁…vₙ, each a complete statement. By default a small instruction-tuned model (Qwen3-8B Instruct) does the splitting; remarkably, plain paragraph splitting also works — zero model calls, zero cost.

2. NLI edge scoring. A pretrained NLI model — DeBERTa, chosen as the strongest encoder on NLI benchmarks and cheap — scores each sentence pair with probabilities p_E (entailment), p_N (neutral), p_C (contradiction), summing to one. An encoder is deliberately chosen: hundreds of pairs must be scored cheaply, with low latency and stable judgments.

3. Two complementary graphs.

• A node–option commitment graph: each proposition vᵢ scores each answer option aₖ (K options) via a hypothesis hₖ like "The answer is Option X: [option text]", using contradiction-adjusted support: eᵢ,ₖ = max(0, p_E − p_C). Only net support counts as evidence; contradiction zeroes out that step's support but doesn't subtract from other steps — like a discredited testimony being voided, not converted into evidence against the defendant.
• A fully connected segment–segment graph: NLI scores for all ordered pairs (a windowed variant considers only |i−j| ≤ w/2). Two global scalars are distilled: Conflict (mean contradiction over directed edges — how much the trace argues with itself) and Asymmetry (mean absolute difference between forward and reverse entailment — whether support depends on ordering).

4. Node reliability. Each vᵢ gets a global coherence cohᵢ (average net entailment toward all other nodes, normalized) and a local trajectory coherence trajᵢ (toward neighbors only), fused as rᵢ = λ·cohᵢ + (1−λ)·trajᵢ with λ = 0.5. A step is trusted to the degree it coheres both globally and locally — each scale catches what the other misses.

5. Dirichlet evidence aggregation. Per option: Eₖ = Σᵢ rᵢ·eᵢ,ₖ. Then the key cut: an effective evidence scale κ_eff = κ·exp(−γ_c·Conflict − γ_a·Asymmetry) — internally conflicting, directionally unstable chains get their evidence proportionally discounted, even if each step barely holds up. Finally αₖ = α₀ + κ_eff·Eₖ; the prediction is the normalized α mixture, and uncertainty U_AGU is the normalized Shannon entropy of that mixture — the flatter the evidence across options, the more the model should say "I don't know."

Default hyperparameters: α₀ = 1.0, κ = 12.0, γ_conflict = 1.2, γ_asymm = 1.0, λ = 0.5. Zero extra calls to the evaluated model — only the small segmenter and NLI encoder cost money.

📊 Nine models, eight wins: the main scoreboard

Experiments run on GPQA Diamond (main), plus MMLU-Pro and TruthfulQA, on nine public reasoning models: DeepSeek-R1-Distill-Llama-70B, DeepSeek-R1-Qwen-14B, DeepSeek-R1-Llama-8B, GPT-OSS-120B, GPT-OSS-20B, Nemotron-Nano-30B, Qwen3-30B-Thinking, Qwen3-4B-Thinking, Phi-4-Mini-Reasoning. Uniform FP16, temperature 0.7, top-p 0.9, n=5 samples per question. The metric is PRR (Prediction Rejection Ratio): how much accuracy improves on remaining samples after rejecting the highest-uncertainty ones — higher is better. Think airport security: a good scanner queues travelers by risk; a bad one either waves everyone through (collapse) or randomly flags people (or worse, inverted — token entropy's negative PRR means it rejects the correct ones).

On GPQA Diamond, AGU takes the top PRR on eight of nine models:

• Nemotron-Nano-30B: AGU 0.65 vs. consistency 0.24, token entropy 0.41 — a rout;
• GPT-OSS-120B: 0.56 vs. 0.36 and −0.27 — note the negative: token entropy fully inverts the rejection order;
• GPT-OSS-20B: 0.55 vs. 0.35 and 0.14;
• Qwen3-4B-Thinking: 0.51 vs. 0.20 and 0.27;
• Qwen3-30B-Thinking: 0.43 vs. 0.31 and 0.10;
• Phi-4-Mini-Reasoning: 0.43 vs. 0.15 and 0.06;
• DeepSeek-R1-Qwen-14B: 0.41 vs. 0.29 and 0.10;
• R1-Llama-8B: 0.29 vs. 0.26 and −0.13.

The sole exception: DeepSeek-R1-Distill-Llama-70B, where consistency wins 0.46 to AGU's 0.34 — but its token entropy is −0.39, the worst of all.

Most telling is small-model behavior: on Phi-4-Mini and Qwen3-4B, token entropy (0.06, 0.27) and consistency (0.15, 0.20) both falter, while AGU holds at 0.43 and 0.51. Argument structure captures information lost in surface signals. Token entropy and consistency presuppose some meta-cognitive self-awareness; logical contradiction is objective — it requires no self-knowledge, only a reader of sentences. For cost-sensitive deployments, this is a gift: no extra sampling, no trusting token probabilities — just read the structure.

🎻 A shape-poem of three distributions

Figure 4's histograms are the paper's most vivid evidence:

• Token entropy: collapse. All models' uncertainty piles near 0 — entropy collapse in direct view; a nearly constant variable predicts nothing.
• Consistency: bimodal. Pinned at the two endpoints — fully consistent (0) or fully inconsistent (1), with a hollow middle. A lie detector that only says yes or no, discarding graded certainty.
• AGU: spread. Uncertainty spreads smoothly over [0,1] with real mid-range resolution — it fills exactly the canyon consistency cannot resolve. A true "degree," not a binary verdict.

Together they diagnose "where did the information go": token entropy's signal was ground away by RL training; consistency's was flattened by coarse-grained voting; AGU's was always in the trace — nobody had read it.

🚀 The climax: when two uncertainties shake hands

The paper's soul: AGU and consistency are nearly orthogonal. Equal-weight averaging their uncertainty scores yields a new PRR high on all nine models. Nemotron-Nano-30B: AGU 0.65, consistency 0.24, mix 0.68. Even on R1-Llama-70B — where AGU lost — the mix beats both parents (0.34 and 0.46).

Why? The two methods read different faces of uncertainty with non-overlapping blind spots. AGU's graph captures intra-reasoning conflict; consistency captures cross-sample variability. A model can be internally airtight yet flip answers across samples, or answer identically five times over a riddled chain (spurious coherence in RL models). Any single method misses half.

The deeper lesson: uncertainty is multidimensional — a model can waver internally and across samples, independently. Comparing methods on a single scalar is like arguing whether a thermometer or blood-pressure cuff better predicts health: measure both. In Appendix B.6 the authors tried stacking, nonlinear fusion, learnable weights — plain equal-weight averaging sufficed. That simplicity itself corroborates true orthogonality: with genuinely complementary components, the simplest 1:1 blend wins. And it's nearly free: consistency sampling was already paid for; AGU is one post-hoc structural read.

🛡️ A ruler that doesn't break, and a bill that adds up

Robustness (Fig. 5): randomly flipping 10% of NLI edge labels preserves 78% of PRR; 40% still keeps half. Gaussian noise: 97% retained at σ=0.5, 85% at σ=1. Because Dirichlet evidence aggregates over dozens of edges, no single edge moves the final estimate much. You don't need an infallible witness — just many roughly honest ones with uncorrelated errors.

Ablations (Table 2): segmentation matters less than expected. Qwen3-8B segmenter: mean PRR 0.46 (std ~0.08); GPT-OSS-120B segmenter: 0.50, std 0.03; zero-cost paragraph splitting: 0.47 — the default for compute-tight settings. Notably, GPT-OSS-120B segmentation pushes GPT-OSS-20B's PRR to 0.76, and paragraph splitting hits 0.71 on Nemotron — the highest single score.

Not a length artifact: using segment count alone as uncertainty yields mean PRR 0.33 (vs. AGU's 0.45, stronger on seven of nine); Spearman correlation only 0.43; regressing out segment count, AGU's residual PRR is still 0.33.

Cost: zero calls to the evaluated model. The windowed variant (w=10) cuts NLI from O(n²) to O(n) with PRR gaps under 0.01 — the recommended default. Consistency costs scale linearly with trace length at a huge constant — five samples, five bills. And in agentic settings it's not just money: sampling five times may trigger external side effects five times; reading structure once triggers them once.

🤔 A sober coda: limits and aftertaste

Honestly, AGU isn't a panacea. It fits MCQA-style tasks with explicit options; open-ended QA's hypothesis construction is unaddressed. The NLI model's ceiling is AGU's ceiling, and against a carefully crafted chain that is internally self-consistent yet wrong, graph structure is blind — it measures consistency, not truth; a flawless syllogism on false premises shows no cracks. That blind spot needs external fact-checking. And the one loss (R1-Llama-70B) reminds us: when a model is strong and sampling stable, consistency's signal is clean and structural margins narrow — though the hybrid never loses on any of the nine.

Still, the paper's posture is what moves: while everyone piles on compute, sampling, and training, it steps back and says — before asking how confident the model is, read what it actually wrote. Stitching Dung's thirty-year-old paper court to Dirichlet evidence calculus yields a ruler that is robust, cheap, and can point to which step was lying — since rᵢ is computed per segment, every uncertainty score traces back to specific argument steps, an attribution value beyond any PRR number.

The confidence crisis of reasoning models won't be solved by any single metric. But this paper proves one thing: gold is buried in the logical structure of arguments, and it's worth reading — no bigger model, no more sampling, just rereading those thousands of tokens and asking the oldest question: does this step entail the next? Dung asked it on paper in 1995; thirty years later, it's the neural chain of thought's turn to answer.

📚 References

• Paper: Argument Graph Uncertainty: Quantifying Uncertainty from the Logical Structure of Reasoning Chains
• Authors: Simon Baur, Sumire Honda, Wojciech Samek, Jackie Ma (Fraunhofer Heinrich-Hertz-Institut, Berlin)
• arXiv: 2610.20328 (2026-10-14, cs.AI) — https://arxiv.org/abs/2610.20328
• License: CC BY-NC-SA 4.0