Understanding Reasoning in LLMs through Strategic Information Allocation under Uncertainty

🎯 Pitch

Large reasoning models (LRMs) correct themselves even when no explicit error is triggered—how? The authors reveal that 'aha moments' do not require magical introspection: simply injecting a minimal doubt cue like 'Wait, is that correct?' recovers ~15% of failed trajectories from standard LLMs, proving that reasoning hinges less on extraordinary inner mechanisms than on the humble linguistic habit of externalizing uncertainty.

1. Executive Summary

This paper introduces an information-theoretic framework that decomposes LLM reasoning into two distinct informational axes—procedural advancement (step-by-step computation toward the answer) and epistemic verbalization (the token-level externalization of the model's internal uncertainty about its own reasoning, e.g., tokens like "Wait, is that correct?")—and proves that even sporadic epistemic verbalization restores convergence toward correct answers in regimes where purely procedural reasoning silently diverges. Analyzing reasoning traces from Qwen2.5, Qwen3-Base, and DeepSeek-R1-Distill models on AIME24/25, AMC23, and MATH500, the authors demonstrate that injecting a minimal doubt cue without identifying any specific error recovers roughly 15% of failed trajectories, and that as few as 800 SFT examples suffice to either instill or suppress epistemic verbalization behavior. The paper reframes reasoning as strategic information allocation under uncertainty, establishing that strong reasoning depends less on an extraordinary inner mechanism than on the linguistic habit of externalizing uncertainty—a capability that can be rapidly distilled into base models only when their token distributions are sufficiently aligned with the epistemic vocabulary of the teacher.

2. Context and Motivation

The Core Problem: We Don't Understand How LLMs Recover from Reasoning Errors

The paper addresses a fundamental puzzle in LLM reasoning: how do models escape incorrect reasoning trajectories, and why do some models succeed while others fail? Recent large reasoning models (LRMs) like DeepSeek-R1 exhibit so-called "Aha moments"—spontaneous self-correction after tokens like "Wait, let me reconsider"—yet the mechanism underlying these behaviors remains opaque. Standard LLMs, by contrast, largely fail to self-correct, instead silently drifting into what the authors term reasoning collapse: a regime where the surface structure of step-by-step reasoning is preserved (the output looks coherent locally) but the model's belief about the correct answer steadily diverges without any overt error signal to trigger correction.

This gap matters for both theoretical and practical reasons:

Theoretical significance. Understanding how LLMs recover from errors is central to understanding the nature of reasoning itself in these models. Prior work has documented that self-correction happens (or fails to happen), but has not identified what informational mechanism enables it. The paper argues that this lack of mechanistic understanding has led the field to conflate distinct phenomena—Aha moments, reflection, self-correction, and the emergence of specific tokens like "Wait"—under a single vague umbrella, making it impossible to design principled interventions or training procedures.

Practical significance. If epistemic verbalization (externalizing uncertainty) is the key mechanism enabling recovery from errors, then it represents a learnable axis of reasoning capability that can be targeted through training. The paper demonstrates exactly this: as few as 800 SFT examples can instill or suppress the behavior, with dramatic effects on performance. Understanding why this works—and why it sometimes fails to transfer during distillation—has direct implications for how reasoning models are trained, deployed, and evaluated. Moreover, the distinction between reactive correction (triggered by explicit errors) and proactive correction (triggered by internal uncertainty) has consequences for system design: models that only correct reactively will systematically fail on the silent divergence patterns that dominate real-world reasoning failures.

Conflicting Prior Evidence on Self-Correction

The paper is motivated by a genuine tension in the literature. Several recent studies have cast doubt on whether LLM "Aha moments" reflect genuine self-correction:

d'Aliberti and Ribeiro (2026) show that markers such as "Wait" emerge from high-entropy prediction states and correlate only weakly with actual performance gains—suggesting these tokens may be epiphenomenal rather than causal.
Liu et al. (2025) find that apparent self-reflection often degenerates into repetition rather than producing constructive revisions—the model looks like it's reflecting but doesn't actually change course.
Huang et al. (2024), Tsui (2025), Tyen et al. (2024), and Kamoi et al. (2024) demonstrate that LLMs can correct externally provided errors in their outputs yet systematically fail to fix the same errors when they appear in their own generated text—a striking asymmetry that undermines claims of genuine self-monitoring.

These studies collectively paint a pessimistic picture: Aha tokens are unreliable markers, apparent self-correction is often superficial, and models lack the ability to detect their own errors in the first place. Yet this picture conflicts with the observable behavior of modern reasoning models like DeepSeek-R1, which demonstrably do recover from incorrect trajectories through spontaneous self-correction. The field lacks a framework for reconciling these observations.

The paper identifies why: prior work conflates the informational mechanism with the control action it enables. Specifically, the authors argue that "Wait" and similar tokens are surface manifestations of a deeper process—epistemic verbalization, the externalization of internal uncertainty—rather than being the mechanism of correction itself. When the marker appears without meaningful uncertainty externalization (e.g., as a high-entropy filler token), it fails to enable recovery. When genuine epistemic verbalization occurs (even without pinpointing the error), it provides conditionable information that the model can act on. This distinction explains why "Wait" correlates weakly with correction in some studies (d'Aliberti and Ribeiro, 2026) while appearing causally linked to recovery in others: the correlation depends on whether the token reflects genuine epistemic verbalization or is merely a surface-level artifact of high-entropy decoding.

Where Existing Theoretical Frameworks Fall Short

A parallel line of work has analyzed reasoning from an information-theoretic perspective, but the paper identifies specific limitations that leave the self-correction puzzle unresolved:

Aggregate information flow analyses. Several recent papers model Chain-of-Thought (CoT) reasoning as a process of information accumulation toward the correct answer. Ton et al. (2025) and Liang (2025) reinterpret CoT as a sequence of belief updates that preserve task-relevant information and tighten error bounds. Gan et al. (2025) recast CoT as optimization over reasoning states, identifying trade-offs between noise reduction and generalization. Qian et al. (2025) observe that effective reasoning concentrates information gain in a few critical steps, often marked by tokens like "Wait," which they characterize as "MI peaks" (mutual information peaks).

While these accounts provide valuable insight into how information flows across a successful reasoning trajectory, they suffer from a shared limitation identified in Section 2 of the paper: they treat every generated token as a procedural step. That is, they model reasoning as a uniform process of step-by-step computation, where each token contributes to advancing the procedure toward the correct answer. This framing cannot explain how a model recovers after entering an incorrect trajectory, because once procedural reasoning diverges from the correct path, further procedural steps (even locally coherent ones) do not accumulate toward the correct answer—they accumulate toward a plausible but incorrect conclusion. The framework doesn't distinguish between tokens that advance the computation and tokens that monitor or reassess the trajectory's reliability.

Procedural collapse is the dominant failure mode, not overt errors. The paper's empirical analysis (Section 3.2, Figure 2, Table 6) quantifies a crucial observation that prior theoretical work overlooked: when standard LLMs produce incorrect answers, 54–62% of those failures involve reasoning collapse—patterns like incoherence, hallucination spirals, repetition, topic drift, or degenerate loops—rather than clean step-by-step reasoning that happens to reach the wrong conclusion. In this collapse regime, the surface structure of step-by-step execution is preserved (outputs look locally coherent), but the model's predictive distribution $P_\theta(Y \mid s_t)$ drifts from the correct answer without producing any explicit error signal. This "silent divergence" is the dominant failure pattern, yet it is precisely the regime where purely procedural information-theoretic accounts have nothing to say about recovery.

Token-level entropy is an insufficient corrective signal. A natural response to the limitations of procedural reasoning is to leverage model uncertainty as a corrective signal. Token-level entropy, $H(A_t \mid s_{t-1})$ , has been widely studied as a proxy for reasoning uncertainty (Yong et al., 2025; Yang et al., 2025b; d'Aliberti and Ribeiro, 2026). However, as the paper demonstrates in Appendix C (Figure 9), token-level entropy fails to distinguish correct from incorrect reasoning: the model becomes locally more confident at similar rates regardless of whether its trajectory is productive. This is because token-level entropy captures uncertainty about the next token, not uncertainty about the target variable $Y$ . A model can be highly confident about each local step while being globally wrong—exactly the pattern observed in silent divergence. This gap between local confidence and global correctness means that internal uncertainty, even if accurately computed, is informationally inert: because autoregressive decoding conditions on the realized token sequence, not on internal states, latent uncertainty cannot influence subsequent generation unless it is externalized.

The Key Insight: A Missing Informational Axis

The paper's central conceptual move is to identify an informational axis that prior frameworks missed. Building on the decomposition illustrated in Figure 1, the authors distinguish:

Procedural information: Tokens that advance the computation—explicit calculations, symbolic manipulations, variable assignments, subroutine executions. This is what prior information-theoretic accounts model.
Epistemic verbalization: Tokens that externalize the model's internal uncertainty about its own reasoning trajectory—utterances like "Wait, is that correct?" or "Hmm, I'm not sure this is right." These tokens do not advance the computation; they make the model's assessment of its own reliability conditionable.

The critical property of epistemic verbalization is that it converts latent, inert uncertainty into conditionable, actionable information. Formally (Section 3.1), reasoning proceeds by self-conditioning: each generated token $a_t$ refines the model's belief over the target variable $Y$ , with the information gain of a step being $\Delta_t = H(Y \mid s_{t-1}) - H(Y \mid s_t)$ . When the model is on a correct trajectory, procedural tokens produce positive $\Delta_t$ . When the model has diverged, procedural tokens may produce near-zero $\Delta_t$ (they're locally coherent but globally uninformative about $Y$ ). Epistemic verbalization, by contrast, externalizes the model's assessment of trajectory reliability—information that is informative about $Y$ even when no overt error has surfaced, because it captures the model's (possibly noisy) estimate of whether the current path is productive.

This insight explains why standard LLMs fail at self-correction while LRMs succeed, without requiring any special "reasoning module" or exotic architecture. Standard LLMs rely almost exclusively on reactive correction: they revise only when an explicit error surfaces (a contradiction, a failed check, an impossible result). In the silent divergence regime, no such trigger arises, so the model has nothing to condition on—its internal uncertainty about the trajectory is latent and cannot influence generation. LRMs, by contrast, exhibit proactive correction: they externalize uncertainty even without an overt error, making that uncertainty available for downstream control actions. Table 1 quantifies this gap: in standard LLMs, proactive corrections account for 0–20% of all self-corrections (and total self-corrections are under 1% of all generations anyway); in LRMs, proactive corrections account for 22–35% of self-corrections.

How This Paper Positions Itself

The paper does not propose a new architecture, training algorithm, or reasoning method. Instead, it provides a unifying information-theoretic framework that clarifies the mechanism underlying observed reasoning behaviors and explains why prior findings appear contradictory. Its contributions are:

Taxonomic: It separates reasoning into two informational axes (procedural advancement and epistemic verbalization) and distinguishes information from control (self-correction is a control action that acts on verbalized uncertainty, not the uncertainty itself). This resolves the conflation that has muddied prior work on Aha moments.
Theoretical: It formalizes why procedural reasoning alone fails in silent divergence regimes (Assumption 5.1) and proves that even sporadic epistemic verbalization suffices to restore convergence (Proposition 5.3, proved in Appendix A)—the key insight being that epistemic verbalization provides trigger-independent information gain, meaning it works even when $p_E \to 0$ (no procedural errors surface).
Empirical: It validates the framework through intervention studies (injecting doubt cues recovers ~15% of failed trajectories; suppressing epistemic tokens reduces accuracy by ~10%), distillation experiments (800 SFT examples suffice to instill or suppress the behavior), and distributional analysis (successful distillation depends on the student model's token-level alignment with epistemic vocabulary).

The paper draws on prior information-theoretic analyses of CoT (Ton et al., 2025; Liang, 2025; Qian et al., 2025) but extends them by introducing the second informational axis and analyzing the failure regime (silent divergence) that prior work did not address. It engages directly with the skeptical literature on self-correction (d'Aliberti and Ribeiro, 2026; Liu et al., 2025; Huang et al., 2024) and offers a resolution: Aha tokens fail when they are empty surface forms but succeed when they reflect genuine epistemic verbalization. It also connects to the literature on reasoning distillation (Ye et al., 2025, the LIMO work) by showing that the rapid performance gains from small SFT datasets are explained by the student model acquiring epistemic verbalization habits, and that the success or failure of this transfer depends on distributional alignment in epistemic token probabilities.

The framing of reasoning as "strategic information allocation under uncertainty" is intended to be generative: it suggests that future work on reasoning models should optimize not just for procedural accuracy but for the joint allocation of procedural and epistemic information at each step, and that training procedures should explicitly target epistemic verbalization as a learnable axis of reasoning capability rather than treating it as an emergent property of scale. The paper's Appendix B further extends the framework to open-world (tool-augmented, interactive) settings, showing that external observations can partially substitute for epistemic verbalization by providing exogenous error signals—a theoretical prediction that opens an empirical research program on the trade-off between internal uncertainty monitoring and external information gathering.

3. Technical Approach

3.1 Reader Orientation

This paper is primarily an analytical and empirical framework paper rather than a system-building paper — it proposes an information-theoretic decomposition of LLM reasoning into two distinct informational channels (procedural advancement and epistemic verbalization) and validates this decomposition through controlled intervention studies, distillation experiments, and distributional analysis. The core idea is that effective reasoning in LLMs, particularly the ability to recover from incorrect trajectories, depends on a linguistic habit of externalizing internal uncertainty — converting latent, inert assessments of trajectory reliability into conditionable tokens that downstream reasoning can act on — and that this habit is distinct from (and complementary to) the step-by-step computation that prior information-theoretic accounts model.

3.2 Big-Picture Architecture (Diagram in Words)

The framework has five conceptual components, though they operate within a single LLM rather than as physically separate modules:

Procedural Reasoning Engine — the base LLM's capacity for step-by-step computation (symbolic manipulation, subroutine execution, variable instantiation). This generates tokens that advance the computation toward the target answer $Y$ , operating under the model's standard autoregressive next-token prediction objective. When the model is on a correct trajectory, procedural tokens produce positive information gain about $Y$ ; when the model diverges, procedural tokens may preserve local coherence while providing near-zero information about $Y$ .
Internal Uncertainty Monitor — a latent assessment within the model of its trajectory's reliability, formalized as a latent epistemic variable $Z_t$ at each step $t$ . This assessment is informative about $Y$ (the model can internally estimate whether it is on a productive path), but as a latent variable it is informationally inert: because autoregressive decoding conditions on the realized token sequence $s_{t-1}$ , not on internal states, $Z_t$ cannot influence subsequent generation unless externalized. This is the information-theoretic bottleneck that the framework addresses.
Epistemic Verbalization Channel — the mechanism by which the model converts latent uncertainty assessments $Z_t$ into conditionable tokens $v_t$ visible in the autoregressive context. Examples include tokens like "Wait, is that correct?" or "Hmm, I'm not sure this is right." Once verbalized, these tokens satisfy the inequality $H(Y \mid s_{t-1}, v_t) \leq H(Y \mid s_{t-1})$ , meaning they provide non-negative information gain about $Y$ — they make the model's belief about the correct answer at least as sharp as it was before, and strictly sharper when $v_t$ carries non-trivial information about $Z_t$ . This is the central mechanism that distinguishes strong reasoning models from standard LLMs.
Control Policy (Self-Correction Action) — the decision mechanism that, given the information now available in the token stream (including verbalized uncertainty), determines what to do: continue the current procedural path, backtrack and try a different approach, verify a suspect step, or seek external information. The paper carefully separates this control action from the informational mechanism: epistemic verbalization is not itself correction; it is the information-gathering step that makes correction possible. Self-correction is a control action that fires when the accumulated conditionable information (from both procedural error signals and epistemic verbalization) indicates a need to change course.
Difficulty / Uncertainty Estimation (Implicit) — the model's implicit assessment of whether its current trajectory is reliable, which determines the rate at which it generates epistemic verbalizations. In standard LLMs, this assessment exists internally (as $Z_t$ ) but is rarely externalized; in LRMs, a non-trivial fraction $\rho$ of steps with $H(Y \mid \tilde{s}_t) > \eta$ generate epistemic tokens. The paper does not propose explicit difficulty estimation as a separate module, but the framework implies that the model's internal uncertainty estimate drives the epistemic verbalization rate.

Information flow through these components during a single reasoning step proceeds as follows: the model has generated a partial reasoning trace $s_{t-1}$ → the procedural reasoning engine computes the next token distribution $P_\theta(\cdot \mid s_{t-1})$ → if the internal uncertainty monitor estimates that trajectory reliability is low (high $H(Y \mid s_{t-1})$ ), the model may generate an epistemic verbalization token $v_t$ rather than (or in addition to) a procedural token → the verbalized uncertainty enters the autoregressive context as part of $s_t$ → the control policy now has access to conditionable information about trajectory reliability that was previously latent → if that information indicates a need for correction, the control policy directs the procedural reasoning engine to revise, backtrack, or verify.

In standard LLMs, this flow is broken: the internal uncertainty monitor exists and produces estimates $Z_t$ , but the epistemic verbalization channel is essentially closed — the model does not externalize uncertainty unless an overt procedural error is detected, at which point reactive correction occurs. In the silent divergence regime (no overt error), the control policy has no conditionable uncertainty signal to act on, so the model continues along the incorrect trajectory until terminal collapse.

3.3 Roadmap for the Deep Dive

First, the formalization of reasoning as self-conditioning (Equations 1–2 and surrounding definitions), establishing the information-theoretic vocabulary — reasoning states, information gain $\Delta_t$ , the target $Y$ — that the rest of the framework depends on. This grounds the subsequent analysis in precise terms and explains why the procedural channel alone is insufficient.
Second, the decomposition of reasoning collapse into concrete failure modes (Section 3.2, Figure 2), since understanding what goes wrong in standard LLMs is the motivation for introducing the epistemic channel. The empirical characterization of collapse — its prevalence, its typology, and its relationship to problem difficulty — provides the evidence that procedural reasoning is brittle in ways that create a specific informational gap.
Third, the reactive vs. proactive correction taxonomy (Section 3.3–3.4, Table 1, Figure 3), which quantifies the behavioral difference between standard LLMs and LRMs and introduces the empirical puzzle that epistemic verbalization resolves. This is where the paper identifies what LRMs do differently — they externalize uncertainty without overt error triggers — before explaining why that matters.
Fourth, the definition and validation of epistemic verbalization as an informational mechanism (Sections 4–4.2), including the intervention study that demonstrates causality (injecting doubt cues recovers failed trajectories) and the identification of surface tokens that serve as proxies. This is the empirical heart of the paper: it shows that epistemic verbalization is not merely correlated with good reasoning but is causally responsible for recovery.
Fifth, the formal information-theoretic framework (Sections 5–5.2, Appendix A), which codifies the preceding empirical observations into assumptions about procedural and epistemic information channels, proves that sporadic epistemic verbalization suffices for convergence (Proposition 5.3), and separates information from control. This section provides the theoretical guarantee that the empirical patterns are not accidental.
Sixth, the distillation and distributional alignment experiments (Sections 6.2–6.3), moving from mechanism to practical implication: if epistemic verbalization is a learnable linguistic habit, then it should be transferable through small-scale SFT, and the success of that transfer should depend on token-level distributional properties of the student model. These experiments validate the framework's practical significance and explain the conditions under which reasoning capabilities can be rapidly distilled.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an analytical framework paper whose core idea is that LLM reasoning operates along two distinct informational axes — procedural advancement and epistemic verbalization — and that the ability to recover from incorrect reasoning trajectories depends on the model's habit of externalizing internal uncertainty, which converts latent, inert assessments into conditionable tokens that enable downstream control actions such as self-correction.

Reasoning as Self-Conditioning: The Information-Theoretic Foundation

The paper's framework begins by formalizing LLM reasoning in the closed-world setting, where the model operates without external observations at inference time — all progress toward the correct answer must come from internal belief transformation. This is distinct from the open-world setting (tool-augmented agents, interactive systems), which is addressed in Appendix B.

Given an input $x \in \mathcal{X}$ (the problem statement), an LLM parameterized by $\theta$ induces a conditional distribution $P_\theta(\cdot \mid x)$ over tokens from vocabulary $\mathcal{V}$ , generating a sequence autoregressively:

$a_1, a_2, \ldots, a_T \sim P_\theta(\cdot \mid s_{t-1})$

where $T$ is the terminal step (either a special end-of-sequence token or a maximum generation length). The reasoning state at each step is defined cumulatively:

$s_0 := x,\quad s_t := (x, a_1, \ldots, a_t) \text{ for } t \geq 1$

where $s_0$ is the initial input (just the problem), and each subsequent $s_t$ is the concatenation of the input and all tokens generated so far. This definition captures the autoregressive nature of the process: each token $a_t$ conditions on the entire history of previously generated tokens.

The key move is to treat reasoning as self-conditioning: each generated token refines the model's belief over the target variable $Y$ (the correct answer) without introducing external evidence. The model's predictive distribution over $Y$ at step $t$ is $P_\theta(Y \mid s_t)$ , and the information gain of a single step is the reduction in uncertainty:

$\Delta_t := H(Y \mid s_{t-1}) - H(Y \mid s_t)$

where $H(\cdot)$ is Shannon entropy (measured in bits, though the units are not crucial for the analysis), $H(Y \mid s_{t-1})$ is the uncertainty about the correct answer given the context up to step $t-1$ , $H(Y \mid s_t)$ is the uncertainty after processing token $a_t$ , and $\Delta_t$ is the reduction in that uncertainty.

What this computes: information gain $\Delta_t$ measures how much less uncertain the model is about the correct answer $Y$ after seeing token $a_t$ compared to before. If the token provides useful procedural information — a calculation that narrows down possibilities, a variable assignment that constrains the solution space — then $\Delta_t$ is positive. If the token is irrelevant or reinforcing an incorrect path, $\Delta_t$ is near zero. The total information accumulated over the trajectory is the sum $\sum_{t=1}^T \Delta_t = H(Y \mid s_0) - H(Y \mid s_T)$ , and the objective of reasoning can be stated as minimizing $H(Y \mid s_T)$ , the residual uncertainty at the end of the trajectory.

Why this form: the use of Shannon entropy and information gain frames reasoning as an information accumulation process, which aligns with prior information-theoretic analyses of Chain-of-Thought (Ton et al., 2025; Liang, 2025). The advantage of this formalization is that it provides a token-level accounting of progress toward the correct answer: each token either contributes to reducing uncertainty ( $\Delta_t > 0$ ) or does not ( $\Delta_t \approx 0$ ). This enables the paper to ask a precise question that prior work did not: when the model enters an incorrect trajectory, do procedural tokens still produce positive $\Delta_t$ ? The answer (empirically, no — they produce near-zero $\Delta_t$ in silent divergence) motivates the need for a second informational channel. An alternative formalization that treated reasoning as a single optimization problem over the full trajectory would not distinguish between tokens that contribute to the answer and tokens that monitor or reassess the trajectory — the key distinction the paper needs to make.

Procedural Reasoning and Its Collapse: Characterizing the Failure Mode

The paper defines procedural reasoning as the dominant class of self-generated evidence in LLM reasoning: explicit step-by-step computations, symbolic manipulations, variable instantiations, and executions of learned subroutines. Formally, the reasoning trace is partitioned into sub-tasks at indices $0 = t_0 < t_1 < \cdots < t_K = T$ , with task-level state $U_k := (x, a_1, \ldots, a_{t_k})$ . Procedural reasoning is then modelled as:

$U_k = \Lambda_\theta(U_{k-1}, \tau_k)$

where $\Lambda_\theta$ is an autoregressive execution operator parameterized by $\theta$ , $\tau_k$ is sub-task $k$ (e.g., "solve for x," "apply the quadratic formula"), $U_{k-1}$ is the state after completing sub-task $k-1$ , and $U_k$ is the state after executing sub-task $k$ . The operator $\Lambda_\theta$ implements the sub-task by generating the necessary tokens conditioned on the previous state.

What this computes: this defines procedural reasoning as a sequence of discrete sub-task executions, each of which takes the current state and produces the next state by autoregressively generating the tokens that implement the sub-task. The model's belief about $Y$ at sub-task boundary $k$ is $P_\theta(Y \mid U_k)$ , and procedural information gain is the reduction in $H(Y \mid U_k)$ across sub-task boundaries.

Why this form: the sub-task decomposition is necessary to analyze where procedural reasoning goes wrong. In the silent divergence regime, the model continues executing sub-tasks — producing tokens that look like valid step-by-step reasoning — but the information content of those tokens with respect to $Y$ is near zero. The partitioning enables the paper to specify the assumption that procedural information is trigger-conditional (Assumption 5.1): for $k > k^*$ (after divergence at sub-task $k^*$ ), procedural tokens provide information gain about $Y$ only when an overt error ( $E_k = 1$ ) triggers revision. Without sub-task boundaries, there is no natural place to define "after divergence" or "overt error detection."

The paper quantifies how this regime fails in practice through an empirical analysis of reasoning collapse across six models from the Qwen2.5 and Qwen3-Base families on four math benchmarks (AIME24, AIME25, AMC23, MATH500). The methodology (detailed in Appendix D.1) works as follows:

For each model, sample $N = 8$ traces per problem across 600 problems (4,800 responses per model).
Filter to incorrect responses only (this isolates the failure cases).
Pass each incorrect response to an LLM judge (GPT-5-2025-08-07) with a structured prompt that classifies the trace into one of five collapse types or returns "no collapse."

The five collapse types, as defined in the judge prompt (Appendix D.1), are:

Repetition: repeating the same sentences, phrases, or steps in a loop — the model gets stuck and produces the same output repeatedly without making progress.
Topic drift: suddenly solving a completely different or made-up problem — the model loses track of what it was supposed to solve and starts addressing an unrelated question.
Incoherence: statements become logically disconnected or nonsensical mid-solution — the surface appearance of reasoning breaks down.
Infinite loop: cycling through the same dead-end approach repeatedly without progress — the model keeps trying a method that cannot work.
Hallucination spiral: inventing fictitious theorems, formulas, or numeric facts and building on them — the model's errors compound as it treats its own fabrications as established facts.

The results (Figure 2, Table 6) are striking: across all models and benchmarks, 54–62% of incorrect responses exhibit reasoning collapse, with the collapse rate rising sharply with problem difficulty. For example, on AIME25 (the hardest benchmark), collapse occurs in 78–83% of incorrect responses. The collapse rate among incorrect responses is relatively stable across model scales — larger models reduce the total error rate but leave the share of collapse among remaining errors roughly unchanged, indicating that scaling reduces surface-level mistakes faster than silent divergence.

The distribution of collapse types varies by model family (Figure 2b), but incoherence and hallucination spirals are consistently the most common patterns. The crucial property shared by all collapse modes is that the surface structure of step-by-step execution is preserved: the output looks like reasoning — it has sentences, mathematical notation, step labels — but it does not accumulate information about the correct answer. The model's belief $P_\theta(Y \mid s_t)$ drifts from the correct $Y$ without producing any overt error that would trigger reactive correction. This is the silent divergence that the epistemic verbalization mechanism is designed to address.

The paper emphasizes a critical point about what this analysis does not show: collapse is not a failure to generate coherent text — the model remains locally fluent — but a failure to accumulate information about $Y$ . The procedural channel continues to operate (tokens are generated, sub-tasks appear to be executed), but the information signal about the correct answer is effectively zero. This is why prior information-theoretic accounts, which treated all tokens as procedural steps, could not explain recovery: they assumed each step provides information gain about $Y$ , but in silent divergence, it does not.

Reactive vs. Proactive Correction: The Empirical Puzzle

Building on the collapse analysis, the paper investigates how models escape (or fail to escape) incorrect trajectories by classifying self-correction events into two modes. The analysis spans both standard LLMs and Large Reasoning Models (LRMs: DeepSeek-R1-Distill-Qwen-7B/32B, Qwen3-8B/14B). The two-stage classification pipeline (detailed in Appendix D.2) operates as follows:

Stage 1: Self-correction detection. All correct-answer responses are passed to a GPT-5 judge with a prompt that checks for a specific pattern: (1) the solver initially pursues a wrong approach or makes a significant mistake, (2) the solver recognizes the error, (3) the solver abandons the wrong path and takes a different approach, and (4) the solver arrives at the correct final answer. This identifies trajectories that contain a genuine recovery from error — not just a correct answer produced on the first attempt.

Stage 2: Trigger classification. The identified self-correction cases are then classified by a second GPT-5 prompt into:

Reactive correction (evidence-based): the model encountered a clear, explicit signal that something was wrong before deciding to correct. Examples include: a mathematical result that is impossible (negative length, $\sin > 1$ , division by zero), a result that explicitly violates a stated condition ( $x = 6$ but problem says $x > 7$ ), a logical contradiction derived from the work ( $6 = 3$ , empty solution set), or an exhausted search that found nothing (tried all cases, none worked).
Proactive correction (suspicion-based): the model decided to re-examine without a clear signal of error. Examples include: vague unease ("let me reconsider," "I'm not sure," "let me double-check"), trying a different approach without identifying what was wrong, or re-examination triggered by aesthetic or intuitive concern rather than a concrete contradiction.

The results (Table 1) reveal a stark asymmetry. In standard LLMs (Qwen2.5-7B, Qwen2.5-32B, Qwen3-1.7B/8B/14B-Base, Qwen2.5-Math-7B), self-correction occurs in at most 35 of 4,800 generations (under 1%) and is overwhelmingly reactive: proactive corrections account for 0–20.5% of these already-rare events. In LRMs (Qwen3-8B/14B instruct, DeepSeek-R1-Distill-7B/32B), proactive corrections account for 22.2–35.0% of self-corrections, and the total number of self-correction events is orders of magnitude higher (hundreds of events per model rather than single digits). This quantifies the behavioral gap: standard LLMs almost never proactively question their own reasoning, while LRMs do so regularly.

The paper introduces a capability map (Figure 3) that situates this distinction in the broader model landscape. The x-axis is direct fluency, defined as the share of responses answered correctly without invoking any self-correction:

$\text{Direct Fluency} = \frac{\text{correct} - \text{SC}}{N}$

where $\text{correct}$ is the total number of correct responses, $\text{SC}$ is the number of responses that reached the correct answer via self-correction, and $N$ is the total number of responses. This measures how often the model gets the answer right on the first attempt without needing to correct itself. The y-axis is the proactive correction rate, the share of total responses that contain a suspicion-based self-correction. Standard LLMs cluster along the bottom of the plot regardless of their direct fluency — even models with reasonable procedural accuracy (Qwen2.5-32B, Qwen2.5-Math-7B) show near-zero proactive correction rates. Reasoning-tuned models (DeepSeek-R1 distillations, Qwen3 instruct variants) occupy a distinct upper-right region where higher direct fluency is paired with a qualitatively new capacity for proactive correction. This suggests that proactive correction is not simply a byproduct of better procedural reasoning — it is a distinct capability axis that emerges through specific training (likely reinforcement learning or reasoning-focused instruction tuning).

The paper then addresses a natural objection: if proactive corrections are so frequent in LRMs, how accurate are they? The precision of proactive signals (Table 2) is defined as the fraction of suspicion-triggered corrections issued on a trajectory that was in fact wrong (as judged by GPT-5 on 80 sampled traces per model, 320 total). Across LRMs, precision averages only 24.4%: roughly three out of four proactive verbalizations second-guess an already-correct chain. DeepSeek-R1 distillations are better calibrated (37.3% for 7B, 23.9% for 32B) than the Qwen3 instruct series (20.5% for 8B, 15.8% for 14B), and precision does not improve with model scale.

This low precision might seem like a weakness, but the paper argues it is actually a strength when considered in the context of silent divergence. The silent divergences that dominate LLM failures (Figure 2) never produce an overt error — they provide no trigger for reactive correction to act on. In this regime, even a noisy signal is more useful than a precise one that never fires. A proactive correction that second-guesses a correct chain 75% of the time is wasteful but not catastrophic (the model may simply verify and continue), whereas a reactive correction that never fires on silently diverged trajectories guarantees failure. The precision analysis thus reframes the normative question: the goal is not to maximize the accuracy of correction signals in isolation, but to maximize recovery from genuinely incorrect trajectories. Proactive correction achieves this by providing a non-zero probability of detection in the regime where reactive correction provides zero.

This empirical puzzle — LRMs exhibit a behavior (proactive correction) that standard LLMs lack, and this behavior is causally linked to recovery from silent divergence — sets up the paper's central theoretical contribution. The next section defines the mechanism that explains why proactive correction works: epistemic verbalization.

Epistemic Verbalization: Definition and Information-Theoretic Role

The paper defines epistemic verbalization as the linguistic channel through which the model explicitly externalizes uncertainty about its own trajectory, turning otherwise inert internal assessments into conditionable tokens that subsequent reasoning can act on. This is distinct from procedural advancement: epistemic utterances do not advance the computation toward the answer (they do not perform calculations, assign variables, or execute subroutines), but instead express judgments of uncertainty or doubt about intermediate steps. Examples from DeepSeek-R1-Distill-Qwen reasoning traces (Table 3) include:

"Wait, is that correct?"
"Wait, 2023 is 7 multiplied by 17 squared, right?"
"Wait, maybe f(n) is related to the Möbius function but scaled differently."
"Wait, perhaps I can write it as $(f * (n/d))(n) = 1$ , but that doesn't seem helpful."

These utterances share a structure: they pause the procedural flow and express a meta-cognitive assessment (doubt, uncertainty, a desire to verify) without advancing the computation itself.

The formal grounding of epistemic verbalization introduces a latent epistemic variable $Z_t$ at each step $t$ , representing the model's internal assessment of its trajectory's reliability — essentially, the model's estimate of whether the current path is productive toward the correct answer $Y$ . This variable is informative: the mutual information $I(Y; Z_t \mid s_{t-1})$ may be strictly positive, meaning the model's internal uncertainty carries information about the correct answer. The critical problem is that as a latent variable, $Z_t$ is informationally inert: since autoregressive decoding conditions on the realized token sequence $s_{t-1}$ , not on internal hidden states, the information in $Z_t$ cannot influence subsequent generation unless it is externalized. The model could internally "know" that it is on a wrong path — its hidden states could encode high uncertainty about $Y$ — but if it never generates tokens that reflect that assessment, the uncertainty cannot affect what it generates next.

Epistemic verbalization closes this gap by emitting tokens $v_t$ from which $Z_t$ is recoverable (in the information-theoretic sense — the tokens carry sufficient information to reconstruct the uncertainty assessment). Once $v_t \in s_t$ (the verbalization enters the autoregressive context), the model's subsequent predictions can condition on the fact that it expressed doubt at step $t$ . Formally, this produces the inequality:

$H(Y \mid s_{t-1}, v_t) \leq H(Y \mid s_{t-1})$

where $H(Y \mid s_{t-1})$ is the uncertainty about the correct answer given the context before the epistemic verbalization, $H(Y \mid s_{t-1}, v_t)$ is the uncertainty after seeing the verbalized doubt, and the inequality is strict whenever $v_t$ carries non-trivial information about $Z_t$ (i.e., when the verbalization genuinely reflects internal uncertainty rather than being an empty surface form).

What this inequality states: after the model generates an epistemic verbalization token, its uncertainty about the correct answer $Y$ is at most what it was before — the verbalization does not increase uncertainty, and typically decreases it because it makes the model's internal assessment of trajectory reliability available for conditioning. This is the informational role of epistemic verbalization: it converts a latent assessment that could not affect generation into a conditionable token that can.

Why this form: the inequality uses entropy reduction as the measure of informational value, which is consistent with the self-conditioning framework in Section 3.1. It captures the idea that epistemic verbalization is not itself a correction — it does not change the answer — but it enables subsequent correction by making trajectory uncertainty visible in the token stream. An alternative framing that treated epistemic verbalization as a direct correction mechanism (e.g., "the model says 'Wait' and then fixes the error") would miss the crucial distinction between information (the verbalization) and control (the correction action that follows). The inequality also clarifies why empty surface forms of "Wait" (those that do not reflect genuine $Z_t$ information) fail: they carry no information about $Y$ , so the inequality is an equality ( $H(Y \mid s_{t-1}, v_t) = H(Y \mid s_{t-1})$ ) and no progress is made.

The Intervention Study: Injecting Epistemic Verbalization Recovers Failed Trajectories

The paper validates the causal role of epistemic verbalization through a controlled intervention study on failed reasoning trajectories. This is the key empirical demonstration that epistemic verbalization is not merely correlated with good reasoning — it is causally responsible for recovery from incorrect paths.

Setup. The experiment collects all incorrect rollouts (8 per problem) from Qwen3-8B-Base and Qwen3-14B-Base — models that predominantly exhibit procedural reasoning with minimal spontaneous epistemic verbalization — on three benchmarks: AIME24 (difficult), AMC23 (moderate), and MATH500 (relatively easier). Since every rollout in this set is incorrect, it must have diverged from a valid reasoning path at some unknown point. The experiment therefore sweeps candidate truncation points: for each failed rollout, generation was truncated at a relative position $\alpha \in \{0.2, 0.5, 0.8, 0.9\}$ , meaning the first $\alpha$ -fraction of tokens was kept and the rest was discarded. From each truncation point, generation was resumed with one of five conditions (Table 4), drawing $n = 4$ continuations per condition.

The five conditions are carefully designed to isolate the effect of epistemic verbalization from the effect of mere re-sampling:

NONE: no injection — just resume generation from the truncated prefix using the base model's standard sampling. This controls for the possibility that simply re-sampling from a prefix inherently improves outcomes (e.g., because the truncation point happens to be before the divergence, giving the model a second chance).
HMM-DOUBT: insert the phrase "Hmm, I'm not sure this is right." This expresses uncertainty alone — it does not explicitly instruct the model to re-examine or correct anything. The word "Hmm" is a hesitation marker, and "I'm not sure this is right" expresses doubt without indicating what to do about it.
HMM-DOUBT-REVISIT: insert "Hmm, I'm not sure this is right. Let me reconsider." This combines the doubt expression with an explicit signal of intent to re-examine the reasoning. The addition of "Let me reconsider" distinguishes the effect of doubt alone from doubt-plus-intent.
WAIT-DOUBT: insert "Wait, is that correct?" This phrase uses the "Wait" token family (which Section 4.2 identifies as the most frequent epistemic token) and expresses doubt through a question about correctness. It does not explicitly direct the model to re-examine — it merely questions the current state.
WAIT-REVISIT: insert "Wait, let me double-check." This combines "Wait" with an explicit revisitation signal, pairing the wait token with a directive to verify.

The conditions vary along two axes: phrase type (HMM vs. WAIT) and function (DOUBT alone vs. REVISIT with intent to re-examine vs. DOUBT-REVISIT combining both). This design tests whether the mere expression of uncertainty (DOUBT) is sufficient for recovery, or whether an explicit revisitation signal (REVISIT) is required. The HMM vs. WAIT axis tests whether the specific lexical form matters.

The recovery rate is the primary metric: the fraction of originally incorrect rollouts whose continuation (from the truncated prefix with the injected cue) reaches the correct answer. Recovery rate is reported as a function of truncation fraction $\alpha$ , injection condition, and benchmark.

Results (Figure 4). Across all benchmarks, model sizes, and conditions, injecting any form of epistemic verbalization significantly increases recovery rates compared to the NONE baseline. The key findings are:

DOUBT alone suffices. Even the minimal HMM-DOUBT condition ("Hmm, I'm not sure this is right."), which conveys only uncertainty without any explicit directive to re-examine or correct, produces meaningful recovery. On Qwen3-8B-Base on MATH500 at $\alpha = 0.5$ , HMM-DOUBT achieves roughly 18% recovery compared to roughly 8% for NONE — more than doubling the recovery rate. This demonstrates that the externalization of uncertainty itself, not the explicit instruction to re-examine, is what provides the actionable signal. The model, upon seeing that it expressed doubt, can autonomously decide to re-evaluate.
Recovery rates decline with truncation fraction $\alpha$ . When the truncation point is early ( $\alpha = 0.2$ , meaning only 20% of the original trace is kept), recovery rates are highest because the model has more room to recover — it is closer to the problem statement and has not yet deeply committed to the incorrect trajectory. As $\alpha$ increases to 0.9 (90% of the trace preserved, truncation very late), recovery rates decline for all conditions. However, the decline is asymmetric: the NONE baseline decays fastest, dropping to near zero at $\alpha = 0.9$ , while the epistemic injection conditions retain some recovery capacity. This means the gap between injected cues and the baseline widens with $\alpha$ — epistemic verbalization is most valuable precisely when the model is most deeply committed to an incorrect path, because re-sampling alone (NONE) provides no benefit at that point.
Recovery tracks benchmark difficulty. Recovery rates are highest on MATH500 (the easiest benchmark), moderate on AMC23, and lowest on AIME24 (the hardest). This is expected: on easier problems, the model is closer to the correct answer even when it diverges, so epistemic verbalization can more easily nudge it back on track. On harder problems, the model may lack the underlying capability to solve the problem regardless of correction signals.
Phrasing differences are small but consistent. WAIT-style cues slightly outperform HMM-style cues across most settings, though the differences are modest. The DOUBT-REVISIT variants (which combine doubt with revisitation intent) do not consistently outperform DOUBT-alone variants, suggesting that the informational content of the doubt expression — not the explicit directive — is the active ingredient. This aligns with the theoretical framework: epistemic verbalization provides conditionable information about trajectory uncertainty; the model's control policy can then decide how to act on that information, regardless of whether the verbalization explicitly says "let me reconsider."
Robustness to model scale. The same pattern holds for both Qwen3-8B-Base and Qwen3-14B-Base, with the 14B model showing slightly higher baseline recovery rates but similar relative gains from epistemic injection. This suggests the effect is not a quirk of a particular model size.

Interpretation. The intervention study demonstrates that epistemic verbalization is causally sufficient for recovering failed trajectories, at least probabilistically. The model does not need to know what went wrong — it only needs to know that something might be wrong. The externalization of this uncertainty converts a latent assessment into a conditionable signal that the model can act on, enabling it to detect and correct errors that would otherwise remain invisible. This aligns with the theoretical claim that epistemic verbalization provides trigger-independent information gain (Assumption 5.2): it works even when no overt error has surfaced, which is precisely the silent divergence regime where standard LLMs fail.

A subtle point: the intervention study shows that epistemic verbalization causes recovery when injected exogenously, but it does not show that the model would have spontaneously generated such verbalizations. This is where the distinction between standard LLMs and LRMs becomes crucial: standard LLMs have the capability to benefit from epistemic verbalization (as shown by the injection study), but they lack the habit of generating it spontaneously. LRMs, through their training (likely reinforcement learning or instruction tuning that rewards self-monitoring), have acquired this habit. The paper's distillation experiments (Section 6.2–6.3) provide direct evidence for this interpretation by showing that the habit can be instilled or suppressed through small-scale SFT.

Epistemic Tokens as Measurement Proxies

To operationalize epistemic verbalization for the later experiments (test-time suppression, distillation analysis), the paper identifies a set of surface tokens that reliably co-occur with epistemic verbalization. This is a practical necessity: while the linguistic realizations of uncertainty expression are numerous and diverse (different models may use different vocabulary, and even the same model may vary its phrasing), the paper needs a tractable set of tokens to manipulate at test time and to measure in training data.

The identification procedure (detailed in Appendix D.4) works as follows:

Take all proactive (suspicion-based) self-correction cases identified by the classification pipeline in Appendix D.2 for the four LRMs that exhibit meaningful proactive correction rates (Qwen3-8B/14B instruct, DeepSeek-R1-Distill-Qwen-7B/32B).
Pass each case to a GPT-5 judge with a characterization prompt that asks it to: (a) extract the minimal "trigger tokens" — the 1–5 word core phrase that most directly expresses the uncertainty (e.g., "Wait, maybe," "Hmm," "I'm not sure"), (b) assign a free-form verbalization label in snake_case based on what it observes (not from a predefined list), and (c) describe in one sentence what internal state the model is expressing through this verbalization.
Aggregate the trigger token frequencies across all models and traces, producing a list of candidate tokens ranked by how often they appear in the minimal trigger phrases extracted by GPT-5.

The resulting frequencies were: "wait" (73.0%), "maybe" (32.9%), "actually" (12.4%), "check" (10.5%), "hmm" (8.3%), "perhaps" (8.2%), "might" (6.6%), "seems" (3.3%), and "alternatively" (1.2%). The paper adopts these nine terms as epistemic tokens: "wait," "hmm," "perhaps," "maybe," "actually," "alternatively," "seems," "might," and "check."

What these tokens capture: they are surface indicators of regions in the reasoning trace where epistemic verbalization is likely occurring. They are lexical correlates of the underlying mechanism (externalization of uncertainty about trajectory reliability), not the mechanism itself. The paper is careful to note this distinction: the tokens serve as practical proxies for measurement and manipulation, but the framework does not depend on this specific set. The core theoretical results (Proposition 5.3, the information-theoretic inequality) refer to epistemic verbalization as an informational category, not to any particular vocabulary item.

Why these specific tokens: the high frequency of "wait" (73.0%) aligns with prior observations that "Wait" is the most common surface marker of self-reflection in reasoning traces (d'Aliberti and Ribeiro, 2026; Qian et al., 2025). The lower frequency of tokens like "hmm" (8.3%) and "perhaps" (8.2%) reflects that these tokens are used less consistently but still appear with non-trivial frequency. The inclusion of "actually" and "alternatively" captures cases where the model signals a shift in its thinking without explicit doubt expressions — these are still epistemic verbalizations because they externalize a change in the model's assessment of its trajectory, even if the surface form does not explicitly say "I'm uncertain."

Limitations acknowledged by the paper: the nine epistemic tokens serve as practical proxies and do not cover the full range of uncertainty expressions. Some models may use vocabulary outside this set (e.g., "hold on," "let me verify," "that doesn't seem right"), and the test-time suppression experiments (Section 6.1) observe exactly this: models sometimes route around suppressed tokens by substituting equivalents (shown in Appendix H.1, Table 8, with examples like "But hold on, let me..." replacing "Wait, let me check..." and "No, that's not quite right" replacing "Hmm..."). The paper notes that "a more thorough linguistic analysis of these proxies may be warranted" (Limitations section), and the core results do not rely on this specific token set being exhaustive.

The Unified Framework: Reasoning as Strategic Information Allocation

Building on the preceding empirical observations and theoretical definitions, the paper formalizes the distinction between procedural and epistemic information within a unified information-theoretic framework. The goal is to prove that sporadic epistemic verbalization suffices to restore convergence toward the correct answer, regardless of whether procedural error signals are available, and to separate the informational mechanism from the control actions that act on it.

The framework is built on two assumptions that capture the empirical patterns documented in Sections 3–4:

Assumption 5.1 (Procedural Information is Trigger-Conditional). Suppose the procedural trajectory enters a diverged execution path at sub-task index $k^*$ (i.e., after sub-task $k^*$ , the model's reasoning is no longer productive toward $Y$ ). For $k > k^*$ , let $E_k \in \{0, 1\}$ indicate whether sub-task $\tau_k$ surfaces an overt error available to procedural revision, and let $p_E := P(E_k = 1 \mid U_{k-1})$ be the probability that the $k$ -th sub-task produces a recognizable error given the state after sub-task $k-1$ . There exists $\delta_{\text{proc}} > 0$ such that:

$I(Y; U_k \mid U_{k-1}) \geq \delta_{\text{proc}} \quad \text{only if} \quad E_k = 1$

where $I(Y; U_k \mid U_{k-1})$ is the mutual information between the target answer $Y$ and the state after sub-task $k$ , conditional on the state after sub-task $k-1$ , and $\delta_{\text{proc}}$ is a positive constant representing the minimum information gain from a productive procedural step.

What this assumption states: after the model enters a diverged path (after sub-task $k^*$ ), procedural reasoning steps provide information about $Y$ (i.e., reduce uncertainty about the correct answer) only when the sub-task surfaces an overt error that triggers revision. In the silent divergence regime — where $E_k = 0$ because the surface structure looks fine — procedural steps provide effectively zero information gain about $Y$ , even though they produce locally coherent tokens. This formalizes the collapse analysis in Section 3.2: when no error surfaces ( $p_E \approx 0$ ), procedural information acquisition stalls in expectation.

Why this form: the assumption uses mutual information $I(Y; U_k \mid U_{k-1})$ rather than the simpler entropy reduction $\Delta_t$ to capture the dependence on the trigger variable $E_k$ . The mutual information formalization allows the paper to state that the procedural channel is conditionally informative — it provides information only when $E_k = 1$ — which directly captures the reactive correction pattern observed in standard LLMs (Table 1). An alternative assumption that procedural information gain was independent of error detection would fail to explain why standard LLMs cannot recover from silent divergence: they would still be accumulating information about $Y$ even on incorrect paths, which contradicts the empirical evidence that they collapse.

Assumption 5.2 (Epistemic Informativeness). There exist $\delta > 0$ and a threshold $\eta > 0$ such that, at every step $t$ where an epistemic token is generated and $H(Y \mid \tilde{S}_{t-1}) > \eta$ (the residual uncertainty about $Y$ is still substantial):

$H(Y \mid \tilde{S}_{t-1}) - H(Y \mid \tilde{S}_t) \geq \delta$

independently of whether an overt error has surfaced at the current sub-task. Here $H(Y \mid \tilde{S}_{t-1})$ is the entropy of $Y$ given the state before the epistemic verbalization, $H(Y \mid \tilde{S}_t)$ is the entropy after, and $\delta$ is a positive constant representing the minimum information gain from an epistemic verbalization step.

What this assumption states: whenever the model's uncertainty about $Y$ is still substantial ( $H(Y \mid \tilde{S}_{t-1}) > \eta$ , meaning the model hasn't yet converged to certainty about the answer), generating an epistemic token produces a non-trivial reduction in that uncertainty ( $\geq \delta$ ), and this reduction occurs regardless of whether the procedural channel has flagged an error. The key property is trigger-independence: epistemic verbalization provides information gain even when $E_k = 0$ , i.e., even in the silent divergence regime where procedural steps provide no information.

Why this form: the assumption captures the empirical finding from the intervention study (Section 4.1, Figure 4) that injecting a doubt cue alone — without pinpointing any error — meaningfully enables recovery. The threshold $\eta$ prevents the assumption from applying when the model is already nearly certain about $Y$ (in which case epistemic verbalization would provide negligible additional benefit). The constant $\delta$ provides a lower bound on the benefit, which is needed for the convergence proof that follows. The trigger-independence is the crucial difference from Assumption 5.1: epistemic verbalization does not wait for an error to surface; it proactively externalizes uncertainty, providing information gain even when $p_E \to 0$ .

Given these assumptions, the paper's central theoretical result is:

Proposition 5.3 (Sporadic Epistemic Verbalization Suffices for Convergence). Under Assumption 5.2, if an epistemic token is generated with at least some non-zero probability $\rho \in (0, 1]$ whenever $H(Y \mid \tilde{S}_t) > \eta$ , then $\mathbb{E}[H(Y \mid \tilde{S}_t)] \to 0$ as $t \to \infty$ , regardless of the procedural trigger probability $p_E$ .

The formal statement and proof are provided in Appendix A. The proof defines $H_t := H(Y \mid \tilde{S}_t)$ as the residual uncertainty at step $t$ , and $\tau_\eta := \inf\{t \geq 0 : H_t \leq \eta\}$ as the first time the entropy drops below the threshold $\eta$ . Let $V_t \in \{0, 1\}$ indicate whether an epistemic token is generated at step $t$ , and let $\Delta_t := H_{t-1} - H_t \geq 0$ be the entropy reduction. By Assumption 5.2 and the lower bound $\mathbb{P}(V_t = 1 \mid \tilde{S}_{t-1}) \geq \rho$ , on the event $\{H_{t-1} > \eta\}$ the expected information gain satisfies:

$\mathbb{E}[\Delta_t \mid \tilde{S}_{t-1}] \geq \delta \cdot \mathbb{P}(V_t = 1 \mid \tilde{S}_{t-1}) \geq \rho\delta$

which depends only on $(\rho, \delta)$ and not on $p_E$ — the procedural trigger probability is irrelevant. Telescoping up to $\tau_\eta$ and taking expectations yields:

$\mathbb{E}[H_0] - \eta \geq \mathbb{E}[H_0] - \mathbb{E}[H_{\tau_\eta}] \geq \rho\delta \cdot \mathbb{E}[\tau_\eta]$

Rearranging gives $\mathbb{E}[\tau_\eta] \leq (\mathbb{E}[H_0] - \eta) / (\rho\delta)$ , which is finite. If such pairs $(\rho(\eta), \delta(\eta))$ exist for every $\eta > 0$ , then $\mathbb{E}[\tau_\eta] < \infty$ for all $\eta > 0$ , so $\mathbb{E}[H_t] \to 0$ .

What this proposition proves: even if epistemic verbalization occurs only sporadically (with probability $\rho$ , which could be small) — and even if $\rho$ is the only source of corrective signal because procedural triggers never fire ( $p_E \approx 0$ ) — the expected uncertainty about the correct answer converges to zero as the number of reasoning steps grows. The convergence rate is bounded by $\rho\delta$ , the product of the verbalization probability and the per-step information gain. Higher $\rho$ (more frequent epistemic verbalization) or higher $\delta$ (more informative verbalizations) leads to faster convergence.

Why this matters: the proposition provides a theoretical explanation for the empirical patterns in Sections 3–4. Standard LLMs fail in the silent divergence regime because $\rho \approx 0$ — they almost never generate epistemic verbalizations unless triggered by an overt procedural error ( $E_k = 1$ ). When $p_E \approx 0$ (silent divergence), their effective information gain rate is near zero, and they drift indefinitely. LRMs succeed because $\rho$ is non-trivial — their training has instilled a habit of generating epistemic verbalizations even without error triggers, providing a steady trickle of information gain that eventually pulls the belief back toward the correct answer. The proposition also explains the precision analysis (Table 2): precision can be low (24.4%) without undermining convergence, because the expected information gain $\mathbb{E}[\Delta_t]$ depends on $\rho\delta$ , not on precision. A noisy signal that fires frequently can still drive convergence, as long as it provides some positive expected information gain.

The paper then builds on this result to separate information from control (Section 5.2). Self-correction is a control action — a decision to revise, backtrack, or verify — that fires whenever the accumulated conditionable information (from both procedural error signals and epistemic verbalization) indicates a need to change course. Epistemic verbalization is the informational mechanism that supplies that conditionable information; it does not itself perform the correction. This distinction is crucial for explaining the mixed prior findings on Aha moments: when "Wait" appears as an empty surface form (high-entropy filler without genuine uncertainty externalization), it provides no information for the control policy to act on, so it does not enable correction — consistent with d'Aliberti and Ribeiro (2026) and Liu et al. (2025). When "Wait" reflects genuine epistemic verbalization (externalization of $Z_t$ uncertainty), it provides the information the control policy needs, enabling correction — consistent with the behavior of LRMs. The same surface token can have different informational content depending on whether it reflects genuine internal uncertainty.

Test-Time Control of Epistemic Tokens

Section 6.1 of the paper demonstrates the causal importance of epistemic verbalization through a negative intervention: suppressing epistemic tokens at test time and measuring the resulting performance degradation. This is the inverse of the intervention study in Section 4.1 (which added epistemic cues to failed trajectories) — here, the paper removes the model's spontaneous epistemic verbalizations and asks whether reasoning performance suffers.

Setup. The experiment uses DeepSeek-R1-Distill-Qwen-14B and DeepSeek-R1-Distill-Qwen-32B — models that naturally produce frequent epistemic verbalizations during reasoning. Standard inference is compared against inference in which the nine epistemic tokens identified in Section 4.2 ("wait," "hmm," "perhaps," "maybe," "actually," "alternatively," "seems," "might," "check") are suppressed. Suppression is implemented via logit bias of -100 applied to these tokens: during autoregressive decoding, the model's predicted logits for these tokens are shifted downward by 100, effectively setting their probability to near zero and preventing the model from generating them. This forces the model to route around the suppressed vocabulary when it wants to express uncertainty.

The primary metric is avg@8 on AIME24 and AIME25: the average accuracy across 8 independent rollouts per problem, which is a standard metric for reasoning benchmarks that captures whether the model can solve the problem in at least one of multiple attempts.

Results (Figure 5). Suppressing epistemic tokens causes consistent performance drops:

DeepSeek-R1-Distill-32B on AIME24: drops from 72.08% (baseline) to 64.58% (suppressed), a decrease of approximately 7.5 percentage points or roughly 10.4% relative.
DeepSeek-R1-Distill-14B on AIME24: drops from 68.33% to 60.42%, approximately 7.9 percentage points.
DeepSeek-R1-Distill-32B on AIME25: drops from 55.00% to 47.92%, approximately 7.1 percentage points.
DeepSeek-R1-Distill-14B on AIME25: drops from 50.42% to 45.83%, approximately 4.6 percentage points.

Across all settings, the performance degradation is around 10% relative, with larger models and harder benchmarks showing somewhat larger absolute drops. Importantly, performance does not collapse entirely — the models retain substantial reasoning ability even when their primary epistemic vocabulary is suppressed.

Analysis of bypass pathways (Appendix H.1, Table 8). Inspection of the reasoning traces reveals that the models sometimes route around the masked tokens by substituting equivalents outside the banned vocabulary. Observed substitutions include:

"Wait, let me check..." → "But hold on, let me..."
"Hmm," → "No, that's not quite right" or "Hold on, no"
"Maybe / Perhaps" → "It's possible that..." or "Suppose..."
"Alternatively" → "Another way to see this"
"Actually" → "I realize" or "On closer look"
"Let me check" → "Let me verify"

In these cases, the underlying doubt-and-verify pattern is preserved, and only its lexical surface is rerouted. This explains why performance degrades but does not collapse: the models have learned to express uncertainty through a broader vocabulary than the nine suppressed tokens, and they adaptively switch to alternatives when their primary epistemic markers are blocked. The residual performance drop (approximately 10%) reflects the fact that these alternative routes are less natural for the model — they require the model to improvise uncertainty expressions rather than using its habitual vocabulary, which likely reduces the probability $\rho$ of epistemic verbalization and thus the effective information gain rate $\rho\delta$ .

Interpretation. The test-time suppression experiment confirms the causal importance of epistemic verbalization from the negative direction: removing the model's ability to express uncertainty in its habitual vocabulary impairs reasoning performance. The fact that models partially bypass the suppression demonstrates that epistemic verbalization is not tied to specific tokens — it is a functional capability (externalizing uncertainty) that can be realized through multiple surface forms. This aligns with the paper's theoretical framework, which defines epistemic verbalization in terms of its informational role (converting latent $Z_t$ to conditionable $v_t$ ) rather than its lexical realization. The 10% performance drop is likely a lower bound on the true importance of epistemic verbalization, because the bypass routes partially compensate for the suppression.

Suppressing Epistemic Verbalization via Distillation

Section 6.2 of the paper isolates the effect of epistemic verbalization more cleanly through a controlled self-distillation SFT experiment that suppresses epistemic verbalization at the training stage rather than at inference time. This avoids the bypass problem from Section 6.1: the model is trained on traces that never contain epistemic verbalization, so it never learns the habit in the first place rather than having to route around suppressed tokens.

Setup. For each base model (Qwen2.5-7B, Qwen3-8B-Base, Qwen3-14B-Base, DeepSeek-R1-Distill-7B, DeepSeek-R1-Distill-32B), the experiment follows these steps:

Append the instruction "Proceed directly without expressing uncertainty or doubt within the reasoning steps." to the problem prompt. This instruction explicitly directs the model to suppress epistemic verbalization during generation.
Collect 800 problems on which the model answers correctly under this instruction. This ensures that all training traces contain correct final answers — the model gets the problem right, it just does so without externalizing uncertainty along the way.
Use the resulting 800 reasoning traces as SFT (supervised fine-tuning) data. The training targets are the tokens in these traces; the model is fine-tuned to reproduce its own reasoning but without the epistemic verbalizations that would appear in its natural (unprompted) traces.
Evaluate the resulting fine-tuned variant on AIME24 pass@1, comparing to the base model's pass@1. The key comparison is between the base model (which was not fine-tuned) and the SFT variant trained on traces with epistemic verbalization suppressed — the only difference between them is the absence of epistemic verbalization in the training data, since all traces contain correct answers.

The choice of 800 training examples is deliberate and follows Ye et al. (2025, the LIMO work): 800 examples is far too few to instill new mathematical knowledge or teach new problem-solving strategies, so any performance changes must be attributed to changes in the model's linguistic habits (how it externalizes or suppresses uncertainty during reasoning) rather than to learning new substantive content.

Results (Table 5). Training on traces with epistemic verbalization suppressed consistently degrades performance:

Qwen2.5-7B: drops from 13.3% to 6.7% — performance is cut in half.
Qwen3-8B-Base: drops from 16.7% to 3.3% — an 80% reduction, the most dramatic degradation.
Qwen3-14B-Base: drops from 16.7% to 10.0% — a 40% reduction.
DeepSeek-R1-Distill-7B: drops from 50.0% to 30.0% — a 40% reduction.
DeepSeek-R1-Distill-32B: drops from 80.0% to 43.3% — a 46% reduction, nearly halving the performance of the strongest model.

The degradation is substantial across all model sizes and families, despite the fact that all training traces contain correct answers. This demonstrates that epistemic verbalization is not mere verbosity or stylistic decoration — removing it at training time impairs the model's reasoning capability even when the training data is otherwise identical (same problems, same correct answers, same model).

Connection to the capability map (Figure 3). The paper further analyzes these results by revisiting the capability map introduced in Section 3.4. LRMs (DeepSeek-R1 distillations) exhibit direct fluency comparable to that of standard LLMs but substantially higher proactive correction rates — they occupy a distinct upper-right region of the map. When epistemic verbalization is suppressed through the SFT procedure, the fine-tuned models show lower proactive correction rates, projecting them back toward the LLM region of the map. In other words, removing epistemic verbalization from the training data transforms an LRM's behavioral profile into that of a standard LLM — it loses the capacity for proactive self-correction that distinguishes it. This provides direct evidence that epistemic verbalization is the mechanism underlying the proactive correction behavior observed in LRMs: when you train the model to suppress it, the behavior disappears, and with it, a substantial fraction of reasoning performance.

Why SFT works for suppression. The paper's explanation is that SFT on 800 examples primarily reshapes the model's linguistic habits — which tokens it tends to generate in which contexts — rather than teaching new knowledge. By exposing the model to 800 trajectories where it gets the right answer without ever saying "Wait" or "Hmm," the fine-tuning teaches the model to route around epistemic verbalization even when it is internally uncertain. The model still has the same procedural reasoning capabilities (it can still perform calculations and execute subroutines), but it has been trained to suppress the externalization of uncertainty. The performance degradation shows that this suppression is harmful: without conditionable uncertainty signals, the model cannot recover from silent divergence, and its effective accuracy drops.

A subtle point: the SFT procedure trains on correct-answer traces, so the model is not learning that epistemic verbalization is wrong — it is learning that it is unnecessary (since the traces reach the correct answer without it). This means the performance degradation is not due to the model associating epistemic verbalization with errors; it is due to the model losing the habit of generating it, which reduces $\rho$ (the probability of epistemic verbalization) and thus the effective information gain rate. The Proposition 5.3 guarantee that sporadic epistemic verbalization suffices for convergence explains why reducing $\rho$ impairs performance without eliminating it entirely: as long as $\rho > 0$ , convergence is still guaranteed in expectation, but the convergence rate $\rho\delta$ decreases, meaning it takes more steps to recover from errors — and in practice, with finite generation budgets, this can mean the model never recovers within the allotted tokens.

Impact of Epistemic Verbalization on Reasoning Distillation

Section 6.3 of the paper examines a complementary phenomenon: instilling epistemic verbalization into base models through distillation from a dataset rich in epistemic verbalizations, and analyzing why this transfer succeeds for some models but fails for others. This is the positive counterpart to the suppression experiment in Section 6.2 — here, the paper adds epistemic verbalization to models that lack it, rather than removing it from models that have it.

Setup. The experiment uses the LIMO-v2 dataset (Ye et al., 2025), which consists of only 800 reasoning examples gathered from DeepSeek-R1, DeepSeek-R1-Distill-Qwen-32B, and QwQ-32B — models that extensively use epistemic verbalizations during reasoning. As shown in Figure 6, the LIMO dataset contains a substantial number of epistemic tokens: "Wait" alone appears 77.1 times per response on average, with "hmm" appearing 48.4 times and "perhaps" 46.8 times per response. This makes LIMO an ideal testbed for studying epistemic verbalization transfer: it is far too small (800 examples) to instill new mathematical knowledge, so any performance changes must come from the student model acquiring the epistemic verbalization habit from the teacher data.

The experiment fine-tunes multiple base models (Qwen2.5-7B, Qwen2.5-Math-7B, Qwen3-1.7B/8B/14B-Base, DeepSeek-Math-7B-Instruct) on the same LIMO dataset using the default LIMO training configuration (LLaMA-Factory with four B200 GPUs, following the hyperparameters from Ye et al., 2025). All models are trained on identical data with identical procedures; the only variable is the base model's characteristics.

Results — successful transfer (Figure 7).

Qwen2.5-7B: AIME24 pass@1 improves from 13.3% (base) to 36.7% (LIMO) and pass@32 from 26.7% to 53.3% — a 2.8× improvement in pass@1 and 2.0× in pass@32.
Qwen3-8B-Base: pass@1 improves from 16.7% to 40.0% and pass@32 from 46.7% to 80.0% — a 2.4× improvement in pass@1 and 1.7× in pass@32.
Qwen3-14B-Base: pass@1 improves from 16.7% to 60.0% and pass@32 from 60.0% to 86.7% — a 3.6× improvement in pass@1, making this the most dramatic gain.
Qwen3-1.7B-Base: pass@1 improves from 6.7% to 30.0% — a 4.5× relative improvement, though the absolute performance remains modest.

These improvements are remarkable for only 800 training examples — a dataset that is far too small to teach new mathematical content. The rapid gains confirm that epistemic verbalization is not a special model capability requiring scale or complex training but rather a linguistic habit that can be rapidly instilled when the base model is receptive to the teacher's epistemic vocabulary.

Results — failed transfer (Figure 7).

Qwen2.5-Math-7B: pass@1 drops from 16.7% (base) to 0.0% (LIMO) and pass@32 from 56.7% to 16.7% — catastrophic degradation despite the base model being a math specialist (Qwen2.5-Math-7B).
DeepSeek-Math-7B-Instruct: pass@1 drops from 3.3% to 0.0% and pass@32 from 13.3% to 0.0% — complete collapse.

These failures are striking because the models are trained on the same data that produced dramatic improvements for Qwen2.5-7B and Qwen3-Base variants. The failures cannot be attributed to model size (Qwen2.5-Math-7B is the same size as Qwen2.5-7B, which improved substantially) or to initial capability (Qwen2.5-Math-7B is a math specialist with higher base pass@32 than Qwen2.5-7B). Something specific to these models' token-level distributions prevents them from absorbing the epistemic verbalization habit.

Explanation — distributional alignment (Figure 8). The paper analyzes this discrepancy through token-level log probabilities of epistemic tokens, comparing successful and failed distillation cases. Specifically, the analysis computes the log-probability that each student model assigns to frequent epistemic tokens like "Wait" and "Alternatively" (aggregated over the LIMO training data) and compares these to the model's log-probability distribution over all tokens.

The contrast between successful and failed models is clear in Figure 8:

Successful models (Qwen2.5-7B, Qwen3-8B-Base) exhibit well-aligned distributions: epistemic tokens like "Wait" and "Alternatively" fall within the model's support — they have non-negligible probability under the base model's distribution, even if they are not the most probable tokens. The model's log-probability for these tokens is within the range it assigns to typical tokens in its vocabulary.
Failed models (Qwen2.5-Math-7B, DeepSeek-Math-7B-Instruct) show large gaps: epistemic tokens are far outside the model's support — the base model assigns near-zero probability to tokens like "Wait" or "Alternatively." The log-probability gap between these epistemic tokens and the model's typical token distribution is large.

Notably, in well-performing models, epistemic tokens remain low-probability and high-entropy relative to other tokens — they are not the model's preferred vocabulary, but they are within the range of tokens the model might plausibly generate. This is sufficient for the fine-tuning to shift the model's habits: the model already "knows" these tokens (they are in its vocabulary with some probability mass), and the SFT simply increases their generation probability in contexts of uncertainty. In poorly performing models, the epistemic tokens are essentially unknown — the base model assigns effectively zero probability to them — and 800 examples are insufficient to teach the model both that these tokens exist and how to use them appropriately.

Interpretation. The dispersion in distillation effectiveness from a high-reasoning teacher to base student models can be attributed to whether the base model's pre-existing characteristics are sufficiently "warmed up" to follow the teacher's epistemic verbalization pattern. When the student model's token distribution already assigns non-trivial probability to the teacher's epistemic vocabulary (even at low probabilities), the SFT rapidly reshapes the model's habits: it learns to generate these tokens in contexts where internal uncertainty is high, acquiring the epistemic verbalization capability and the associated reasoning benefits. When the student model's distribution places epistemic tokens far outside its support, the SFT cannot bridge the gap — the model never learns to externalize uncertainty because it never had the vocabulary to do so in the first place.

This finding has practical implications for reasoning distillation: the success of small-data reasoning transfer depends not just on the quality of the teacher traces but on the distributional alignment between student and teacher token vocabularies. A student model that has never encountered epistemic tokens during pretraining (or has encountered them only rarely) cannot rapidly acquire the epistemic verbalization habit, regardless of how good the teacher data is. This suggests that pretraining data mixtures that include diverse uncertainty expressions may be a prerequisite for effective small-scale reasoning distillation — a hypothesis the paper does not test but that follows directly from the framework.

Additional Analyses Supporting the Framework

The paper includes several supporting analyses that strengthen the connection between epistemic verbalization and information gain, and validate that the surface tokens used as proxies genuinely reflect underlying uncertainty.

Epistemic verbalization produces information gain (Appendix F). Building on Qian et al. (2025)'s observation that reasoning trajectories exhibit "MI peaks" (sharp increases in mutual information with the correct answer) at thinking tokens like "Wait," the paper extends this analysis to examine whether epistemic verbalization — not just the surface token — drives information gain. Using the HSIC-based mutual information estimator from Qian et al. (2025), the experiment measures the statistical dependence between the model's last-layer hidden representation at each token position and the ground-truth answer representation, tracking when answer-relevant information emerges in the model's internal representations.

The experiment compares two models from the same family on the same AIME24 problem (#7): Qwen3-8B-Base (which fails to recover from an incorrect trajectory) and Qwen3-8B-SFT (fine-tuned on reasoning traces rich in epistemic verbalization, which successfully recovers through self-correction). Both models initially commit to an incorrect trajectory, but only the SFT model recovers. As shown in Figure 10, Qwen3-8B-Base's MI collapses to near zero shortly after divergence — the model's internal representations lose all correlation with the correct answer. Qwen3-8B-SFT sustains elevated MI while producing evaluative expressions such as "Wait, let me check."

A closer inspection of high-MI regions (Figure 11) reveals a crucial nuance: MI rises at thinking tokens, but not always. Elevated MI appears in utterances that perform epistemic verbalization (evaluating the trajectory, expressing doubt), and thinking tokens occurring without such verbalization (e.g., "Hmm" in the left panel of Figure 11) do not trigger an MI increase. This demonstrates that the surface tokens ("Wait," "Hmm") are not themselves the source of information gain — they are markers of the underlying epistemic verbalization process, which is what actually drives the increase. This finding validates the paper's theoretical distinction between epistemic verbalization as an informational category and specific tokens as surface manifestations.

Token-level entropy fails as a corrective signal (Appendix C, Figure 9). The paper demonstrates that token-level entropy — the model's local uncertainty about its next token prediction, $H(A_t \mid s_{t-1})$ — fails to distinguish correct from incorrect reasoning. On AIME24 with Qwen2.5-Math-7B and Qwen3-14B-Base, token-level entropy decreases similarly in both correct and incorrect solutions: the model becomes locally more confident at comparable rates regardless of whether its trajectory is productive. This means that even if the model could access its own token-level entropy (which it implicitly does, since it computes the probability distribution), this signal would not reliably indicate when it is on a wrong path. The failure occurs because token-level entropy captures local fluency confidence rather than global uncertainty about the target answer — a model can be highly confident about each next token while being globally wrong, exactly the silent divergence pattern.

Uncertainty verbalization tracks problem difficulty (Appendix G). Analyzing DeepSeek-R1-Distill-Qwen models from 1.5B to 14B parameters on AIME24/25, AMC23, and MATH500, the paper shows that smaller models and harder benchmarks elicit more frequent epistemic token usage. For example, relative to the 14B model, the 1.5B model produces 75% more occurrences of "Wait" and 234% more of "Perhaps" on AIME24 (Figure 13). Epistemic tokens appear more frequently on harder benchmarks (AIME24/25) and less frequently on easier ones (AMC23/MATH500). This confirms that epistemic verbalization genuinely reflects the uncertainty the model experiences during reasoning: when problems are harder (beyond the model's comfortable capability range), the model verbalizes uncertainty more often.

A parallel analysis on Qwen3-Base models distilled with LIMO (Appendix G, Figure 14) shows similar patterns: smaller models and harder problems elicit more epistemic tokens, though the specific vocabulary shifts toward the teacher's distribution (predominantly "Wait," with less use of "perhaps" because the LIMO dataset contains fewer instances of that token). This demonstrates that patterns of uncertainty verbalization can be shaped by training data distribution while still reflecting underlying uncertainty.

Reactive vs. proactive correction examples (Appendix I, Table 9). The paper provides representative examples of both correction modes to ground the abstract taxonomy in concrete traces. Reactive corrections include: Qwen2.5-32B-Instruct deriving $x = 6$ which violates the constraint $x > 7$ ("However, we are given that $x > 7$ . Therefore, we need to re-evaluate the vertices."); DeepSeek-R1-Distill-32B obtaining a negative length ("Wait, negative length? That can't be."); and Qwen3-14B finding a function evaluation that contradicts monotonicity claims ("Wait, so it increases up to some point and then decreases? That contradicts my previous thought."). Proactive corrections include: DeepSeek-R1-Distill-32B serially recalling formulas with no computation performed ("Wait, perhaps I should look for a different approach."); Qwen3-14B correctly analyzing a game tree with no error present ("Wait, maybe I need to think again."); and DeepSeek-R1-Distill-32B correctly identifying a losing position ("Wait, maybe I'm getting confused."). These examples illustrate the trigger-independence of proactive correction: the model questions its trajectory without any overt error to trigger the correction.

Summary of Design Choices and Their Justifications

Closed-world self-conditioning framework over open-world external observation models: isolates the internal mechanisms of reasoning from tool use or environmental interaction, making it possible to study epistemic verbalization as the sole recovery mechanism. The open-world extension (Appendix B) shows that external observations can partially substitute for epistemic verbalization, validating the closed-world analysis as the hardest case.
Sub-task partitioning of procedural reasoning over treating the trajectory as an undifferentiated token stream: enables the specification of where divergence occurs and when procedural error signals are or are not available, which is necessary for formalizing Assumption 5.1 (trigger-conditional information gain).
Five-category collapse taxonomy over a binary collapsed/not-collapsed classification: captures the diversity of failure modes while maintaining tractability. The categories (incoherence, hallucination spiral, repetition, topic drift, infinite loop) cover the qualitatively distinct ways procedural reasoning can fail without producing overt errors.
Two-stage self-correction classification (detection then trigger classification) over a single-stage classification: ensures that the reactive/proactive distinction is applied only to genuine self-corrections, not to cases where the model never went wrong in the first place. The first stage identifies trajectories with an initial wrong path, recognized error, course change, and correct final answer; the second stage determines whether the correction trigger was evidence-based (reactive) or suspicion-based (proactive).
Injection study with truncation sweep over a fixed injection point: accounts for the unknown location of the divergence point. If the injection always occurred at the end of the trace, it might miss the opportunity for recovery (if divergence was early) or be redundant (if the model was still on a correct path). Sweeping $\alpha$ reveals the differential benefit of epistemic verbalization as a function of how deeply the model is committed to its incorrect trajectory.
Nine-token epistemic proxy over exhaustive linguistic analysis: trades completeness for tractability. The tokens are empirically grounded (derived from GPT-5 analysis of actual reasoning traces) and cover the most frequent uncertainty expressions, while the paper acknowledges that they are not exhaustive (Section 4.2, Limitations).
Self-distillation SFT on 800 examples over larger-scale training: isolates the effect of epistemic verbalization from the effect of learning new mathematical knowledge. 800 examples is deliberately "too small to instill mathematical knowledge" (Ye et al., 2025), so any performance changes must come from changes in linguistic habits — specifically, the habit of externalizing or suppressing uncertainty.
Log-probability alignment analysis over other distributional measures (e.g., embedding similarity, attention patterns): directly captures whether the student model can generate the teacher's epistemic vocabulary. Since epistemic verbalization operates through token generation (making uncertainty conditionable), the bottleneck is whether the student can produce the relevant tokens, not whether its internal representations are similar to the teacher's.
HSIC-based mutual information estimation over other dependence measures: follows Qian et al. (2025)'s established methodology for tracking answer-relevant information in hidden representations. The kernel-based HSIC estimator (Gretton et al., 2007) captures non-linear dependencies between hidden states and answer representations without requiring distributional assumptions, making it suitable for the high-dimensional hidden states of transformers.
LIMO-v2 dataset over custom-curated data: leverages an existing, publicly available dataset with known properties (800 examples, rich epistemic verbalizations, multiple teacher models). This makes the distillation experiments reproducible and grounds them in the existing literature on small-data reasoning transfer (Ye et al., 2025).

4. Key Insights and Innovations

Innovation 1: Reasoning collapse is the dominant failure mode, and it operates through silent divergence — not through overt errors.

Before this paper, the dominant mental model of LLM reasoning failures was that models make mistakes — they compute incorrectly, they apply a formula wrong, they misread a constraint — and then, depending on the model's capability, they either catch those mistakes (via self-verification or contradiction detection) and correct them, or they proceed to a wrong answer. This mental model implicitly assumes that errors surface as recognizable violations: a negative length, a violated inequality, a contradiction between derivations. In that world, improving reasoning is about improving the model's ability to detect and recover from such surfaced errors.

This paper shows that this mental model misses the dominant failure case entirely. The empirical analysis in Section 3.2 (Figure 2, Table 6) reveals that 54–62% of incorrect responses across six models and four benchmarks involve reasoning collapse — patterns like incoherence, hallucination spirals, repetition, topic drift, and degenerate loops — where the surface structure of step-by-step reasoning is preserved but the model's belief about the correct answer diverges without ever producing an overt error. The model continues generating locally coherent, well-formatted tokens that look like reasoning, yet no individual step triggers an alarm. From the outside, the trace appears to be proceeding normally until it becomes clear, often only at the very end, that it has been going nowhere for many steps.

The intellectual shift here is from a model of reasoning failure as discrete error events to a model of failure as continuous belief drift. This is analogous to the shift in control theory from detecting discrete sensor faults to monitoring for gradual divergence in a Kalman filter — the problem isn't catching a spike, but recognizing that the estimate has been drifting from the true state for a while. The paper names this phenomenon silent divergence and argues that it is the primary bottleneck for LLM reasoning, not the ability to correct surfaced errors (which standard LLMs already do reactively, as Table 1 shows). This reframes the research agenda: the key problem is not better error detection, but a mechanism that can surface the fact that divergence might be occurring in the absence of any explicit error signal.

The significance of this finding extends beyond the specific numbers. It explains why prior work on self-correction reached contradictory conclusions. Studies that tested self-correction on problems where models make overt errors (e.g., Huang et al., 2024, which provided externally-identified error locations) found that models can correct when the error is surfaced, but this misses the dominant failure case where errors never surface. Studies that observed real reasoning traces (d'Aliberti and Ribeiro, 2026; Liu et al., 2025) found that "Aha" markers are unreliable, because in silent divergence, no marker triggers. The paper's taxonomy of collapse modes (incoherence, hallucination spiral, repetition, topic drift, infinite loop) provides a diagnostic vocabulary that the field previously lacked — researchers can now classify how a model is failing rather than just noting that it failed, enabling targeted interventions for specific collapse patterns.

Innovation 2: Epistemic verbalization is a distinct informational axis, orthogonal to procedural computation, and its role is to convert latent uncertainty into conditionable tokens — not to perform correction itself.

The standard view of Chain-of-Thought reasoning, as formalized in prior information-theoretic work (Ton et al., 2025; Liang, 2025; Qian et al., 2025), treats every generated token as a step in a computation toward the answer. Each token refines the model's belief about the target variable, with information gain measured by entropy reduction. In this view, reasoning is a single-channel process: the model generates tokens, and good tokens (correct calculations, useful deductions) provide information gain, while bad tokens (errors, irrelevant digressions) do not. There is no distinction between tokens that compute and tokens that assess, because all tokens are modeled as steps in the same information accumulation process.

This paper introduces a second informational axis that is orthogonal to procedural computation: epistemic verbalization — the explicit externalization, at the token level, of the model's internal uncertainty about its own reasoning trajectory. The key conceptual move is recognizing that a model's internal assessment of its trajectory reliability (the latent variable $Z_t$ ) is informationally inert unless externalized. The model might "know" internally that it is on a wrong path — its hidden states might encode high uncertainty about the correct answer — but because autoregressive generation conditions on the realized token sequence, not on hidden states, that internal assessment cannot influence what the model generates next. Epistemic verbalization solves this by emitting tokens (doubts, self-questions, hesitation markers) that make the uncertainty assessment conditionable — part of the context that subsequent generation steps can attend to.

The critical distinction from prior work is that epistemic verbalization is not itself correction. It does not identify the error, propose a fix, or change the answer. It is an informational mechanism that supplies the raw material (conditionable uncertainty) that a separate control policy then acts on. This separation — information vs. control — resolves the puzzle of why "Wait" sometimes enables correction and sometimes doesn't. When "Wait" is an empty surface form (a high-entropy filler token that doesn't reflect genuine internal uncertainty), it provides no information for the control policy to act on; the token is present but informationally empty. When "Wait" reflects genuine epistemic verbalization (externalization of a real $Z_t$ assessment), it provides the conditionable signal that enables the control policy to trigger re-examination. This explains the weak correlations found by d'Aliberti and Ribeiro (2026) while still allowing for genuine causal effects — the correlation depends on whether the surface token carries information, which is not visible from the token alone.

This two-axis decomposition is a fundamental theoretical contribution, not an incremental refinement. It changes the ontology of reasoning from a single process of information accumulation to a dual process of procedural computation and epistemic monitoring. The framework implies that future work on reasoning should optimize for both axes jointly — not just for how accurately the model computes, but for how effectively it allocates epistemic verbalization across the trajectory, trading off between advancing the computation and checking whether the computation is on track.

Innovation 3: Epistemic verbalization is a learnable linguistic habit that can be instilled or suppressed with remarkably little data, rather than an emergent property of scale or a special reasoning mechanism.

A prevailing assumption in the LLM reasoning literature — particularly for phenomena like "Aha moments" and self-correction — is that these behaviors emerge only at scale, through reinforcement learning, or from specialized architectures. DeepSeek-R1's self-reflective reasoning, for example, was produced through large-scale RL, and the behavior appears qualitatively different from what standard LLMs exhibit. This could lead to the conclusion that epistemic verbalization / proactive correction is a capability that requires extraordinary training or scale to acquire — that it is fundamentally tied to the specific training recipe used for LRMs.

This paper's distillation experiments (Sections 6.2–6.3) fundamentally undercuts that assumption. As few as 800 SFT examples — a dataset deliberately chosen to be too small to teach new mathematical knowledge (following Ye et al., 2025) — suffice to either instill epistemic verbalization into base models that lack it (Qwen2.5-7B improves from 13.3% to 36.7% on AIME24; Qwen3-14B-Base from 16.7% to 60.0%) or suppress it in models that possess it (DeepSeek-R1-Distill-32B drops from 80.0% to 43.3%). The same models, trained on the same data, can be made to either gain or lose the capability.

The intellectual significance of this finding is that it recategorizes epistemic verbalization from an emergent model capability to a learnable linguistic habit. The model doesn't need to become "smarter" or acquire new reasoning strategies to benefit from epistemic verbalization; it just needs to learn a new pattern of which tokens to generate in which contexts. This is a kind of meta-cognitive habit — when uncertain, externalize the uncertainty — that operates at the level of token generation preferences rather than at the level of underlying reasoning competence. The fact that 800 examples can instill or suppress it implies that the underlying procedural reasoning capability is largely unchanged; what changes is whether the model's uncertainty assessments become visible and conditionable.

This finding also recasts the success of small-data reasoning distillation (like LIMO) in a new light. The dramatic performance gains from 800-example SFT are not because the model is learning new mathematical content from the teacher — 800 examples is far too few for that — but because the model is learning the teacher's epistemic verbalization habits. The student model already has the underlying mathematical knowledge (it was pretrained on vast corpora); what it lacks is the habit of externalizing uncertainty, which the SFT provides.

The corollary — that the success or failure of distillation depends on distributional alignment in epistemic token probabilities (Figure 8) — is equally significant. It identifies a concrete bottleneck for transferring reasoning capabilities: if the student model's token distribution places epistemic tokens far outside its support, the SFT cannot teach the habit because the model has never "encountered" these tokens in meaningful contexts during pretraining. This is a practical, testable condition for when small-data reasoning distillation will succeed, and it suggests that pretraining data mixtures that include diverse uncertainty expressions may be a prerequisite for effective reasoning transfer.

Innovation 4: Even a completely imprecise uncertainty signal — one that second-guesses correct reasoning 75% of the time — is more valuable than a precise signal that never fires, because it provides the only escape route from silent divergence.

The natural intuition about self-monitoring signals is that they should be accurate: a model should question its reasoning when it is actually wrong, and not question it when it is correct. In this view, the quality of a self-monitoring mechanism is measured by its precision — what fraction of triggered corrections are on genuinely incorrect trajectories. A mechanism that second-guesses correct reasoning three-quarters of the time (24.4% precision, as shown in Table 2 for LRMs) would seem, by this metric, to be a poor mechanism — noisy, wasteful, frequently triggering unnecessary re-examination.

The paper argues that this intuition is wrong for the specific case of LLM reasoning, because it fails to account for the asymmetric cost structure of silent divergence. In silent divergence — the dominant failure mode documented in Section 3.2 — the model's trajectory is incorrect but produces no overt error signal. This means that a reactive corrector (one that only fires when an explicit error surfaces) has zero probability of triggering in precisely the regime where correction is most needed. The precision of such a corrector is undefined (it never fires), but its recall for genuinely incorrect trajectories is zero. By contrast, a noisy proactive corrector — even one with 24.4% precision — fires with non-zero probability on silently diverged trajectories, providing at least some chance of recovery. The formal guarantee in Proposition 5.3 captures this mathematically: what matters for convergence is the product $\rho\delta$ (the probability of epistemic verbalization times the per-step information gain), not the precision of individual verbalizations.

This reframes the normative question from "how accurate are the correction signals?" to "do correction signals fire with non-zero probability in the silent divergence regime?" By the first metric, LRMs look inefficient (75% false alarms). By the second metric, LRMs are the only models that have any mechanism for addressing the dominant failure mode — and the precision numbers are actually a sign of a working monitoring mechanism that errs on the side of caution. The paper's capability map (Figure 3) visualizes this: LRMs occupy a region where direct fluency is high and proactive correction rate is non-trivial, while standard LLMs have near-zero proactive correction rates regardless of direct fluency.

This insight is a fundamental conceptual contribution because it changes what researchers should optimize for when designing self-monitoring mechanisms. The goal is not to maximize precision in isolation, but to maximize the probability of detecting silent divergence while keeping the cost of false alarms manageable. Since false alarms on correct trajectories are not catastrophic (the model re-examines, confirms the step is correct, and continues), the cost is largely wasted computation, which is far less harmful than undetected silent divergence. This suggests a design principle for reasoning systems: when in doubt, externalize the doubt — the downside of unnecessary checking is much smaller than the downside of missing a silent divergence.

5. Experimental Analysis

Evaluation Methodology

Dataset. All experiments use mathematical reasoning benchmarks: AIME24, AIME25, AMC23, and MATH500. AIME24 and AIME25 are American Invitational Mathematics Examination problems (30 problems each), AMC23 is the 2023 AMC competition (40 problems), and MATH500 is the standard 500-problem test split from Hendrycks et al. (2021). The specific split is 600 problems total across the four benchmarks (Section 3.2: "600 problems × 8 samples"). For most analyses, 8 rollouts are sampled per problem, yielding 4,800 responses per model. The AIME benchmarks are substantially harder than AMC23 and MATH500, as reflected in lower accuracy scores across all models (Figure 2a shows collapse rates rising with difficulty). For the distillation experiments in Section 6.3, the evaluation uses AIME24 exclusively (pass@1 and pass@32 reported in Figure 7). For the SFT suppression experiments in Section 6.2, evaluation is on AIME24 pass@1 only (Table 5). The intervention study in Section 4.1 uses AIME24, AMC23, and MATH500 — the three benchmarks on which failed rollouts were collected. The test-time suppression experiments in Section 6.1 use AIME24 and AIME25 with the avg@8 metric. Note that the test sets are small by machine learning standards — AIME24 has 30 problems, AIME25 has 30 problems, AMC23 has 40 problems, and MATH500 has 500 problems — which means that pass@1 figures on AIME24/25 are based on only 30 questions and are therefore noisy. The paper does not report confidence intervals, so estimates like "13.3% pass@1" on AIME24 correspond to approximately 4 out of 30 questions correct, and a difference of a few percentage points may reflect only one or two additional correct answers.
Base model(s). The paper analyzes models from three families: Qwen2.5 (Qwen2.5-7B, Qwen2.5-32B-Instruct, Qwen2.5-Math-7B), Qwen3 (Qwen3-1.7B/8B/14B-Base, Qwen3-8B/14B instruct variants), and DeepSeek-R1-Distill-Qwen (1.5B, 7B, 14B, 32B). The Qwen2.5 and Qwen3-Base models are chosen because they "exhibit strong step-by-step procedural reasoning ability, achieve competitive performance on these benchmarks, and serve as standard baselines in recent math reasoning research" (Section 3.2). The DeepSeek-R1-Distill models are chosen as representatives of Large Reasoning Models (LRMs) that exhibit proactive self-correction. The 7B and 32B variants of DeepSeek-R1-Distill are used for the self-correction analysis (Table 1) and the test-time suppression experiments (Section 6.1), while the 1.5B variant is included in the uncertainty-tracking analysis (Appendix G). For the distillation experiments (Section 6.3), additional models are included: DeepSeek-Math-7B-Instruct and Qwen3-4B-Base (in some figures). The choice of multiple model families and scales (1.5B to 32B) allows the paper to test whether epistemic verbalization patterns are robust to model architecture and size. The paper does not include models from other families (e.g., Llama, Mistral, Gemma) in the main experiments, though Figure 3 includes Mistral-7B, Llama-3.1-8B, and Gemma-3-4B-it on the capability map for broader context. An important caveat: the paper selects decoding temperature differently for different models based on an ablation (Table 7, Appendix E) — DeepSeek-Distill models use temperature 0.7 (top-p 0.8) for pass@1 reporting because temperature 0.0 is harmful for them, while Qwen2.5 models use the better of temperature 0.0 or 0.7. This means that reported base model pass@1 figures are not strictly comparable across model families, since they use different decoding hyperparameters.
Metrics. The paper uses several metrics across experiments: (a) pass@1 — the fraction of problems for which a single sampled solution is correct. This is the primary metric for the SFT suppression experiment (Section 6.2, Table 5) and the LIMO distillation experiment (Section 6.3, Figure 7). (b) pass@k (specifically pass@32) — the fraction of problems for which at least one of k sampled solutions is correct. This is reported alongside pass@1 in Figure 7 for the distillation experiments. (c) avg@8 — the average accuracy across 8 independent rollouts per problem, used in the test-time suppression experiments (Section 6.1, Figure 5). (d) Recovery rate — the fraction of originally incorrect rollouts whose continuation reaches the correct answer after truncation and resumption with an injected cue. This is the primary metric for the intervention study (Section 4.1, Figure 4). (e) Collapse rate — the fraction of incorrect responses flagged as exhibiting reasoning collapse by GPT-5. This is reported in Section 3.2 (Figure 2, Table 6). (f) Precision of proactive signals — the fraction of suspicion-triggered corrections issued on genuinely incorrect trajectories (Section 3.4, Table 2). (g) Direct fluency — the share of responses answered correctly without any self-correction, computed as (correct − SC) / N where SC is the number of responses reaching the correct answer via self-correction (Section 3.4, Figure 3). (h) Proactive correction rate — the share of responses containing a suspicion-based self-correction (Section 3.4, Figure 3). Answer correctness is determined by comparing the model's final answer to the ground-truth answer. For the collapse, self-correction, and correction trigger classifications, GPT-5-2025-08-07 is used as an automated judge with structured JSON-output prompts (detailed in Appendices D.1–D.3). The paper does not report inter-annotator agreement or validation of GPT-5's judgments against human annotations, which is a limitation acknowledged in the Limitations section: "the classification of reactive and proactive correction, as well as the reasoning collapse analysis, depends on GPT-5 as an automated judge, introducing potential annotation noise."
Baselines. The paper compares against several baselines depending on the experiment: (a) NONE (no injection) in the intervention study (Section 4.1) — resuming generation from a truncated prefix without any injected cue, which controls for the effect of re-sampling alone. (b) Base model performance in the SFT experiments (Sections 6.2–6.3) — the untrained model's pass@1, which controls for the effect of SFT on mathematical ability versus linguistic habit change. (c) Standard inference in the test-time suppression experiments (Section 6.1) — the model's normal, unrestricted generation, compared against inference with epistemic tokens suppressed. The paper does not compare against alternative methods for improving reasoning (e.g., majority voting over multiple samples, best-of-N selection, or self-consistency decoding) in most experiments, which is notable since these are standard techniques. The FLOPs-matched pretraining-vs-inference comparison that appeared in the reference example paper is absent here — the paper does not compare the cost of acquiring epistemic verbalization through SFT against the cost of simply scaling model size.
Generation budget / compute accounting. The paper does not use a standardized compute budget in the way that search-vs-best-of-N papers do. Instead, different experiments control cost in different ways: (a) The intervention study (Section 4.1) draws n = 4 continuations per condition per truncation point, so the total generation cost per rollout is 4 × 5 = 20 continuations (4 continuations × 5 conditions per truncation point, with multiple truncation points swept), but the paper does not report total compute or compare against a budget-equivalent baseline. (b) The SFT experiments (Sections 6.2–6.3) fix the number of training examples at 800, which controls for the amount of training data but does not account for the cost of generating those training examples (which requires the model to produce traces, some with and some without epistemic verbalization). (c) The test-time suppression experiments (Section 6.1) compare standard inference against suppression at the same number of rollouts (avg@8 for both), so the generation budget is identical. (d) The collapse and self-correction analyses in Sections 3.2–3.4 analyze 8 rollouts per problem per model, but no compute-normalized comparisons are attempted. Overall, the paper does not attempt FLOPs-matched or latency-matched comparisons, and the intervention study does not account for the cost of sweeping truncation points against any baseline strategy that might achieve similar recovery by simply generating more samples. This is appropriate for a mechanism-study paper but means the practical efficiency of epistemic verbalization relative to simpler strategies (e.g., just sampling more) is not quantified.
Cross-validation / statistical protocol. The paper does not employ cross-validation or formal statistical testing for most experiments. The intervention study (Section 4.1) reports recovery rates as point estimates without confidence intervals. The SFT experiments (Sections 6.2–6.3) report pass@1 on AIME24 as a single number per model, which on a 30-question test set means each reported percentage point corresponds to less than one question — differences of a few percentage points are not statistically distinguishable with this sample size. The collapse analysis (Section 3.2) aggregates across 4,800 responses per model, providing larger samples, but the classification itself is done by GPT-5 with unknown reliability. The precision analysis (Table 2) is based on only 80 sampled traces per model (320 total), which the paper explicitly notes. The capability map (Figure 3) includes base models and reasoning models evaluated under different decoding hyperparameters (temperature selection per model, as shown in Table 7), which introduces a confounding variable. The paper does not report multiple training seeds or trials for any SFT experiment — each model is fine-tuned once, so the reported pass@1 numbers may include training stochasticity (especially on a 30-question test set). Standard deviations, confidence intervals, or statistical significance tests are absent throughout.

Main Quantitative Results

The paper's experiments are organized around validating the existence and causal role of epistemic verbalization, rather than benchmarking a new method against alternatives. The results therefore fall into three categories: (1) characterizing the failure mode (reasoning collapse and the reactive/proactive correction distinction), (2) demonstrating that epistemic verbalization is causally responsible for recovery from failed trajectories, and (3) showing that epistemic verbalization is a learnable habit that can be instilled or suppressed through small-scale SFT, with distributional alignment determining transfer success.

Reasoning Collapse Is the Dominant Failure Mode and Proactive Correction Distinguishes LRMs from Standard LLMs

The foundational empirical result is the quantification of reasoning collapse across standard LLMs. As reported in Table 6 (Appendix D.1), across 9,644 total incorrect responses from five models (Qwen2.5-7B, Qwen2.5-32B-Instruct, Qwen3-1.7B/8B/14B-Base) on 600 problems with 8 samples each, 58.4% of incorrect responses exhibit reasoning collapse — the five-way breakdown of collapse types (incoherence, hallucination spiral, repetition, topic drift, infinite loop) is shown in Figure 2b. The collapse rate among incorrect responses is relatively stable across model scales (54.9% for Qwen3-8B-Base to 61.7% for Qwen3-1.7B-Base), meaning that larger models reduce the total error rate but the share of errors attributable to silent divergence does not decrease substantially — scaling reduces surface-level mistakes faster than it eliminates collapse. Collapse rates rise sharply with problem difficulty (Figure 2a): on MATH500 (easiest), collapse rates are 49–56%; on AIME25 (hardest), they are 78–83%. The fact that the hardest problems exhibit the highest collapse rates is consistent with the paper's framework: on problems near the limit of the model's capability, divergence is more likely and the model has fewer resources to detect it.

The crucial behavioral distinction between standard LLMs and LRMs is quantified in Table 1. Across 4,800 generations per model, standard LLMs exhibit self-correction in at most 35 generations (under 1%) — and those rare self-corrections are overwhelmingly reactive (evidence-based), with proactive corrections accounting for 0–20.5% of already-minimal totals. LRMs show a fundamentally different pattern: proactive corrections account for 22.2–35.0% of self-corrections, and the total absolute number of self-correction events is orders of magnitude higher (hundreds per model rather than single digits). DeepSeek-R1-Distill-7B shows 256 proactive corrections out of 731 total self-corrections (35.0%); Qwen3-14B (instruct) shows 138 proactive out of 622 total (22.2%). This asymmetry — standard LLMs almost never proactively question their reasoning, LRMs do so regularly — is the empirical puzzle that epistemic verbalization explains.

The capability map (Figure 3) situates these findings visually. Standard LLMs cluster along the bottom (near-zero proactive correction rate) regardless of direct fluency — Qwen2.5-32B-Instruct, with presumably higher direct fluency than Qwen2.5-7B, still shows essentially zero proactive correction. LRMs occupy a distinct region where high direct fluency is paired with non-trivial proactive correction rates. The paper notes that base models and reasoning-tuned models from the same family (e.g., Qwen3-8B-Base vs. Qwen3-8B instruct) occupy different regions, indicating that the proactive correction capability is acquired through post-training (likely RL or instruction tuning) rather than being an emergent property of pretraining.

The precision of proactive signals (Table 2) reveals that only 24.4% of suspicion-based corrections are issued on genuinely incorrect trajectories — three-quarters second-guess already-correct chains. DeepSeek-R1-Distill-7B achieves the highest precision at 37.3%, while Qwen3-14B shows the lowest at 15.8%. Precision does not improve with scale (DeepSeek-R1-Distill-32B at 23.9% is lower than the 7B variant). The paper's interpretation — that low precision is acceptable because the alternative (no signal in silent divergence) is worse — is supported by the formal convergence result (Proposition 5.3) but is not tested directly: the paper does not compare a high-precision, low-recall corrector against the existing low-precision, higher-recall proactive corrector on the same budget.

Injecting Epistemic Verbalization Causally Recovers Failed Trajectories

The intervention study (Section 4.1, Figure 4) provides the paper's key causal evidence. Across Qwen3-8B-Base and Qwen3-14B-Base on AIME24, AMC23, and MATH500, injecting epistemic verbalization cues into truncated failed trajectories consistently increases recovery rates compared to the NONE (re-sample only) baseline. Specific findings include:

On MATH500 (easiest benchmark) with Qwen3-8B-Base at α = 0.5 (truncation at 50% of the original trace): NONE achieves roughly 8% recovery; HMM-DOUBT ("Hmm, I'm not sure this is right.") achieves roughly 18% — more than double. WAIT-DOUBT ("Wait, is that correct?") achieves approximately 20%. WAIT-REVISIT ("Wait, let me double-check.") achieves approximately 22%.
Recovery rates are highest at early truncation (α = 0.2) and decline as α increases. At α = 0.2 on MATH500 with Qwen3-8B-Base, the best injection conditions achieve roughly 25–28% recovery. At α = 0.9 (very late truncation, 90% of the original trace preserved), the NONE baseline drops to near zero (roughly 0–2%), while the injection conditions retain some recovery (roughly 2–8%). The gap between injection and baseline widens with α — epistemic verbalization is most valuable when the model is most deeply committed to its incorrect trajectory.
Recovery tracks benchmark difficulty: MATH500 (highest recovery), AMC23 (intermediate), AIME24 (lowest). On AIME24 with Qwen3-8B-Base, maximum recovery rates are roughly 4–6% at α = 0.2, declining to near zero by α = 0.7 — substantially lower than MATH500's 25–28% at α = 0.2.
DOUBT alone suffices for recovery; REVISIT (explicit revisitation cue) does not consistently outperform DOUBT alone. This demonstrates that the mere expression of uncertainty — without any explicit instruction to re-examine — provides the actionable signal. The model, upon encountering its own externalized doubt, can autonomously decide to re-evaluate its reasoning.
WAIT-style cues slightly outperform HMM-style cues, though differences are modest (typically 1–3 percentage points).
Both Qwen3-8B-Base and Qwen3-14B-Base show the same qualitative pattern, with the 14B model showing slightly higher baseline recovery rates but similar relative gains from injection.

The interpretation that epistemic verbalization — not just any injection — is responsible for recovery is supported by the fact that the NONE condition (which simply re-samples from the same truncated prefix) produces substantially lower recovery rates. The remaining possibility — that any injected text would improve recovery by disrupting the model's commitment to its incorrect trajectory — is not directly tested (e.g., by injecting task-irrelevant filler text), though the paper's theoretical framework suggests that only uncertainty-expressing text should provide the kind of information gain that enables correction. The paper also does not test whether the recovery is specific to these particular model families or whether models that already exhibit epistemic verbalization would benefit from additional injections.

Test-Time Suppression of Epistemic Tokens Reduces Reasoning Performance

Suppressing the nine epistemic tokens at test time (Section 6.1, Figure 5) causes consistent performance degradation on AIME24 and AIME25:

DeepSeek-R1-Distill-32B on AIME24: avg@8 drops from 72.08% to 64.58% (a 7.5 percentage point decrease).
DeepSeek-R1-Distill-14B on AIME24: drops from 68.33% to 60.42% (a 7.9 percentage point decrease).
DeepSeek-R1-Distill-32B on AIME25: drops from 55.00% to 47.92% (a 7.1 percentage point decrease).
DeepSeek-R1-Distill-14B on AIME25: drops from 50.42% to 45.83% (a 4.6 percentage point decrease).

The relative degradation is around 10% across all settings. Performance does not collapse entirely because (as documented in Appendix H.1, Table 8) the models partially bypass the suppression by substituting alternative uncertainty expressions: "But hold on, let me..." replaces "Wait, let me check..."; "No, that's not quite right" replaces "Hmm..."; "I realize" or "On closer look" replaces "Actually." The residual performance drop (roughly 10%) represents the cost of forcing the model to use less-natural uncertainty expressions, which likely reduces the effective probability ρ of epistemic verbalization. The paper does not attempt to suppress these bypass expressions as well, so the 10% figure is a lower bound on the importance of epistemic verbalization — the true impact if all uncertainty expression were prevented could be larger.

A notable aspect of this experiment: suppression is implemented via logit bias of -100, which prevents the model from generating the banned tokens but does not prevent it from generating tokens that contain the banned tokens (e.g., "await" contains "wait" but would not be suppressed by a simple token-level ban, depending on the tokenizer). The paper does not discuss this nuance or whether substring matches were also suppressed.

SFT on Epistemic-Verbalization-Suppressed Traces Degrades Reasoning Performance

The controlled self-distillation experiment (Section 6.2, Table 5) provides the cleanest evidence that epistemic verbalization is causal for reasoning performance, not merely correlated with it. Training each model on 800 of its own correct reasoning traces — generated with explicit instruction to suppress epistemic verbalization — consistently degrades AIME24 pass@1 compared to the base model:

Qwen2.5-7B: 13.3% → 6.7% (halved)
Qwen3-8B-Base: 16.7% → 3.3% (80% reduction, the largest relative drop)
Qwen3-14B-Base: 16.7% → 10.0% (40% reduction)
DeepSeek-R1-Distill-7B: 50.0% → 30.0% (40% reduction)
DeepSeek-R1-Distill-32B: 80.0% → 43.3% (46% reduction)

Since all training traces contain correct final answers and the only difference from the base model's natural reasoning is the absence of epistemic verbalization, the degradation directly implicates epistemic verbalization as causally necessary for the base model's reasoning performance. The finding that LRMs (DeepSeek-R1-Distill) suffer more absolute degradation (37–47 percentage points) than standard LLMs (7–13 percentage points) is consistent with the framework: LRMs rely more heavily on epistemic verbalization for their reasoning, so removing it costs them more. Standard LLMs already have near-zero proactive correction rates (Figure 3), so suppressing epistemic verbalization removes a capability they barely use — the remaining degradation (to 3.3–10.0%) may reflect secondary effects, such as the model unlearning subtle uncertainty-related patterns in its token distribution.

A paper-specific nuance: the SFT trains the model to suppress epistemic verbalization on problems it can solve (the 800 training examples are all correct-answer traces). During evaluation, the model encounters problems of varying difficulty, including ones it cannot solve on the first attempt. The SFT has taught it not to verbalize uncertainty, so when it enters a silently diverged trajectory, it lacks the mechanism to recover — even though it had the underlying procedural capability to solve the problem. This is a subtle point about generalization: the SFT generalizes from "this model can solve problems without saying 'Wait'" (on the training set) to "this model should not say 'Wait' when solving any problem" (at test time), and this generalization impairs recovery on problems where the model would have benefited from verbalizing uncertainty.

Small-Scale Distillation Can Instill Epistemic Verbalization, but Only When Token Distributions Align

The LIMO distillation experiment (Section 6.3, Figure 7) demonstrates that 800 training examples from a dataset rich in epistemic verbalization (77.1 "Wait" tokens per response, Figure 6) can dramatically improve AIME24 pass@1 for some base models, while catastrophically degrading others:

Successful transfers:

Qwen2.5-7B: pass@1 13.3% → 36.7%; pass@32 26.7% → 53.3%
Qwen3-8B-Base: pass@1 16.7% → 40.0%; pass@32 46.7% → 80.0%
Qwen3-14B-Base: pass@1 16.7% → 60.0%; pass@32 60.0% → 86.7% (the largest absolute gain)
Qwen3-1.7B-Base: pass@1 6.7% → 30.0%; pass@32 3.3% → 30.0%

Failed transfers:

Qwen2.5-Math-7B: pass@1 16.7% → 0.0%; pass@32 56.7% → 16.7% (catastrophic degradation despite being a math specialist)
DeepSeek-Math-7B-Instruct: pass@1 3.3% → 0.0%; pass@32 13.3% → 0.0% (complete collapse)

The paper's explanation — distributional alignment in epistemic token log-probabilities (Figure 8) — is supported by a targeted analysis rather than an exhaustive sweep. In successful models (Qwen2.5-7B, Qwen3-8B-Base), epistemic tokens like "Wait" and "Alternatively" fall within the model's support (they have non-negligible probability, even if low). In failed models (Qwen2.5-Math-7B, DeepSeek-Math-7B-Instruct), these tokens are far outside the model's support, with large log-probability gaps relative to the model's typical token distribution. The paper notes that in well-performing models, epistemic tokens remain low-probability and high-entropy — they are not preferred vocabulary but are within plausible generation range. The SFT can shift the model toward generating these tokens in contexts of uncertainty because the foundation (the token's existence in the model's active vocabulary) is already present.

An important observation that the paper makes but does not fully explore: the "failed" models (Qwen2.5-Math-7B, DeepSeek-Math-7B-Instruct) are both math-specialized models. This suggests that math-specific fine-tuning may inadvertently suppress epistemic verbalization tendencies (perhaps because math pretraining data focuses on clean, direct solutions without metacognitive commentary), making these models poor students for epistemic verbalization distillation. If true, this would be a significant finding for the reasoning model design space: improving procedural math accuracy might come at the cost of reducing the model's capacity to benefit from epistemic verbalization training later.

Epistemic Verbalization Produces Information Gain, Not Just Surface-Level Marker Tokens

The mutual information analysis in Appendix F (Figures 10–11) provides neural evidence that epistemic verbalization — not just the surface tokens — drives information gain. Comparing Qwen3-8B-Base and Qwen3-8B-SFT (fine-tuned on epistemic-rich reasoning traces) on the same AIME24 problem where both initially commit to an incorrect trajectory, Qwen3-8B-SFT sustains elevated mutual information between its hidden states and the ground-truth answer after divergence, while Qwen3-8B-Base's MI collapses to near zero. The SFT model recovers to the correct answer; the base model does not. The high-MI regions correspond to utterances that perform epistemic verbalization (evaluating the trajectory, expressing doubt), not to thinking tokens in isolation — a "Hmm" that occurs without accompanying evaluative behavior does not trigger an MI increase (Figure 11). This finding is important because it distinguishes the paper's framework from the "MI peaks" observation in Qian et al. (2025): the peaks are not caused by tokens like "Wait" per se, but by the epistemic verbalization process that those tokens sometimes mark.

A limitation of this analysis: the comparison is between two different models (Qwen3-8B-Base and Qwen3-8B-SFT) on the same problem, so the difference in MI patterns could reflect general differences in model behavior rather than specifically the effect of epistemic verbalization. A within-model comparison (e.g., comparing MI in traces with and without injected epistemic cues from the same model) would provide cleaner evidence, but is not performed.

Uncertainty Verbalization Genuinely Reflects Model Difficulty

The analyses in Appendix G (Figures 12–14) establish that epistemic token frequency correlates with problem difficulty and model capacity in the expected directions. On DeepSeek-R1-Distill-Qwen models (1.5B to 14B), harder benchmarks (AIME24/25) elicit more epistemic tokens than easier ones (AMC23/MATH500), and smaller models use epistemic tokens more frequently than larger ones: the 1.5B model produces 75% more "Wait" and 234% more "Perhaps" than the 14B model on AIME24 (Figure 13). On Qwen3-Base models fine-tuned with LIMO, the same pattern holds: smaller models and harder problems elicit more epistemic tokens, though the vocabulary shifts to rely more heavily on "Wait" and less on "perhaps" (reflecting the LIMO dataset's token distribution). These patterns are presented as evidence that epistemic tokens genuinely reflect the model's experienced uncertainty rather than being arbitrary stylistic choices. The correlation between difficulty and epistemic token frequency is consistent with the framework, but the causal direction is not established: do problems elicit more epistemic tokens because they are harder (uncertainty drives verbalization), or do models that generate more epistemic tokens perform better on hard problems (verbalization enables recovery, improving scores and thus reducing the perceived difficulty)? The paper's framework suggests both directions operate — uncertainty triggers verbalization (Section 4), and verbalization enables recovery (Proposition 5.3) — so the observed correlation likely reflects a feedback loop rather than a simple causal arrow.

Ablation Studies and Robustness Checks

The paper's experiments are not structured as a typical "main result plus ablations" empirical section, but several analyses serve as robustness checks or explore alternative explanations:

Token-level entropy fails as an alternative corrective signal (Appendix C, Figure 9): On AIME24 with Qwen2.5-Math-7B and Qwen3-14B-Base, token-level entropy decreases similarly in both correct and incorrect solutions. The model becomes locally more confident at comparable rates whether or not its trajectory is productive. This demonstrates that local token confidence cannot serve as a proxy for trajectory correctness — a finding that motivates why a separate epistemic verbalization channel is needed rather than simply thresholding entropy. The analysis uses token-level entropy $H(A_t \mid s_{t-1})$ rather than target-variable entropy $H(Y \mid s_t)$ , which is the right comparison: local entropy is what the model has access to at generation time, while target-variable entropy requires post-hoc measurement. A missing analysis: does the PRM-style approach from other work (training a verifier to predict correctness from hidden states) outperform token-level entropy? The paper does not compare epistemic verbalization against alternative uncertainty estimation methods.
Epistemic token suppression elicits bypass pathways (Appendix H.1, Table 8): When nine epistemic tokens are suppressed at test time (Section 6.1), the models partially adapt by substituting alternative expressions: "But hold on, let me..." for "Wait, let me check...", "No, that's not quite right" for "Hmm...", "I realize" or "On closer look" for "Actually." This demonstrates that epistemic verbalization is a functional capability, not tied to a fixed vocabulary — the model can express uncertainty through multiple surface forms. The paper does not quantify what fraction of original epistemic verbalizations are successfully rerouted versus lost entirely, which would indicate the effective reduction in ρ (the epistemic verbalization probability). A more thorough ablation would suppress these bypass expressions as well (through iterative logit biasing based on observed substitutions) to measure the full impact of eliminating all uncertainty expression.
Temperature selection for pass@1 reporting (Appendix E, Table 7): The paper reports an ablation across decoding temperatures (0.0 vs. 0.7 with top-p 0.8 or 1.0) for computing pass@1 scores. The finding is that temperature 0.0 is harmful for DeepSeek-Distill models (e.g., DeepSeek-R1-Distill-32B drops from 70.0% at temperature 0.7 to 50.0% at temperature 0.0) but beneficial or neutral for Qwen2.5/Qwen3 models. The paper uses the best temperature per model for base model pass@1 reporting and fixes temperature at 0.0 for LIMO evaluations. This means that cross-model comparisons (e.g., base vs. LIMO) use consistent temperature within each evaluation, but comparisons across model families combine different temperatures, which is a confound. The paper does not report LIMO performance at both temperatures to show that the gains are robust to decoding hyperparameters.
Mutual information analysis controls for the "thinking token alone" alternative (Appendix F, Figures 10–11): The paper explicitly checks whether MI increases are driven by thinking tokens (like "Wait") in isolation or by the evaluative behavior they mark. The finding is that MI rises at thinking tokens only when they co-occur with epistemic verbalization — a "Hmm" without accompanying evaluative content does not trigger MI increase. This controls for the alternative hypothesis that thinking tokens are themselves the source of information gain, rather than surface markers of an underlying process. This is a clean within-figure comparison but is only shown for one problem and one model pair; broader replication across more problems and models would strengthen the claim.
Proactive correction precision analysis uses an independent sample (Table 2): The precision numbers (24.4% average) are computed on a separate sample of 80 responses per model (320 total) distinct from the main self-correction classification, which prevents circularity between the classification and evaluation of classification accuracy. The paper acknowledges that precision is estimated from a "small sample" (the Limitations section notes the sample size constraint), and no confidence intervals are provided for the precision estimates.

Critical Assessment

The experiments in this paper are designed to validate the existence and causal role of epistemic verbalization, not to optimize or benchmark a method. This is appropriate for a framework paper, but it means the empirical bar is different from a systems or methods paper: the experiments need to convincingly demonstrate the mechanism, not necessarily to show state-of-the-art performance or practical efficiency. Assessed on those terms, the paper's evidence is generally coherent and mutually reinforcing, but several important gaps and alternative explanations remain unaddressed.

Do the injection experiments (Section 4.1) demonstrate that epistemic verbalization causes recovery?

The evidence is strong that injecting epistemic verbalization cues increases recovery rates compared to re-sampling alone (NONE baseline). However, several alternative explanations are not ruled out:

Any injection would help. The paper does not test a control condition where task-irrelevant text is injected (e.g., "Let me think about this." or "The next step is..."). It is possible that any disruption to the autoregressive context at the truncation point — regardless of content — would improve recovery by causing the model to re-evaluate its trajectory. The theoretical framework predicts that only uncertainty-expressing text should provide information gain about Y, but this prediction is not tested against a non-epistemic injection control.
The truncation sweep understates the NONE baseline. The NONE condition re-samples from the truncated prefix at the same truncation point. But a smarter baseline might re-sample from earlier in the trajectory, or might attempt multiple continuations and select the best via some criterion. The paper compares epistemic injection against a fixed re-sampling procedure, not against an adaptive re-sampling strategy that might recover some of the same trajectories without epistemic cues.
Recovery rates are modest in absolute terms. On the hardest benchmark (AIME24), maximum recovery rates are 4–6% even with injection. On MATH500, the best injections recover around 25–28% of failed trajectories. The paper does not report what fraction of all incorrect trajectories across all benchmarks become correct after injection — the recovery rate is reported per-truncation-point, and it is unclear how the optimal truncation point would be chosen in practice. The realized recovery rate in a deployed system (where truncation point must be chosen automatically) would likely be lower than the best per-α rate.
The intervention is synthetic. The experiment injects epistemic cues exogenously — it manually inserts "Wait, is that correct?" into the model's output. This demonstrates that if the model could produce such verbalizations, they would help. But it does not demonstrate that the model can learn to produce them at the right points. The SFT experiments address this gap by showing that training can instill or suppress the behavior, but the bridge between "exogenous injection helps" and "endogenous generation can be learned" relies on the SFT results, not on the injection results alone.

Do the SFT experiments (Sections 6.2–6.3) demonstrate that epistemic verbalization is a learnable habit rather than an intrinsic capability?

The evidence is compelling in pattern but thin in quantity. Each model is fine-tuned once; there are no replicates; the test set is 30 questions for AIME24. A pass@1 difference of, say, 16.7% to 10.0% (Qwen3-14B-Base suppression experiment) corresponds to approximately 5 correct vs. 3 correct on 30 questions — a difference of 2 questions. With 30 questions and unknown training variance, a 6.7 percentage point difference could plausibly arise from factors other than the epistemic verbalization manipulation. The larger differences (50.0% to 30.0%, 80.0% to 43.3%) are more robust even on a 30-question test set, but the paper does not provide error bars or replicate the SFT training.

A more fundamental gap is that the SFT suppression experiment (Section 6.2) controls for what the training traces lack (epistemic verbalization) but not for what they add. The instruction "Proceed directly without expressing uncertainty or doubt within the reasoning steps" may change the generated traces in ways beyond suppressing epistemic verbalization — for example, the model might produce shorter solutions, different intermediate calculations, or altered reasoning strategies. The paper does not compare the SFT traces to the base model traces to check that they differ only in the absence of epistemic tokens. If the suppression instruction causes the model to reason differently (e.g., less thoroughly because it is rushing to the answer without self-checking), the performance degradation could be due to lower-quality procedural reasoning rather than the absence of epistemic verbalization per se. The paper's theoretical framework would predict that the degradation is specifically from reduced ρ (epistemic verbalization probability), but the experiment does not isolate this variable cleanly.

Similarly, the LIMO distillation experiment (Section 6.3) attributes the performance gains to epistemic verbalization acquisition, but the LIMO dataset differs from the base model's natural reasoning along many dimensions — solution structure, formatting, use of LaTeX, problem-solving strategies, and the content of the reasoning itself. The paper's token-level log-probability analysis (Figure 8) isolates epistemic tokens and shows distributional alignment correlates with success, which is suggestive but does not prove that epistemic tokens are the active ingredient in the performance gains. A targeted ablation — e.g., training on LIMO with all non-epistemic reasoning replaced by the base model's own reasoning style, keeping only the epistemic verbalizations — would isolate the contribution of epistemic verbalization from the contribution of the teacher's procedural reasoning quality. This ablation is not performed.

Does the mutual information analysis (Appendix F, Figures 10–11) demonstrate that epistemic verbalization provides information gain?

The analysis shows that Qwen3-8B-SFT sustains higher MI with the correct answer after divergence than Qwen3-8B-Base, and that high-MI regions correspond to evaluative utterances rather than thinking tokens alone. This is consistent with the framework but has two limitations: (a) it compares two different models (base vs. SFT), so the MI difference could reflect any of the other changes induced by SFT training (not just epistemic verbalization acquisition), and (b) it shows correlation between epistemic verbalization and MI, not causation — the paper does not show that inserting epistemic verbalization increases MI, or that removing it decreases MI, which would be the interventional evidence. A within-model comparison (comparing MI in traces where the same model does vs. does not perform epistemic verbalization) would be stronger, but is complicated by the fact that epistemic verbalization is endogenous — the model generates it when it is uncertain, so traces with and without epistemic verbalization are not comparable in their pre-verbalization states.

What experiments are missing?

Several experiments would have strengthened the paper's claims considerably:

Direct measurement of ρ (epistemic verbalization probability) and δ (per-verbalization information gain). The formal framework (Assumption 5.2, Proposition 5.3) depends on these parameters, but the paper never estimates them empirically. Measuring ρ (what fraction of steps with high H(Y | s_t) generate epistemic tokens) and δ (how much entropy reduction follows an epistemic verbalization) across models would connect the theory to the data quantitatively. The formal convergence bound is $\mathbb{E}[\tau_\eta] \leq (\mathbb{E}[H_0] - \eta) / (\rho\delta)$ , so estimating ρδ for different models would predict their relative convergence rates, which could be validated against observed recovery behavior.
Ablation of epistemic token types. The paper identifies nine epistemic tokens (Section 4.2) but treats them as a unified set. Are some tokens more informative than others? Does "Wait, is that correct?" provide more information gain than "Hmm"? Does the REVISIT function add value beyond DOUBT alone? The injection experiment partially addresses this (comparing HMM vs. WAIT, DOUBT vs. REVISIT) but with small differences and no statistical testing. A larger-scale analysis measuring the per-token information gain would connect the surface-level token analysis to the information-theoretic framework.
A non-epistemic injection control. As noted above, injecting task-irrelevant text (e.g., "Let me continue with the solution.") would control for the possibility that any disruption to the autoregressive context at the truncation point improves recovery.
Comparison against alternative uncertainty estimation methods. The paper argues that token-level entropy fails as a corrective signal (Appendix C, Figure 9) and that epistemic verbalization succeeds. But what about other methods for detecting or recovering from incorrect trajectories? For example: training a verifier (like a PRM) to predict trajectory correctness and using its scores to trigger re-sampling; using entropy of the answer distribution rather than the token distribution; or simply generating more samples and using majority voting. The paper does not compare epistemic verbalization against any of these alternatives, which makes it hard to assess the practical significance of the mechanism — how much does epistemic verbalization add beyond what simpler, existing methods can achieve?
Latency and compute analysis. The test-time suppression experiments (Section 6.1) show that removing epistemic tokens degrades performance, but the suppressed model generates fewer tokens (since it cannot produce the banned vocabulary). If the shorter outputs take less time and compute, the degradation might be partially offset by efficiency gains. The paper does not report average generation length for baseline vs. suppressed inference, nor does it compute accuracy per output token or per FLOP. Similarly, the injection experiments add tokens (the injection phrase) without accounting for the cost of those extra tokens. A compute-normalized comparison (e.g., accuracy per 1000 generated tokens) would reveal whether epistemic verbalization is efficient or merely effective.
Broader model coverage. The experiments cover Qwen2.5, Qwen3, and DeepSeek-R1-Distill models. The capability map (Figure 3) includes Mistral-7B, Llama-3.1-8B, and Gemma-3-4B-it as contextualization, but these models are not included in any intervention or SFT experiment. The paper's claim that epistemic verbalization is a general mechanism rather than a quirk of a specific model family would be stronger with replication across Llama, Mistral, and Gemma families.

Do the experiments support the paper's central claims?

The paper's central claims, from the Executive Summary (written elsewhere but referenced here), are: (1) reasoning operates along two informational axes — procedural advancement and epistemic verbalization; (2) epistemic verbalization converts latent uncertainty into conditionable tokens that enable recovery from silent divergence; (3) injecting a minimal doubt cue recovers ~15% of failed trajectories; (4) as few as 800 SFT examples suffice to instill or suppress the behavior; (5) epistemic verbalization is a learnable linguistic habit, not an emergent property of scale.

The experiments provide strong qualitative support for all five claims, but with varying degrees of quantitative precision:

Claim 1 (two informational axes): Supported conceptually by the reactive/proactive correction distinction (Table 1, Figure 3) and the mutual information analysis (Figures 10–11), which show that epistemic utterances produce information gain distinct from procedural tokens. However, the experiments do not demonstrate that the two axes are independent or orthogonal — it is possible that epistemic verbalization is simply a particular type of procedural token (one that triggers self-monitoring subroutines) rather than a fundamentally distinct category.
Claim 2 (converts latent uncertainty to conditionable tokens): Supported by the theoretical inequality $H(Y \mid s_{t-1}, v_t) \leq H(Y \mid s_{t-1})$ and the observation that injecting doubt cues improves recovery without specifying what went wrong (Figure 4). The experiment elegantly shows that the model does not need to know what the error is — it only needs to know that something might be wrong. However, the paper does not directly measure latent uncertainty $Z_t$ or show that verbalized tokens $v_t$ are recoverable from it — the "latent to conditionable" claim is a theoretical interpretation of the injection results, not a directly tested mechanism.
Claim 3 (~15% recovery from doubt cues): This number appears to be drawn from the MATH500 results at specific truncation fractions. In Figure 4, Qwen3-8B-Base on MATH500 at α = 0.5 shows roughly 18% recovery for HMM-DOUBT vs. ~8% for NONE — an absolute gain of ~10 percentage points, and a relative gain (compared to baseline) of more than 2×. At α = 0.2, the gain is larger (roughly 25% vs. ~12%). The "~15%" figure is thus a rough summary and varies substantially with benchmark, model, and truncation point. The more precise statement is: injection of epistemic verbalization roughly doubles recovery rates on easier benchmarks (MATH500, AMC23) and provides smaller absolute gains on harder benchmarks (AIME24), with the relative advantage over re-sampling alone widening as the truncation point moves later in the trajectory.
Claim 4 (800 SFT examples suffice): Strongly supported by the LIMO distillation results (Figure 7) for the instillation direction (Qwen2.5-7B, Qwen3-Base variants show 2–4× improvements), and by the SFT suppression results (Table 5) for the suppression direction. The claim is qualified by the distributional alignment condition (Figure 8): 800 examples suffice when the student model's token distribution is aligned with the teacher's epistemic vocabulary. Without this condition, the same 800 examples can be catastrophic (Qwen2.5-Math-7B drops to 0% pass@1). The paper's abstract statement "as few as 800 training samples suffice to either instill or suppress this behavior" should be accompanied by the qualification "when there is sufficient token-level distributional alignment."
Claim 5 (learnable habit, not emergent property): The strongest evidence is that 800 SFT examples — a dataset deliberately too small to teach new mathematical knowledge — produce large performance changes in both directions. This fundamentally distinguishes epistemic verbalization from capabilities that require scale to emerge. However, the claim that epistemic verbalization is only a habit and not at all dependent on model scale is not fully tested: the paper shows that 800 examples suffice for some models, but does not test whether even smaller models (sub-1B parameters) or models with fundamentally different pretraining can acquire the habit. The correlation between epistemic token frequency and model size (smaller models verbalize uncertainty more, Appendix G) suggests scale does play a role — smaller models are more uncertain, so they verbalize more — but the capacity to verbalize appears to require only that the tokens exist in the model's support, not that the model is large.

Overall, the experimental program is well-designed for establishing the existence and nature of epistemic verbalization as a mechanism, but it leaves the quantitative importance and practical efficiency of the mechanism largely unaddressed. The paper succeeds in shifting the conceptual landscape — from viewing reasoning as a single-channel information accumulation process to viewing it as a dual-channel process of computation and uncertainty monitoring — and the experiments provide sufficient evidence to make this shift credible. However, readers looking for guidance on how to deploy epistemic verbalization in practice (how much training data, which models, what trade-offs against other methods) will find the paper's empirical analysis more suggestive than prescriptive.

6. Limitations and Trade-offs

The Difficulty Estimation Analogue Remains Unresolved — When Should the Model Verbalize Uncertainty?

The entire framework depends on a single behavioral principle: the model should verbalize uncertainty when its residual entropy $H(Y \mid s_t)$ is high (Assumption 5.2). Yet the paper provides no mechanism — either theoretical or practical — for the model to determine when this condition holds. Proposition 5.3 proves convergence if epistemic verbalization occurs with probability $\rho$ whenever $H(Y \mid s_t) > \eta$ , but it does not specify how the model decides that its uncertainty exceeds the threshold. This is the inference-time analogue of the difficulty estimation problem in the reference paper: just as that work needed a mechanism to estimate prompt difficulty before selecting a test-time compute strategy, this paper needs a mechanism for the model to estimate its own trajectory uncertainty and trigger epistemic verbalization at the right moments.

The precision analysis (Table 2, Section 3.4) reveals the magnitude of this problem. Across LRMs, proactive corrections average only 24.4% precision — three-quarters of the time, the model verbalizes uncertainty when it is not on a wrong path. This means the model's internal thresholding is poorly calibrated: it fires far too often on correct trajectories, wasting computation on unnecessary re-examination. The paper frames this as acceptable ("even a noisy signal is more useful than a precise one that never fires"), but this argument depends on the cost of false alarms being negligible. For a deployed system with latency constraints or per-token billing, every unnecessary "Wait, let me double-check" and its subsequent verification steps incurs a real cost in time and compute that the paper never quantifies. The intervention study (Section 4.1, Figure 4) injects epistemic cues exogenously at experimenter-chosen truncation points — it does not test whether the model itself can learn to generate them at the right points, at the right frequency, without the precision penalty observed in Table 2. The SFT experiments (Sections 6.2–6.3) show that the model can acquire the habit of epistemic verbalization, but they do not measure whether the acquired habit is well-calibrated — the LIMO-distilled models might exhibit the same 24.4% precision as their teachers, or worse.

A deeper version of this problem emerges in the suppression experiments. Section 6.2 trains models on 800 traces where epistemic verbalization was suppressed by explicit instruction. But during evaluation, the model encounters problems it cannot solve on a direct path — problems it would have previously recovered from via epistemic verbalization. The SFT has taught it a blanket rule ("do not verbalize uncertainty") rather than a calibrated policy ("verbalize uncertainty when your trajectory is unreliable"). This is a fundamental mismatch: the training procedure suppresses an entire informational channel rather than teaching the model when to use it. The paper does not test whether a more nuanced training approach — e.g., training on traces that include epistemic verbalization only at points of genuine uncertainty — would preserve recovery capability while reducing false alarms. The current finding (Table 5: DeepSeek-R1-Distill-32B drops from 80.0% to 43.3%) demonstrates that removing epistemic verbalization is catastrophic, but it does not demonstrate that improving its calibration is possible or easy.

The information-theoretic framework itself suggests a specific mitigation — track $H(Y \mid s_t)$ and trigger verbalization when it exceeds a learned threshold — but the paper does not propose, train, or evaluate any such mechanism. The mutual information analysis in Appendix F (Figure 10) measures $I(Y; h_t)$ post-hoc using a separate estimator, not in a form usable by the model during autoregressive generation. This is a significant practical gap: the paper proves that epistemic verbalization is sufficient for convergence, but does not provide a recipe for making it efficient (i.e., high recall with manageable precision) in a deployed system. Section 8 of the paper does not explicitly list this as future work, though the discussion of dynamic allocation in the broader framework would naturally encompass it.

Consequence: A model that verbalizes uncertainty indiscriminately (as LRMs currently do, with 24.4% precision) wastes substantial inference compute on unnecessary self-checks. A model trained to suppress epistemic verbalization entirely (as in Section 6.2) loses the ability to recover from silent divergence. The optimal calibration — verbalizing uncertainty when it is genuinely informative while suppressing it on confident correct trajectories — is not addressed by the current framework and may require explicit training on calibrated uncertainty signals that the paper does not develop. A practitioner deploying this approach would face an unresolved trade-off between recovery rate and inference cost, with no guidance from the paper on how to navigate it.

The Evidence Is Drawn from a Narrow Slice of Models, Benchmarks, and Tasks — Generalization to Other Reasoning Domains Is Unestablished

Every experiment in the paper is conducted on mathematical reasoning benchmarks — AIME24, AIME25, AMC23, and MATH500. Every model analyzed is from the Qwen family (Qwen2.5, Qwen3-Base) or a Qwen-derived distillation (DeepSeek-R1-Distill-Qwen). The capability map in Figure 3 includes Mistral-7B, Llama-3.1-8B, and Gemma-3-4B-it as contextualization, but these models are not subjected to any intervention, SFT, or collapse analysis. The paper's claims — that silent divergence is the dominant failure mode, that epistemic verbalization causally drives recovery, that 800 SFT examples suffice to instill or suppress the behavior — are all conditioned on this specific ecosystem of models and tasks.

The paper is transparent about this: the Limitations section states that "our empirical analysis is mainly conducted on mathematical reasoning benchmarks, where correctness is objectively verifiable. Extending the analysis to other closed-world reasoning tasks ... is left for future work." However, the transparency does not mitigate the concern — it names the gap without quantifying its severity.

Several specific concerns follow from this narrow scope:

Math reasoning may be uniquely amenable to epistemic verbalization. Mathematical problem-solving has a distinctive structure: well-defined subgoals (solve for x, apply the quadratic formula), clear correctness criteria (a derivation is either correct or not), and a conventional vocabulary for expressing uncertainty ("Wait, is that correct?" makes natural sense when checking an algebraic manipulation). It is unclear whether epistemic verbalization generalizes to reasoning domains with less crisp structure — e.g., legal reasoning (where correctness is fuzzy and argument structure matters more than step-by-step computation), medical diagnosis (where differential reasoning involves weighing probabilities rather than deriving closed-form answers), or code generation (where "uncertainty" might manifest as wanting to test a function rather than saying "Wait"). The paper proposes no theoretical reason why epistemic verbalization would be limited to math, but it also provides no evidence that it transfers.
The Qwen/DeepSeek ecosystem may be selected on the dependent variable. The models analyzed — Qwen2.5, Qwen3-Base, DeepSeek-R1-Distill-Qwen — are all from families known for strong reasoning performance and, in the case of DeepSeek-R1, explicitly trained for self-reflective reasoning. The paper uses these models to discover epistemic verbalization as a general mechanism, but the discovery may be an artifact of looking at models where the mechanism is already pronounced. Other model families (e.g., Llama, Mistral, Gemma) might exhibit different patterns — perhaps they exhibit different collapse modes, different rates of proactive correction, or different sensitivity to epistemic token suppression. The capability map (Figure 3) hints at this: the non-Qwen models cluster in the lower-left region, but without intervention experiments on them, it is impossible to know whether they can benefit from epistemic verbalization or whether their failure modes are fundamentally different.
The distributional alignment analysis (Figure 8) may not identify the true bottleneck for other families. The paper's explanation for why distillation succeeds or fails — alignment in epistemic token log-probabilities — is tested only on Qwen-variant models (Qwen2.5-7B, Qwen2.5-Math-7B, Qwen3-Base, DeepSeek-Math-7B-Instruct). It is plausible that the same mechanism applies to other model families, but it is equally plausible that other families have different bottlenecks — e.g., a Llama model might have "Wait" in its support but lack the attention patterns or internal representations needed to use it effectively as an epistemic signal. The paper does not test this.
The collapse taxonomy may be benchmark-specific. The five collapse types (incoherence, hallucination spiral, repetition, topic drift, infinite loop) are diagnosed by GPT-5 on math reasoning traces. On a code generation task, a different typology of failures might emerge (e.g., generating syntactically valid but logically wrong code, getting stuck in a function definition, confusing variable scopes). The paper does not claim universality for the taxonomy, but the empirical claim that "silent divergence is the dominant failure mode" depends on the taxonomy and the benchmark — silent divergence might be less prevalent in tasks where errors more frequently produce overt contradictions (e.g., code that fails to compile vs. code that runs but produces wrong output).

Consequence: A practitioner working in a non-math reasoning domain — code generation, scientific QA, legal analysis, planning, dialogue — cannot assume that the paper's findings transfer. Epistemic verbalization may be less effective in domains without clear sub-task boundaries, less amenable to uncertainty externalization, or less critical because alternative error signals (compilation errors, factual contradictions, constraint violations) provide more frequent overt triggers for reactive correction. The paper provides no methodology for assessing whether a given domain will benefit from epistemic verbalization, nor any evidence that its central claims hold outside the specific model-benchmark combination studied. This is a typical limitation for a framework paper introducing a new concept, but it is a significant practical constraint on the paper's prescriptive value.

The Practical Overhead of Difficulty Estimation and Trigger Calibration Is Entirely Unaccounted

The paper's intervention study (Section 4.1) demonstrates that injecting epistemic verbalization at experimenter-chosen truncation points recovers failed trajectories, but it sweeps four truncation fractions (α = 0.2, 0.5, 0.8, 0.9) and reports recovery rates without selecting an optimal α or accounting for the cost of the sweep. In a real deployment, the model does not know where its trajectory diverged — it must either (a) run multiple α-sweeps at inference time (prohibitively expensive), (b) verbalize uncertainty continuously throughout the trajectory (incurring the precision cost documented in Table 2), or (c) learn a triggering policy that activates epistemic verbalization at the right moments. None of these options is evaluated in the paper.

The unaccounted costs are substantial:

Continuous epistemic verbalization cost. If the model follows option (b) and verbalizes uncertainty at every step, it multiplies its output length — each epistemic utterance ("Wait, let me double-check...") adds tokens, and each subsequent verification step adds more tokens. The paper does not report the average output length of baseline vs. suppressed inference in the test-time suppression experiments (Section 6.1, Figure 5), so the cost of epistemic verbalization in tokens per problem is unknown. The LIMO dataset (Section 6.3, Figure 6) provides a rough proxy: "Wait" alone appears 77.1 times per response on average. For a model generating thousands of tokens per problem, 77 additional "Wait" tokens are negligible. But each "Wait" likely triggers a verification subsequence — re-reading a prior step, re-computing a value, confirming a constraint — that could easily add hundreds of tokens. The paper does not measure the total token overhead of epistemic verbalization, making it impossible to assess whether the accuracy gains (2–4× pass@1 improvements in some distillation settings) are cost-effective relative to simply generating more samples.
Trigger policy training cost. The SFT experiments train on 800 examples with or without epistemic verbalization, but this training does not teach the model when to verbalize — it teaches it whether to verbalize at all (always or never). Training a calibrated trigger policy — one that verbalizes when $H(Y \mid s_t) > \eta$ and suppresses otherwise — would require either (a) access to per-step uncertainty labels (which the paper does not have and does not propose a method for generating), or (b) reinforcement learning with a reward that balances accuracy gains against token costs (which the paper does not attempt). The cost of generating the training data for such a policy — collecting trajectories with per-step uncertainty estimates, or running RL with appropriate reward shaping — could easily dwarf the 800-example SFT cost that the paper emphasizes as "efficient."
Test-time suppression experiments underestimate the cost of epistemic verbalization. When epistemic tokens are suppressed at test time (Section 6.1), the models generate fewer tokens (since they cannot produce the banned vocabulary). If the suppressed models have 10% lower accuracy but 20% shorter outputs, the accuracy-per-token trade-off might be more favorable than the raw accuracy numbers suggest. The paper does not report output lengths for baseline vs. suppressed inference, so this trade-off cannot be evaluated. The 10% accuracy drop might be partially offset by the efficiency gain of shorter outputs, or it might not — the paper provides no data either way.

The open-world extension in Appendix B introduces a related unaccounted cost. In tool-augmented settings, external observations can substitute for epistemic verbalization by providing exogenous error signals — but tool calls are expensive (API costs, latency, compute). The paper correctly notes that "the performance gap between models with and without epistemic verbalization may narrow as the external observation channel becomes richer," but it does not provide any empirical characterization of this trade-off — e.g., at what rate of tool availability does epistemic verbalization become unnecessary, or how should a system allocate its budget between internal uncertainty monitoring and external information gathering?

Consequence: The paper's headline findings — "injecting a minimal doubt cue recovers ~15% of failed trajectories" (Section 4.1), "800 SFT examples suffice to instill or suppress" (Sections 6.2–6.3) — are computed without accounting for the cost of knowing when to inject the cue, calibrating the trigger frequency, or verifying after the verbalization. In a deployed system, these costs could consume a substantial fraction of the inference budget, particularly if the model's trigger precision is as low as the 24.4% observed in LRMs (Table 2). A practitioner evaluating whether to adopt epistemic verbalization training would need to know the total cost of ownership — training data generation, inference-time token overhead, latency impact — none of which is quantified in the paper. The framework's theoretical elegance (Proposition 5.3) provides an existence proof that epistemic verbalization works, but it does not provide a cost model for making it efficient, and the empirical work does not fill this gap.

The SFT Experiments Lack Replicates, Statistical Rigor, and Robustness to Training Stochasticity

The paper's most dramatic empirical claims — the 2–4× pass@1 improvements from 800-example LIMO distillation (Figure 7), the halving of accuracy from epistemic verbalization suppression (Table 5) — are each based on a single fine-tuning run per model, evaluated on a 30-question test set (AIME24). No replicate trainings, no standard deviations, no confidence intervals, no statistical tests. This is a significant methodological weakness, particularly given the small test set size: on 30 questions, each reported percentage point corresponds to less than one question correct, and a difference of a few percentage points — e.g., 16.7% to 10.0% for Qwen3-14B-Base in the suppression experiment — represents at most 2 additional correct answers out of 30.

The specific vulnerabilities introduced by this lack of rigor include:

Training stochasticity. Fine-tuning on 800 examples with modern optimizers involves substantial randomness — batch ordering, dropout, weight initialization, learning rate schedule interactions. The paper uses LLaMA-Factory with the default LIMO configuration (Appendix E), but does not specify whether multiple seeds were tested or whether the reported number is the best, worst, or only result observed. On a 30-question test set, training variance could easily produce swings of ±3–5 percentage points (1–2 questions), which would change the interpretation of some of the smaller reported effects.
Decoding hyperparameter sensitivity. The paper reports an ablation across temperatures (Appendix E, Table 7) showing that DeepSeek-Distill models perform substantially better at temperature 0.7 than temperature 0.0 (DeepSeek-R1-Distill-32B: 50.0% vs. 80.0% on AIME24). The LIMO evaluations fix temperature at 0.0, while base model pass@1 uses the better of 0.0 or 0.7. This means the "base vs. LIMO" comparisons for DeepSeek models compare base at temperature 0.7 to LIMO at temperature 0.0 — different decoding hyperparameters on top of the SFT effect. The paper does not report LIMO performance at temperature 0.7, so it is unknown whether the LIMO gains for DeepSeek-Distill models (reported as negative in Table 5 for the suppression experiment, positive in Figure 7 for LIMO distillation) would persist under consistent decoding settings.
No comparison to sampling-more baseline. The LIMO distillation results show that pass@1 on AIME24 for Qwen3-14B-Base improves from 16.7% to 60.0% (Figure 7). But the paper also reports pass@32 for the base model at 60.0% — meaning the base model already achieves the LIMO model's pass@1 when given 32 attempts. This raises the question: is the LIMO SFT actually improving the model's single-sample accuracy, or is it effectively shifting probability mass toward the correct answer in a way that is equivalent to simply sampling more from the base model? The paper does not compare the compute cost of (a) running LIMO SFT plus generating 1 sample versus (b) generating k samples from the base model with majority voting. If generating 32 samples from the base model costs less (or the same) as running 1 sample from the LIMO model (accounting for the training cost amortized over inference queries), the practical value of the SFT is unclear.
Unknown generalization to other test sets. The distillation and suppression experiments are evaluated exclusively on AIME24. It is unknown whether the reported gains and degradations would hold on AIME25, AMC23, MATH500, or other reasoning benchmarks. The collapse analysis (Section 3.2) and intervention study (Section 4.1) span multiple benchmarks, demonstrating that the mechanism generalizes, but the SFT results are restricted to a single 30-question test. Given the paper's own finding that benchmark difficulty strongly modulates epistemic verbalization behavior (Appendix G, Figures 13–14), it is plausible that the SFT effects are difficulty-dependent — e.g., LIMO distillation might provide large gains on AIME24 but smaller gains on MATH500 (where the base model is already stronger and epistemic verbalization provides less marginal benefit), or the suppression degradation might be less severe on easier benchmarks (where the model is less likely to enter silent divergence in the first place).
Absence of hold-out validation for SFT training data selection. The SFT suppression experiment (Section 6.2) collects "800 problems the model answers correctly" under the suppression instruction. If these 800 problems are drawn from the same distribution as the AIME24 test set (e.g., from the training split of the same benchmark family), there is a risk of data leakage — training on problems similar to the test set could confound the effect of epistemic verbalization suppression with the effect of exposure to test-set-like problems. The paper does not specify the source of the 800 training problems relative to the AIME24 evaluation set, making it impossible to assess this risk.

Consequence: The paper's empirical claims about the magnitude of epistemic verbalization's impact — "2–4× pass@1 improvement," "halving of accuracy," "800 samples suffice" — should be interpreted as qualitative existence proofs rather than precisely quantified effects. The direction of the effects (epistemic verbalization helps, suppressing it hurts, 800 examples can change behavior) is robustly demonstrated across multiple models and both instillation and suppression experiments. But the magnitudes are potentially sensitive to training seed, decoding hyperparameters, and the specific 30 questions in the AIME24 test set — differences of a few percentage points should not be over-interpreted. A practitioner seeking to replicate these results should budget for multiple training runs and evaluation on a larger test set (or a held-out validation split) to estimate variance, and should expect that the realized magnitude of the effect in a new setting may differ from the paper's point estimates.

The Proposal Distribution / Verifier Decomposition Is Incomplete — Epistemic Verbalization and Self-Correction Are Studied in Isolation from Procedural Improvement

The paper's central theoretical contribution is the decomposition of reasoning into procedural advancement and epistemic verbalization, with self-correction as a control action that operates on the information provided by both channels. However, the empirical program studies these components in a strangely asymmetric way: epistemic verbalization is the sole focus of intervention, measurement, and training, while the quality of the procedural channel — the accuracy of the base model's step-by-step computation — is taken as fixed and exogenous. The paper shows that adding epistemic verbalization to a procedurally-competent model improves recovery (Section 4.1) and that removing it from a procedurally-competent model degrades performance (Section 6.2), but it never asks the complementary question: can improvements to procedural reasoning substitute for epistemic verbalization, or vice versa?

Several specific dimensions of this incompleteness:

No joint optimization of procedural and epistemic channels. The paper's framework (Section 5.2) characterizes reasoning as "strategic information allocation under uncertainty" — the joint determination of how to advance the procedure and how much epistemic verbalization to allocate. Yet the experiments either manipulate epistemic verbalization while holding procedural capability fixed (Sections 4.1, 6.1–6.3) or measure procedural collapse without intervening (Section 3.2). There is no experiment that tests whether improving the procedural channel — e.g., by fine-tuning on higher-quality reasoning traces, using a better base model, or providing better few-shot examples — reduces the need for epistemic verbalization. The open-world analysis in Appendix B suggests exactly this dynamic: "the performance gap between models with and without epistemic verbalization may narrow as the external observation channel becomes richer." By analogy, the gap should also narrow as the internal procedural channel becomes richer — a model that makes fewer procedural errors enters silent divergence less often and thus has less need for epistemic verbalization. But this prediction is untested.
The LIMO distillation gains are ambiguous in source. As noted in Section 5, the LIMO dataset (Ye et al., 2025) differs from the base model's natural reasoning along many dimensions beyond epistemic verbalization — solution structure, formatting, problem-solving strategies, and the accuracy of the procedural reasoning itself. The paper attributes the performance gains primarily to epistemic verbalization acquisition, but a targeted ablation (e.g., training on LIMO with epistemic tokens removed but procedural reasoning preserved, or training on the base model's own reasoning with epistemic tokens added) would be needed to isolate the contribution. The token-level log-probability analysis (Figure 8) shows that distributional alignment in epistemic tokens correlates with success, which is suggestive but does not prove causality — it could be that models with better procedural alignment to the LIMO teacher (not just epistemic alignment) are the ones that succeed, and epistemic token alignment is merely correlated with overall distributional similarity.
No combination of PRM-style verifiers with epistemic verbalization. The reference paper studied two complementary mechanisms — search against a process reward model (PRM) and iterative revisions — and demonstrated that they have complementary, difficulty-dependent strengths (PRM search works best on medium-difficulty problems, revisions on easy problems). This paper identifies a different complementarity: procedural reasoning works when the trajectory is correct; epistemic verbalization works when the trajectory has silently diverged. But it never studies whether an external verifier (like a PRM) could detect silent divergence and trigger re-sampling, potentially substituting for or complementing epistemic verbalization. A verifier trained to predict trajectory correctness from hidden states could, in principle, detect the divergence that token-level entropy misses (Appendix C, Figure 9) and trigger a correction without requiring the model to externalize uncertainty. The paper does not compare epistemic verbalization against (or in combination with) such verifier-based approaches, making it unclear whether epistemic verbalization is the best mechanism for escaping silent divergence or simply a sufficient one.
The revision model analogue is not explored. The reference paper's revision model learns to generate improved answers by conditioning on previous incorrect answers. This paper's framework suggests an analogous idea: a model could be trained to explicitly revise its reasoning when epistemic verbalization surfaces uncertainty. But the paper treats self-correction as an emergent consequence of epistemic verbalization — "the model, upon seeing that it expressed doubt, can autonomously decide to re-evaluate" (Section 4.1 interpretation) — without studying whether this autonomous re-evaluation is optimal, whether it could be improved through explicit revision training, or whether different models have different revision policies that affect the benefit of epistemic verbalization. The intervention study (Section 4.1) injects doubt cues and measures whether recovery occurs, but it does not analyze how the model revises after the cue — does it simply re-sample the next step? does it backtrack and try a different approach? does it verify specific sub-computations? The mechanism of recovery after epistemic verbalization is a black box.

Consequence: The paper establishes that epistemic verbalization is a necessary mechanism for recovering from silent divergence in the current generation of models, but it does not establish that it is sufficient (the 15% recovery rate in Section 4.1 is modest in absolute terms) or that it is efficient relative to alternatives (verifier-based detection, improved procedural training, majority voting over more samples). A practitioner deciding how to allocate their reasoning model budget — invest in better procedural training, invest in epistemic verbalization SFT, invest in a verifier, or invest in more inference-time sampling — gets no guidance from the paper on the relative return on these investments. The framework provides a language for describing the trade-off (procedural vs. epistemic information allocation), but the empirical work provides no quantitative characterization of the trade-off surface.

The Formal Theory Proves Convergence Given an Unrealistic Independence Assumption, and the Gap Between Theory and Empirics Is Large

The paper's central theoretical guarantee — Proposition 5.3 (Sporadic Epistemic Verbalization Suffices for Convergence) — proves that $\mathbb{E}[H(Y \mid \tilde{S}_t)] \to 0$ as $t \to \infty$ , provided that epistemic verbalization occurs with probability at least $\rho$ whenever $H(Y \mid \tilde{S}_t) > \eta$ and each verbalization reduces entropy by at least $\delta$ . The proof (Appendix A) is straightforward: the expected per-step entropy reduction is at least $\rho\delta$ , which telescopes to a finite expected time to reach $\eta$ , and since this holds for all $\eta > 0$ , convergence to zero entropy follows.

The gap between this guarantee and the empirical reality of LLM reasoning is substantial in ways the paper acknowledges only partially.

First, the guarantee requires unbounded generation length. The proof shows that in expectation, the entropy converges to zero as $t \to \infty$ . But real LLM deployments have finite generation budgets — typically a few thousand tokens. The convergence rate is bounded by $\rho\delta$ , and if the product $\rho\delta$ is small (because $\rho$ is low — the model rarely verbalizes — or $\delta$ is small — verbalizations are weakly informative), the expected time to convergence could exceed the generation budget. The paper never estimates $\rho$ or $\delta$ for any model, so it is impossible to assess whether the convergence guarantee operates within practical generation lengths. The intervention study (Section 4.1) suggests that $\delta$ is positive but modest (recovery rates of 15–25% after a single injection), which implies that many verbalization steps might be needed for reliable convergence — potentially exceeding the token budget for hard problems.

Second, the guarantee depends on Assumption 5.2, which requires that epistemic tokens reduce entropy by at least $\delta$ independently of whether the trajectory is actually incorrect. This is a strong and non-obvious assumption. The paper argues that it is "consistent with the intervention study in Section 4.1, where injecting a doubt cue alone, without pinpointing any error, meaningfully enabled the recovery of failed trajectories." But the intervention study shows that injection sometimes enables recovery (15–25% of the time on MATH500, less on harder benchmarks) — not that it always provides positive information gain. The gap between "sometimes enables recovery" and "always provides $\delta$ entropy reduction" is significant: Proposition 5.3 requires a lower bound on per-step information gain, but the empirical evidence only provides an upper bound (the recovery rate) on the probability that a given injection is beneficial. If epistemic verbalization provides zero information gain on some fraction of steps (e.g., when the model is on a correct trajectory and verbalizes unnecessary doubt, or when the model is on an incorrect trajectory but the verbalization is too vague to trigger effective correction), the expected per-step gain could be much lower than $\rho\delta$ , and convergence could be much slower than the bound suggests.

Third, the proof assumes that $H(Y \mid \tilde{S}_t)$ can be driven to zero, which implies the model has the capability to reach the correct answer given sufficient computation. This is violated for the hardest problems in the paper's own analysis. Figure 2a shows that collapse rates rise to 78–83% on AIME25 — problems where the model's base pass@1 is near zero. In this regime, $H(Y \mid s_0)$ is high (the model is very uncertain about the answer) and no amount of epistemic verbalization will reduce it substantially, because the model simply lacks the procedural capability to generate a correct solution even if it knows it is on a wrong path. The paper acknowledges this in a different context: "the hardest questions (difficulty bin 5 in the reference paper) show near-zero improvement regardless of compute budget." The analogy is direct — Proposition 5.3 guarantees convergence only if convergence is possible (i.e., there exists a sequence of tokens that drives entropy to zero). For problems outside the model's capability range, no amount of epistemic verbalization will help, because the bottleneck is procedural competence, not uncertainty monitoring. The paper's framework does not distinguish between "uncertain because the trajectory is wrong but the model is capable of finding the right one" and "uncertain because the problem exceeds the model's procedural ceiling" — both produce high $H(Y \mid s_t)$ , but only the first is addressable by epistemic verbalization.

Fourth, the theoretical framework treats all epistemic verbalizations as interchangeable — any expression of uncertainty provides at least $\delta$ information gain — but the empirical evidence (Section 4.1, Figure 4) shows that different phrasings produce different recovery rates, and Appendix H.1 shows that models can route around suppressed tokens with alternative expressions. This implies that $\delta$ is not a constant across verbalization types — some uncertainty expressions are more informative than others — and that the effective $\delta$ depends on the model's familiarity with the verbalization form (bypass expressions may be less effective than habitual ones, explaining the residual 10% degradation in Section 6.1). The convergence proof does not accommodate this variation; it assumes a uniform lower bound $\delta$ .

Consequence: Proposition 5.3 establishes the in-principle sufficiency of epistemic verbalization — it shows that the mechanism can drive convergence, not that it will for any specific model, problem, or generation budget. The empirical evidence that epistemic verbalization is causal (Section 4.1) and learnable (Sections 6.2–6.3) is strong, but the quantitative connection between the theoretical guarantee and the experimental results is loose. A practitioner cannot use the theory to predict, for a given model and problem distribution, how much epistemic verbalization training is needed, what convergence rate to expect, or whether the convergence will complete within a typical generation budget. The theory provides conceptual clarity (why epistemic verbalization matters) but not engineering guidance (how much to invest in it). This is a reasonable limitation for a framework paper introducing a new mechanism — the theory's primary contribution is explanatory, not predictive — but it means the paper's claims about convergence should be read as qualitative insights rather than operational guarantees.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper reframes LLM reasoning from a single-channel information accumulation process into a dual-channel system of procedural computation and epistemic monitoring, and in doing so, it resolves a cluster of contradictory findings that have confused the field for several years. The conceptual shift is not a new architecture or training algorithm — it is a new ontology of reasoning tokens: some tokens advance the computation, others externalize uncertainty about whether the computation is on track, and these two categories are informationally distinct, causally independent, and must be jointly optimized. This reframing clarifies what prior work could not.

Resolution of contradictory findings on self-correction. Before this paper, the literature on LLM self-correction was genuinely confused. Huang et al. (2024), Tsui (2025), Tyen et al. (2024), and Kamoi et al. (2024) demonstrated that LLMs can correct externally provided errors yet systematically fail to fix the same errors in their own outputs — a finding that undermined claims of genuine self-monitoring. d'Aliberti and Ribeiro (2026) showed that markers like "Wait" correlate only weakly with performance gains, suggesting these tokens are epiphenomenal. Liu et al. (2025) found that apparent self-reflection often degenerates into repetition. Meanwhile, DeepSeek-R1 and similar models demonstrably do recover from incorrect trajectories through spontaneous self-correction — a phenomenon the skeptical literature could not explain.

This paper resolves the contradiction by distinguishing the informational content of a token from its surface form. When "Wait" appears as an empty high-entropy filler (the case captured by d'Aliberti and Ribeiro, 2026), it carries no information about trajectory reliability and does not enable correction. When "Wait" reflects genuine epistemic verbalization — the externalization of internal uncertainty about the trajectory — it provides conditionable information that downstream control actions (self-correction) can act on. The same surface token can be informationally empty or informationally rich, depending on whether the model's internal uncertainty assessment $Z_t$ is genuinely being externalized. The skeptical literature studied models where $\rho \approx 0$ (standard LLMs that almost never externalize uncertainty without an overt error trigger), so "Wait" tokens in those studies were predominantly empty surface forms — and the weak correlation with correction follows directly. The DeepSeek-R1 phenomenon reflects models where $\rho$ is non-trivial because post-training has instilled the epistemic verbalization habit, so "Wait" tokens more frequently carry genuine information. The two literatures were studying different populations of "Wait" tokens — one predominantly empty, one frequently meaningful — and reaching opposite conclusions because they were measuring different things with the same surface proxy.

Shift from error detection to continuous uncertainty monitoring. The paper's characterization of silent divergence — where the model's belief about the correct answer drifts while surface coherence is preserved, with no overt error ever surfacing — fundamentally changes what the field should optimize for. Prior work on reasoning improvement assumed that the bottleneck was better error detection: if we could train models to recognize when they've made a mistake, they could correct it. This paper shows that 54–62% of incorrect responses from standard LLMs involve reasoning collapse where no error surfaces to be detected (Section 3.2, Table 6). In this regime, the problem is not that the model fails to recognize errors — it's that the errors are of a type that never trigger recognition mechanisms in the first place. The shift is analogous to the difference between a smoke detector (which triggers on visible signs of fire) and a continuous temperature monitor (which detects abnormal heating before anything catches fire). Epistemic verbalization is the continuous monitor; reactive correction is the smoke detector. The paper demonstrates that standard LLMs have the smoke detector but lack the continuous monitor, and that this absence — not poor error detection — is the dominant source of reasoning failure.

This shifts research priorities in a specific way: improving verifier robustness and calibration becomes more important than developing more sophisticated search or self-correction algorithms. The reference paper identified verifier over-optimization as the bottleneck for test-time compute scaling; this paper identifies trigger calibration (when to verbalize uncertainty) as the bottleneck for epistemic monitoring. In both cases, the key constraint is not the power of the correction mechanism but the reliability of the signal that feeds it. Researchers working on self-correction should invest in better uncertainty estimation and more calibrated verbalization policies rather than more elaborate correction strategies.

Recategorization of reasoning capabilities as linguistic habits. Perhaps the most disruptive implication is the finding that epistemic verbalization — and with it, substantial fractions of reasoning accuracy — can be instilled or suppressed with as few as 800 SFT examples (Sections 6.2–6.3). This recategorizes a capability that appeared to require large-scale RL (DeepSeek-R1's self-reflective reasoning) as a learnable linguistic habit that operates at the level of token generation preferences. The model does not need to become "smarter" or acquire new reasoning strategies; it needs to learn to externalize uncertainty when its internal assessments indicate high trajectory uncertainty. The fact that 800 examples suffice — and that the same 800 examples can be catastrophic when the student model's token distribution is misaligned (Qwen2.5-Math-7B drops to 0% pass@1, Figure 7) — demonstrates that this is a surface-level behavioral adaptation, not a deep cognitive restructuring.

This finding reframes the success of small-data reasoning distillation (like LIMO, Ye et al., 2025) as primarily the transfer of epistemic verbalization habits rather than the transfer of mathematical knowledge or problem-solving strategies. The implication is that distillation efforts should explicitly target epistemic verbalization as a transfer objective — measuring and optimizing for the student model's acquisition of the teacher's uncertainty externalization patterns — rather than treating it as an incidental byproduct of training on high-quality traces. It also implies that pretraining data mixtures that include diverse uncertainty expressions may be a prerequisite for effective reasoning distillation later, since the student model needs epistemic tokens within its distributional support before SFT can amplify their use.

What becomes less attractive. The paper's framework implies that purely procedural improvements to Chain-of-Thought — better prompt engineering, more detailed step-by-step instructions, finer-grained sub-task decomposition — have a ceiling that is determined by the silent divergence problem. No amount of procedural refinement can help if the model enters a silently diverged trajectory and has no mechanism to detect it. Research that focuses exclusively on making procedural reasoning more accurate without addressing the epistemic monitoring channel is optimizing the wrong axis for the dominant failure mode. Similarly, the paper's finding that token-level entropy fails as a corrective signal (Appendix C, Figure 9) — because local token confidence tracks fluency rather than answer-correctness — means that approaches relying on internal uncertainty measures that are not externalized (e.g., using hidden-state entropy to trigger early exit or beam search pruning) will inherit the same limitation: they can detect local uncertainty about the next token but cannot distinguish globally correct from globally incorrect trajectories.

What becomes more attractive. Several research directions gain urgency. Training calibrated trigger policies for epistemic verbalization — so that models verbalize uncertainty when $H(Y \mid s_t)$ is high and suppress it when confidence is justified — becomes the central practical challenge, because the current 24.4% precision (Table 2) indicates that LRMs are wasteful in their uncertainty expression. Distributional alignment in epistemic token spaces becomes a key design consideration for pretraining and distillation pipelines, since the paper shows that misalignment is a hard barrier to transfer (Figure 8). The open-world extension (Appendix B) opens a research program on the trade-off between internal uncertainty monitoring and external information gathering — when should a model verbalize doubt versus query a tool — that connects epistemic verbalization to the agent and tool-use literatures. And the framework's separation of information from control suggests that verification and self-correction should be studied as distinct components: epistemic verbalization supplies the information, and the control policy determines how to act on it. Improving either component independently — better uncertainty externalization, or better correction strategies given externalized uncertainty — could yield gains, and the decomposition makes it possible to study them separately.

Follow-Up Research This Work Enables

Training calibrated epistemic verbalization policies with reinforcement learning. The paper's central unresolved practical problem is that LRMs verbalize uncertainty with only 24.4% precision (Table 2) — three-quarters of all proactive corrections second-guess already-correct chains. The Proposition 5.3 guarantee shows that even low precision is sufficient for convergence in expectation with unbounded length, but for finite generation budgets, precision directly determines efficiency: a model wasting 75% of its epistemic verbalization budget on unnecessary checks is leaving substantial recovery capacity on the table. A natural follow-up would train a policy that decides, at each reasoning step, whether to generate an epistemic token, using a reward function that combines answer correctness with a penalty on output length (to discourage unnecessary verbalization). The training signal could come from outcome-based RL (the DeepSeek-R1 approach, but with an explicit length penalty) or from process-level supervision (labeling each step with whether epistemic verbalization would have been beneficial, using the intervention study methodology from Section 4.1 as a labeling oracle). The key measurement would be precision at matched recall — can we maintain the recovery benefit of epistemic verbalization while reducing false alarms? If even a modest improvement is possible (e.g., raising precision from 24% to 50%), the efficiency gains in tokens-per-correct-answer would be substantial, making epistemic verbalization practically viable for latency-sensitive deployments.

Measuring and estimating the convergence parameters ρ and δ for specific models and problems. Proposition 5.3 provides a convergence bound $\mathbb{E}[\tau_\eta] \leq (\mathbb{E}[H_0] - \eta) / (\rho\delta)$ , but the paper never estimates $\rho$ (the probability of epistemic verbalization given high uncertainty) or $\delta$ (the per-verbalization information gain) for any model. Without these parameters, the theory provides qualitative insight but no quantitative prediction. A measurement study would: (a) develop an estimator for $H(Y \mid s_t)$ — perhaps using the HSIC-based approach from Appendix F or an ensemble-based uncertainty estimator — that can be computed at each step of a reasoning trace; (b) measure $\rho$ as the empirical frequency of epistemic tokens at steps with $H(Y \mid s_t) > \eta$ for different threshold choices $\eta$ ; (c) measure $\delta$ as the average drop in $H(Y \mid s_t)$ following an epistemic verbalization; and (d) predict convergence times for different models and problem difficulties, then validate against observed recovery behavior. This would transform the theoretical framework from a qualitative explanation into a quantitative engineering tool. The measurement could also characterize how $\rho$ and $\delta$ vary with model scale, model family, and problem difficulty — the paper's Appendix G suggests scale and difficulty effects exist for epistemic token frequency (a proxy for $\rho$ ), but $\delta$ is completely unmeasured. A negative result — e.g., finding that $\rho\delta$ is so small that expected convergence times exceed practical generation budgets for all but the easiest problems — would substantially qualify the framework's practical significance and redirect effort toward increasing $\delta$ (making epistemic verbalizations more informative) rather than increasing $\rho$ (making them more frequent).

Comparing epistemic verbalization against verifier-based uncertainty detection on matched problems. The paper shows that token-level entropy fails as a corrective signal (Appendix C, Figure 9) and that epistemic verbalization succeeds (Section 4.1). But it does not compare epistemic verbalization against a trained verifier — a separate model (or a separate head on the same model) trained to predict whether the current trajectory will reach the correct answer. A verifier operating on hidden states could, in principle, detect silent divergence without requiring the model to externalize uncertainty, because it has access to the same internal representations that encode $Z_t$ . The comparison would train a PRM-style verifier on the same base model, evaluate its ability to detect silent divergence (by measuring its accuracy at flagging steps in trajectories that eventually produce wrong answers), and compare against epistemic verbalization on two axes: (a) detection accuracy (does the verifier catch silent divergence better than the model's spontaneous epistemic verbalization?), and (b) recovery rate when the detection signal is used to trigger re-sampling (does verifier-triggered re-sampling recover failed trajectories at rates comparable to the 15–25% achieved by epistemic cue injection in Section 4.1?). This comparison would determine whether epistemic verbalization is the best mechanism for escaping silent divergence or simply a sufficient one. A finding that trained verifiers substantially outperform epistemic verbalization would redirect effort toward verifier development rather than epistemic verbalization training; a finding that epistemic verbalization holds its own (or that verifiers suffer from the same over-optimization problems documented in the reference paper) would strengthen the case for the epistemic channel as a first-class mechanism.

Testing the open-world trade-off between epistemic verbalization and tool use. Appendix B sketches a theoretical prediction: in open-world settings where the model can query tools or interact with an environment, external observations can substitute for epistemic verbalization by providing exogenous error signals. This prediction is empirically testable and practically important. The experiment would: (a) take a set of reasoning problems where tool calls are possible (e.g., problems where a calculator, a code interpreter, or a search query could resolve uncertainty); (b) compare two model variants — one with epistemic verbalization training (LIMO-distilled) and one without — across different rates of tool availability (0%, 25%, 50%, 100% of problems allow tool calls); and (c) measure the performance gap between the two variants as a function of tool availability. The prediction is that the gap narrows as tool availability increases — when the model can query an external oracle, it has less need for internal uncertainty monitoring. The measurement would quantify this trade-off: at what tool availability rate does epistemic verbalization become unnecessary? Is the relationship linear (each additional tool call reduces the epistemic verbalization benefit by a constant amount) or thresholded (epistemic verbalization helps until tool availability exceeds some critical value, then becomes irrelevant)? This would provide practical guidance for system design: for a given tool budget, should the developer invest in epistemic verbalization training or in better tool integration? The experiment would also test a more nuanced hypothesis — that epistemic verbalization serves as a dispatch signal for tool use (the model verbalizes doubt and then decides to query a tool), meaning the two mechanisms are complementary rather than substitutive at moderate tool availability rates.

Characterizing collapse modes and epistemic verbalization across non-math reasoning domains. The paper's entire empirical program is conducted on mathematical reasoning benchmarks. The collapse taxonomy (incoherence, hallucination spiral, repetition, topic drift, infinite loop) is diagnosed by GPT-5 on math traces. It is unknown whether the same collapse modes appear in other reasoning domains, whether they appear at similar rates, and whether epistemic verbalization provides similar recovery benefits. A replication study across three contrasting domains would substantially broaden the framework's scope: (a) code generation (e.g., HumanEval, MBPP) where correctness is verifiable via test cases and "errors" often manifest as execution failures rather than logical contradictions; (b) legal or ethical reasoning (e.g., professional exam questions) where correctness is fuzzier and reasoning involves weighing principles rather than deriving closed-form answers; and (c) multi-step planning (e.g., TravelPlanner or strategy games) where the model must maintain state across many steps and errors compound. For each domain, the study would replicate the collapse analysis (Section 3.2 methodology, adapted with domain-appropriate collapse categories), the proactive/reactive correction classification (Section 3.3), and the intervention study (Section 4.1, with domain-appropriate epistemic cues — e.g., "Wait, does this function handle edge cases?" for code generation). The finding would either establish epistemic verbalization as a domain-general mechanism (strengthening the paper's claims) or identify boundary conditions where silent divergence is less prevalent or epistemic verbalization is less effective, refining the framework's scope.

Developing dynamic, context-sensitive verbalization policies that adapt to trajectory state. The paper's SFT experiments treat epistemic verbalization as a binary habit: the model either verbalizes (LIMO-distilled) or suppresses (Section 6.2). The theoretical framework suggests a richer possibility: the model should verbalize more when $H(Y \mid s_t)$ is high and less when it is low, and the optimal verbalization rate likely varies with problem difficulty, model capability, and trajectory position. A dynamic policy would: (a) use a lightweight estimator of trajectory uncertainty — perhaps a small probe trained on hidden states to predict eventual correctness, or the HSIC-based MI estimator from Appendix F adapted for online use — to continuously assess $H(Y \mid s_t)$ ; (b) learn a threshold function (possibly problem-dependent) that triggers epistemic verbalization when uncertainty exceeds the threshold; and (c) adapt the verbalization form to the estimated type of uncertainty (e.g., a targeted "Wait, is that calculation correct?" when uncertainty is localized to a specific sub-computation vs. a broader "Hmm, let me reconsider the approach" when the entire trajectory seems unreliable). This policy could be trained via RL (rewarding correct answers while penalizing token length) or via imitation learning on trajectories where epistemic verbalizations are labeled as beneficial or wasteful based on post-hoc analysis. The measurement would compare the dynamic policy against (a) always-verbalize (LIMO-style), (b) never-verbalize (suppression-style), and (c) fixed-frequency verbalization, on the axes of accuracy, token efficiency, and precision-recall of verbalization triggers. A successful dynamic policy would demonstrate that the gains from epistemic verbalization can be preserved while substantially reducing the token overhead — closing the efficiency gap that the paper leaves unresolved.

Ablation of training data content in LIMO-style distillation to isolate epistemic verbalization from procedural quality. The paper attributes the LIMO distillation gains (Figure 7) primarily to epistemic verbalization acquisition, but the LIMO dataset differs from base model traces along many dimensions — solution structure, formatting, problem-solving strategies, and the accuracy of the procedural reasoning itself. This confound could be resolved by an ablation that creates three training datasets from the same 800 problems: (a) Full LIMO — the original teacher traces with all epistemic verbalizations and procedural content; (b) LIMO minus epistemic — the same traces but with epistemic tokens identified in Section 4.2 removed (or replaced with neutral transitions) while preserving the procedural reasoning; and (c) Base plus epistemic — the base model's own reasoning traces (which lack epistemic verbalization) augmented with epistemic cues injected at points identified by an uncertainty estimator or by the teacher model's verbalization positions. Training the same student model on all three datasets and measuring AIME24 pass@1 would decompose the LIMO gain into the portion attributable to epistemic verbalization (difference between Full LIMO and LIMO minus epistemic, or between Base plus epistemic and Base) and the portion attributable to improved procedural reasoning quality (difference between LIMO minus epistemic and Base). This would directly test the paper's central claim that epistemic verbalization — not better procedural reasoning — is the active ingredient in small-data reasoning distillation. A finding that the epistemic-only gain is small (while the procedural-quality gain is large) would substantially revise the paper's interpretation.

Practical Applications and Downstream Use Cases

Small-data reasoning distillation with epistemic verbalization awareness. The paper's findings directly inform the practice of distilling reasoning capabilities from large models into smaller ones using small datasets (the LIMO paradigm, Ye et al., 2025). The key practical insight is that distillation success depends on distributional alignment in epistemic token probabilities (Figure 8). A practitioner preparing to distill a reasoning model should: (a) compute the log-probability that the student base model assigns to the teacher's frequent epistemic tokens ("Wait," "hmm," "perhaps," etc.) using the teacher's training data as context; (b) if these tokens are within the student's support (even at low probability), proceed with LIMO-style distillation expecting 2–4× pass@1 improvements as observed for Qwen2.5-7B (13.3% → 36.7%) and Qwen3-14B-Base (16.7% → 60.0%); (c) if these tokens are far outside the student's support (as observed for Qwen2.5-Math-7B and DeepSeek-Math-7B-Instruct, which degraded catastrophically), invest in an intermediate fine-tuning stage — perhaps continued pretraining on a corpus rich in uncertainty expressions, or SFT on a smaller dataset specifically designed to bring epistemic tokens into the model's active vocabulary — before attempting reasoning distillation. This diagnostic step is cheap (computing token log-probabilities on the training data) and can prevent the catastrophic failures observed in the paper, where the same 800 examples that tripled Qwen3-14B-Base's pass@1 reduced Qwen2.5-Math-7B's pass@1 to zero.

Reasoning model post-training that targets epistemic verbalization as an explicit objective. The paper shows that the proactive correction capability distinguishing LRMs from standard LLMs (Figure 3, Table 1) is a learnable habit that can be instilled or suppressed with small data. This suggests a specific modification to reasoning model post-training pipelines (RL, instruction tuning, or SFT): explicitly incentivize epistemic verbalization at points of genuine trajectory uncertainty, rather than treating it as an emergent property of large-scale RL. A concrete recipe: (a) collect a dataset of reasoning traces with per-step labels indicating whether the trajectory eventually reached the correct answer; (b) identify steps where the trajectory later diverged but no overt error was present at that step (silent divergence points); (c) construct training examples that insert epistemic verbalizations at those steps and demonstrate recovery; (d) fine-tune the base model on these examples, with the objective of learning when to verbalize (not just that verbalization is possible). The paper's SFT suppression experiment (Section 6.2) provides the negative result establishing that removing epistemic verbalization degrades performance by 40–80% across models (Table 5); the positive counterpart — targeted epistemic verbalization training — should recover at least some of that gap while avoiding the precision penalty documented in Table 2. For a model like Qwen3-8B-Base where suppression drops pass@1 from 16.7% to 3.3%, even a partially calibrated epistemic verbalization policy could restore most of the loss with modest token overhead — a practical win for models deployed in settings where accuracy is prioritized over per-query cost.

Diagnosis of reasoning failures in production LLM deployments. The collapse taxonomy (Section 3.2, Figure 2, Table 6) and the reactive/proactive correction distinction (Section 3.3, Table 1) provide a diagnostic vocabulary that operations teams can use to monitor reasoning quality in deployed models. Rather than tracking only aggregate accuracy, a team could: (a) periodically sample incorrect responses from production traffic, classify them using the GPT-5 judge prompt from Appendix D.1 into the five collapse types plus "non-collapse error," and track the collapse rate over time; (b) separately track the ratio of proactive to reactive corrections in correct responses (using the two-stage classification pipeline from Appendix D.2) as a measure of the model's epistemic monitoring health. A rising collapse rate (particularly incoherence and hallucination spirals) would indicate that the model is increasingly susceptible to silent divergence — perhaps due to distribution shift in input problems, model drift from continuous fine-tuning, or changes in decoding parameters. A declining proactive correction ratio would indicate that the model is losing its epistemic verbalization habit — potentially due to accidental suppression during fine-tuning (the paper shows in Section 6.2 that even 800 examples of suppression-oriented training can eliminate the behavior). This monitoring approach provides leading indicators of reasoning degradation before aggregate accuracy metrics show significant decline, enabling preemptive intervention (reverting to a previous checkpoint, adjusting decoding parameters, or running targeted fine-tuning to restore epistemic verbalization).

Pretraining data curation for downstream reasoning capability. The paper's finding that distributional alignment in epistemic token probabilities is a hard prerequisite for successful reasoning distillation (Figure 8) implies a design principle for pretraining data mixtures: include diverse, natural expressions of uncertainty and self-questioning in pretraining corpora if downstream reasoning transfer is anticipated. Models like DeepSeek-Math-7B-Instruct and Qwen2.5-Math-7B — math specialists that catastrophically failed LIMO distillation — may have been pretrained or fine-tuned on corpora dominated by clean, direct solutions without metacognitive commentary, causing epistemic tokens to drift outside their active vocabulary support. A pretraining team anticipating that their model will later undergo reasoning distillation from a teacher that uses epistemic verbalizations (as essentially all current strong reasoning models do) should ensure that the pretraining data includes: (a) informal mathematical problem-solving with self-doubt, hesitation, and revision (e.g., forum discussions, scratch work, tutoring transcripts); (b) diverse uncertainty expressions across multiple languages and registers, not just the nine epistemic tokens identified in Section 4.2 but also their paraphrases and equivalents; and (c) exposure to the specific lexical patterns used by target teacher models (the paper shows in Appendix G, Figure 14, that distilled models adopt the teacher's epistemic vocabulary distribution — "Wait" dominates when the teacher uses "Wait" heavily — so pretraining should cover the teacher's preferred expressions). The expected benefit is qualitative: the difference between a model that can successfully absorb epistemic verbalization from 800 examples (2–4× pass@1 improvement) and one that degrades catastrophically (0% pass@1) is the difference between a viable distillation pipeline and a failed one, and the paper's evidence suggests this difference is determined at pretraining time, not at distillation time.