ArXiv: 2510.10494

🎯 Pitch

The hidden state trajectory during reasoning predicts answer correctness better than output-based confidence—reducing compute waste by up to 70% while boosting accuracy. These signals emerge early, letting you kill bad traces before they finish generating.

1. Executive Summary

This paper analyzes how the temporal evolution of a model's internal hidden states during reasoning can predict solution accuracy, evaluating three open-source reasoning models—DeepSeek-R1-Distill-Qwen-14B, Phi-4-Reasoning-Plus, and Qwen3-14B—across scientific (GPQA), mathematical (AIME 2025), and algorithmic (TSP) domains. The authors introduce a family of Latent-Trajectory signals that capture three complementary aspects of representational change: Net Change (the overall shift from the first to last reasoning segment), Cumulative Change (the total accumulated movement across all intermediate steps), and Aligned Change (the extent to which intermediate updates advance toward the final state). These signals predict solution correctness more reliably than both cross-layer metrics and output-distribution-based confidence measures, and when used to guide answer selection in multi-sample inference, they reduce token usage by up to 70% while improving accuracy by 2.6% on average over majority voting—matching or exceeding majority-vote performance with fewer than half the samples. The signals are predictive early in the trace, enabling compute to be allocated to the most promising candidates before full generation, establishing that a model's internal latent dynamics carry robust information about reasoning quality even when surface-level heuristics and output-based confidence estimates fail.

2. Context and Motivation

The Core Problem: Reasoning Models Generate Many Traces, but We Don't Know Which Ones Will Succeed

This paper addresses a fundamental inefficiency in how we use reasoning-enabled large language models today. Models like DeepSeek-R1, Phi-4-Reasoning-Plus, and Qwen3 have been explicitly trained or fine-tuned to produce long chains of intermediate reasoning tokens—often thousands of tokens per answer—before arriving at a final solution. As the authors note in Section 1, "scaling compute at inference time to generate longer and multiple chains-of-thought (reasoning traces) and aggregating them into a final solution" has become the dominant paradigm for tackling complex reasoning tasks.

The problem is deceptively simple: not all reasoning traces are created equal. Some contain productive steps that lead toward correct answers, while others "deviate into unproductive paths such as overthinking, failing to converge on a valid solution strategy, or exhibiting inconsistent reasoning" (Section 1). The model generates all of these traces at substantial computational cost, yet we typically have no way of knowing mid-generation whether a particular trace is on a promising path—we simply run the full chain to completion and check the answer afterward.

This creates a critical gap: we lack reliable, computationally cheap signals for distinguishing high-quality reasoning traces from low-quality ones during inference. If we could identify which traces are likely to succeed early in the generation process, we could:

  • Avoid wasted computation on unproductive paths (the model wouldn't need to complete traces that are already going wrong).
  • Make multi-sample inference more efficient (we could stop generating new samples once we've found one that looks promising, rather than always generating a fixed number).
  • Enable early allocation of compute to the most promising candidates (in parallel generation scenarios, we could prune unpromising traces early and let the strong ones run to completion).

Why This Problem Matters

The significance of this gap has grown dramatically with the rise of reasoning models. The authors identify two compounding sources of inefficiency that make this problem urgent:

Source 1: The sample-level inefficiency. In practice, reasoning models are rarely used with a single generation—majority voting over multiple samples has "become the default approach for recent releases of reasoning models, since a single inference pass is rarely sufficient for robust performance, especially in applications or agentic settings" (Section 5.2). Generating five samples for every query means five times the computation. If we can identify a correct sample from its latent dynamics after generating just one or two traces, we can skip the remaining three or four. This directly translates to cost savings in production deployments.

Source 2: The trace-level inefficiency. Reasoning models exhibit a well-documented phenomenon the authors refer to as "overthinking": they "consume compute even after reaching a correct solution" (Section 2, citing Balachandran et al., 2025; Shojaee et al., 2025; Sui et al., 2025). A model might figure out the answer within the first 2,000 tokens but continue generating another 8,000 tokens of unnecessary reasoning before finally producing the answer. If the latent dynamics stabilize or show signs of convergence early, we could potentially stop generation early, saving those 8,000 tokens.

These two sources of inefficiency compound: we generate multiple long traces, many of which are unnecessarily long and some of which are doomed to be wrong from early on. The paper's goal is to provide signals that address both problems simultaneously—reducing the number of samples needed and identifying high-quality traces early within a single sample's generation.

Beyond efficiency, there is also a reliability problem. The paper notes that when we aggregate multiple samples via majority voting, we're treating all traces equally. But in practice, on difficult problems, the majority of generated traces may be incorrect—in those cases, majority voting actively hurts accuracy by drowning out the minority of correct solutions. If we could identify which individual traces are likely correct (via their latent dynamics), we could select them directly rather than relying on the crude heuristic of "choose the most common answer." This is why the paper shows that LT-guided selection can actually improve accuracy over majority voting, not just match it: it identifies correct solutions even when they are in the minority among sampled generations.

Where Prior Approaches Fall Short

The paper systematically identifies and critiques several families of existing methods, showing specific limitations that motivate the latent-trajectory approach:

Verifier models are effective but expensive. The dominant approach for assessing reasoning quality is to train or use separate verifier models that score candidate answers (Weng et al., 2023; Madaan et al., 2023; Zhang et al., 2024). These can be external models trained specifically for verification, or the same model prompted to self-verify its own outputs (the "self-verification" approach of Madaan et al., 2023). The problem, as the authors state in Section 2, is that these approaches "substantially increase inference cost." Running a separate verifier model doubles the inference budget (you pay for both the generator and the verifier). Having the same model self-verify means running multiple additional forward passes. Either way, the computational overhead undercuts the efficiency gains the verification is supposed to enable.

Surface-form analysis of reasoning traces is unreliable. A second line of work performs fine-grained analysis of the natural-language content of reasoning traces, developing metrics that "target factual and logical validity, as well as linguistic and semantic coherence" (Section 2, citing Wu et al., 2025; Golovneva et al., 2022). These approaches analyze what the model says it's doing—looking for logical fallacies, inconsistent statements, or incoherent reasoning in the surface text. The paper identifies two problems with this:

  1. Cost: These methods "often require annotation or structured extraction from traces, which introduces dependence on human raters or auxiliary expert models" (Section 2). You need humans to label what constitutes good reasoning, or you need another model to parse and evaluate the trace text. Either way, it's expensive.

  2. Unreliability of surface form: Perhaps more fundamentally, there is growing evidence that "natural language reasoning traces may not always reflect the underlying strategies that models employ" (Section 1, citing Chen et al., 2025; Stechly et al., 2025). The model might produce a plausible-sounding but ultimately misleading chain of reasoning that leads to a correct answer through a different internal mechanism than what the text describes. This is the "reasoning models don't always say what they think" problem (Chen et al., 2025)—the surface text is an unreliable proxy for what's actually happening in the model's computation. The paper also notes that "some models are trained to produce intermediate latent embeddings rather than explicit text" (Section 1, citing Hao et al., 2024), making surface-form analysis impossible for that model class.

Output-distribution-based confidence measures are weak. A common heuristic approach is to extract confidence estimates from the model's output token probabilities—metrics like the logit margin (difference between top-2 token logits), the entropy of the output distribution, or perplexity (Kadavath et al., 2022; Yona et al., 2022). The intuition is that if the model is confident in its answer, the probability distribution over the final answer token should be sharply peaked (high logit margin, low entropy). The paper tests these metrics and finds them "significantly weaker and less consistent, with performance often close to or below chance level" (Section 5.1, Figure 3). Specifically, on the reasoning models studied, these output-distribution measures achieve ROC-AUCs of roughly 0.44–0.59, barely above the 0.5 random baseline in some cases. Why? The paper doesn't speculate extensively, but one plausible explanation is that reasoning models are trained to generate long traces before answering—the probability distribution at the final answer token may not reflect the model's internal state of certainty, because the model has been optimized to produce the answer after completing the reasoning process regardless of whether the reasoning converged early.

Trace length heuristics are unreliable. Recent work has explored whether shorter reasoning traces are more likely to be correct, based on the observation that correct solutions often involve more direct, less "wandering" reasoning (Hassid et al., 2025; Marjanović et al., 2025). The paper tests this "shortest-answer selection" baseline (Section 5.2) and finds it "reduces accuracy by an average of 1.4%" compared to majority voting, demonstrating that "length alone is an unreliable proxy for correctness." While there may be a correlation between trace length and correctness in aggregate, the relationship is too noisy to serve as a reliable selection criterion for individual traces.

Cross-layer representational signals are inconsistent. The closest prior work to this paper is the cross-layer curvature analysis of Wang et al. (2024), which examined how much representations change across layers within a single token position (a "spatial" perspective) and found that these changes correlate with answer accuracy in instruction-tuned models. The paper replicates this approach as a baseline, computing "the mean magnitude and angle of layer-to-layer changes" within each reasoning segment and averaging across segments (Section 4.1). The results (Figure 3) show that these cross-layer signals are "less reliable and vary substantially across models and reasoning domains," with ROC-AUCs of 0.58 for magnitude change and 0.67 for angle change—higher than output-distribution measures but substantially below the LT signals (0.71–0.74). The paper's key insight is that examining changes across layers within a single segment (spatial) misses the distinctive dynamics of reasoning, which unfold across tokens over time (temporal). Reasoning is inherently a sequential process—the model builds understanding step by step. Looking at how representations change along the token dimension (as the LT signals do) captures information about this sequential process that is invisible when looking at how representations change along the layer dimension at a fixed position.

Probing approaches require training. Concurrent work by Zhang et al. (2025) trains model-specific probes over hidden representations to detect when intermediate answers are likely correct. The paper positions itself as complementary but distinct: "Our approach shares the objective but remains training-free and can be applied to diverse models and datasets with minimal setup" (Section 2). The practical implication is significant: if you need to train a separate classifier for each model and each task, deployment becomes complex and the classifier may not transfer. The LT signals, by contrast, are computed directly from hidden states with no training, no external annotations, and no model-specific calibration beyond a threshold selection step that the paper shows can be done with a small calibration set (Section 5.2 and Appendix D).

How This Paper Positions Itself

The paper's intellectual contribution is not a new training procedure, a new model architecture, or a new decoding algorithm. Instead, it is the discovery and systematic validation that the temporal evolution of hidden states during reasoning carries strong and robust predictive signals about solution correctness, and that these signals can be operationalized into practical inference-time policies that improve both efficiency and accuracy.

The key conceptual move is shifting from a spatial perspective (how representations vary across layers at a fixed position) to a temporal perspective (how representations vary across token positions, averaged across layers). This is not merely a different measurement—it reflects a different hypothesis about where reasoning quality is encoded. The spatial perspective implicitly assumes that reasoning quality manifests as some kind of layer-level computation pattern (e.g., deeper layers being more or less active for correct reasoning). The temporal perspective assumes that reasoning quality manifests as a trajectory through representation space over time—the path the model's internal state takes as it processes the reasoning tokens.

This hypothesis is motivated by a growing body of representational analysis work that has found temporal dynamics to be informative about various model properties:

  • Safety-related behavior can be detected through activation patterns (Turner et al., 2023; Zou et al., 2023).
  • Learning dynamics such as in-context learning and induction heads can be understood by tracking representational changes over sequences (Olsson et al., 2022).
  • Natural language processing in LLMs involves "straightening neural sentence trajectories to construct a predictive representation" (Hosseini & Fedorenko, 2023)—the model's internal trajectory through representational space becomes more linear and predictive as it processes a sentence.
  • Factual reliability correlates with representational properties (Meng et al., 2022; Yuksekgonul et al., 2024).

The paper extends this line of thinking specifically to reasoning traces in reasoning-enabled models, which have distinctive characteristics that make temporal analysis particularly promising: reasoning traces are long (thousands of tokens), they exhibit a structured progression from problem understanding to step-by-step deduction to final answer, and they are generated by models that have been explicitly trained to use this intermediate reasoning to improve final-answer accuracy.

The paper also positions itself within the broader conversation about inference-time efficiency. As models get larger and reasoning traces get longer, the computational cost of generating multiple samples for majority voting grows proportionally. The authors cite a growing body of work attempting to address this: training models to produce more concise reasoning (Kang et al., 2025a; Shrivastava et al., 2025), dynamically halting trace generation once the model is confident (Yang et al., 2025b; Zhang et al., 2025), pruning reasoning paths with trained classifiers (Manvi et al., 2024; Li et al., 2024). The LT approach is positioned as complementary to these efforts—it doesn't require retraining the model to produce shorter traces (unlike Kang et al. or Shrivastava et al.), it doesn't require modifying the generation process with early-exit mechanisms (unlike Yang et al. or Zhang et al.), and it doesn't require training separate classifiers (unlike Manvi et al. or Li et al.). It is a lightweight, training-free signal that can be layered on top of existing models and generation strategies.

Finally, the paper frames its contribution at two levels: practical (efficiency and accuracy improvements in multi-sample inference) and scientific/interpretability (revealing the structure of reasoning in latent space). The practical contribution is the demonstration that these signals work across three different model families and three distinct reasoning domains, with consistent patterns. The scientific contribution is the characterization of what distinguishes successful from unsuccessful reasoning trajectories in representational space: successful traces involve larger overall representational shifts (the model's internal state substantially changes from start to finish), less accumulated wandering (the total path length through representational space is shorter), and intermediate updates that are more aligned with the final direction of travel (each reasoning step advances toward where the model ends up).

The paper explicitly aims to bridge these two levels: the same signals that reveal interpretable properties of reasoning dynamics can be directly operationalized into practical inference-time decision rules. This is what distinguishes the work from purely analytical representational studies (which often stop at correlation analysis) and from purely engineering-driven efficiency methods (which often treat the model as a black box).

3. Technical Approach

3.1 Reader orientation

This paper develops a set of training-free, inference-time metrics computed directly from a model's hidden states that quantify how the model's internal representations evolve during reasoning, and then uses these metrics as signals for deciding which generated reasoning traces are likely correct—enabling early stopping during multi-sample generation and early pruning of unpromising traces during parallel generation. The system solves the problem of inference-time inefficiency in reasoning models by providing a computationally cheap way to predict trace quality without running separate verifier models, without training task-specific classifiers, and without relying on unreliable surface-form heuristics; the core idea is that the trajectory a model's hidden state takes through representation space—its direction, distance, and accumulated path length—carries robust information about whether the reasoning is likely to converge on a correct answer.

3.2 Big-picture architecture (diagram in words)

The system has three major components that operate in sequence during inference:

  1. Hidden state extraction — During generation of each reasoning trace, the model's hidden states are collected at every transformer layer for every reasoning-token position. These raw (layer, position) activations form a 2D grid that encodes the model's complete internal computation. The reasoning trace is delimited by special tokens ({trace start} and {trace end}), isolating it from the prompt and answer tokens.

  2. Temporal segmentation and trajectory construction — The reasoning trace (which can span thousands of tokens) is divided into fixed-size, non-overlapping blocks of k = 500 contiguous tokens called reasoning segments. Within each segment and each layer, token-level hidden states are averaged to produce a single segment-level representation. This produces, for each layer, a sequence of N segment states {˜h(1), ˜h(2), ..., ˜h(N)} that form a coarse-grained trajectory through representational space—a path that captures how the model's understanding evolves during reasoning while smoothing out token-level noise.

  3. Signal computation and decision logic — From each layer's trajectory, three scalar quantities are computed: Net Change (the distance between the first and last segment), Cumulative Change (the total path length traveled), and Aligned Change (the cosine similarity between each local step and the overall direction). These are averaged across layers to produce a single score per trace. At decision time, these scores are compared against calibrated thresholds to either (a) accept a solution early in sequential sampling, or (b) select a promising trace to continue from among parallel candidates.

Information flows as follows: a prompt enters the model → the model autoregressively generates reasoning tokens and then answer tokens → hidden states are collected for all reasoning-token positions across all layers → reasoning tokens are partitioned into 500-token segments → per-layer per-segment averages are computed → three trajectory signals are derived from the segment sequences → signals are averaged across layers and compared to thresholds → a decision is made (accept, continue, or select).

3.3 Roadmap for the deep dive

  • First, the mathematical primitives: how the paper defines the reasoning trace, extracts hidden states, and constructs segment-level representations. This establishes the notation and the raw material from which all signals are derived.
  • Second, the three Latent-Trajectory signals themselves—Net Change, Cumulative Change, and Aligned Change—with exact definitions, what each measures, and why the combination of three complementary signals matters.
  • Third, the cross-layer baseline signals (Layer Magnitude and Layer Angle), which serve as the primary internal comparison point and help clarify what isn't being captured by the LT approach.
  • Fourth, the output-distribution baselines (Logit Margin, Entropy, Perplexity), which represent the standard lightweight confidence estimation methods the paper argues against.
  • Fifth, the two inference-time decision policies: threshold-based early stopping for sequential multi-sample generation, and trace pruning for parallel generation with a lightweight classifier.
  • Sixth, the calibration procedure for threshold selection, which is critical to making the training-free signals work in practice without overfitting to the test distribution.

3.4 Detailed, sentence-based technical breakdown

This is primarily a representational analysis paper with practical inference-time applications. The core idea is that the temporal trajectory of a model's hidden states during reasoning encodes information about solution correctness that is more robust than spatial (cross-layer) patterns or surface-form heuristics, and that this information can be operationalized into lightweight decision policies without any additional training.

Formalizing the Reasoning Trace

The paper begins by establishing a precise formal decomposition of what a reasoning model produces. Given a problem, the model generates a sequence of tokens that the authors partition into three distinct regions:

q1,…,qi{trace start}t1,…,tr{trace end}a1,…,ajq_1, \ldots, q_i \quad \texttt{\{trace start\}} \quad t_1, \ldots, t_r \quad \texttt{\{trace end\}} \quad a_1, \ldots, a_j

where $q_1, \ldots, q_i$ are the user query (problem) tokens, $t_1, \ldots, t_r$ are the intermediate reasoning trace tokens, and $a_1, \ldots, a_j$ are the final answer tokens. The special delimiters {trace start} and {trace end} are model-specific tokens that explicitly mark the boundaries of the reasoning region—they are part of the output sequence and are recognized by the model's tokenizer.

Why this decomposition matters. The reasoning region $t_1$ through $t_r$ is the focus of all subsequent analysis. The authors explicitly exclude the question tokens and the answer tokens from the trajectory computation: question tokens represent the problem the model is given (not the model's own reasoning), and answer tokens are the output of reasoning rather than the process itself. The reasoning tokens are where the model's internal computation unfolds step by step, and it is the dynamics of this unfolding—captured through hidden states—that the LT signals aim to characterize. This is a deliberate design choice that reflects the hypothesis that reasoning quality manifests in how the model processes intermediate steps, not in the final answer token probabilities (which the output-distribution baselines measure) or in the initial encoding of the problem.

For each token position $r$ within the reasoning trace (where $r \in \{1, \ldots, R\}$ and $R$ is the total number of reasoning tokens), the model produces a hidden state at every transformer layer. At layer $l \in \{1, \ldots, L\}$, the hidden state for reasoning-token position $r$ is denoted by:

hl(r)∈Rdh^{(r)}_l \in \mathbb{R}^d

where $d$ is the hidden dimension of the model (the size of the residual stream at each layer). This produces a 2D array indexed by layer ($l$) and token position ($r$), encoding the model's complete internal state at every step of the reasoning process. All three models studied (DeepSeek-R1-Distill-Qwen-14B, Phi-4-Reasoning-Plus, Qwen3-14B) have the same hidden dimension $d$ architecture, making the approach directly comparable across models.

Practical note on hidden state access. The LT signals are computed from intermediate representations that are naturally available during model generation—no additional forward passes, no separate model calls, and no modification to the generation process are required. This is what makes the approach "training-free" and lightweight: the hidden states are already being computed as part of the autoregressive generation; the LT computation is simply reading and aggregating values that exist in memory. This contrasts with verifier-based approaches, which require a separate model forward pass (doubling the computation), and with probing approaches (Zhang et al., 2025), which require training a classifier on these hidden states.

Temporal Segmentation: From Token-Level to Segment-Level Representations

Raw token-level hidden states $h^{(r)}_l$ are high-frequency and noisy—adjacent tokens may have highly similar or highly dissimilar representations depending on the local linguistic context, which can obscure the large-scale trajectory of the model's reasoning. To extract a cleaner signal, the authors apply temporal coarse-graining by partitioning the reasoning trace into non-overlapping blocks of fixed size and averaging within each block.

Why segmentation is necessary. Reasoning traces in the studied models routinely span 5,000 to over 30,000 tokens. Computing trajectory-level metrics directly from per-token hidden states would be computationally heavy (requiring $R \times L$ vector operations) and would be dominated by token-level fluctuations rather than the macro-scale trajectory the paper aims to capture. Segmentation reduces dimensionality by approximately a factor of $k$ (from $R$ token positions to $N \approx R/k$ segments) and smooths out local noise, making the large-scale representational movement more visible. The paper explicitly notes that "this temporal coarse-graining smooths local fluctuations in token-level dynamics while preserving the large-scale evolution of the model's latent space over the trace" (Section 3.1).

Segment size choice. The token-level reasoning trace $t_1, \ldots, t_r$ is divided into non-overlapping contiguous blocks of $k$ tokens, with the paper setting:

k=500k = 500

This specific value is motivated by the average reasoning trace lengths across the studied datasets (Appendix F): "The dataset with the shortest responses still had an average of 5,000 tokens per answer. Setting the window to 500 tokens therefore ensures that, on average, we obtain at least 10 measurement points per answer." With 10 segments, the trajectory has enough resolution to capture the evolution of representations without being so fine-grained that noise dominates. For models that produce longer traces (e.g., 30,000 tokens), the number of segments scales proportionally (roughly 60 segments), providing even richer trajectory information.

An alternative segmentation strategy based on natural delimiters (newline tokens \n) was considered and rejected because "segment sizes varied substantially across models under this approach, making it less comparable across architectures" (Appendix F). Different models produce reasoning traces with different paragraph structures; a delimiter-based segmentation would produce different numbers of segments for the same problem across models, making cross-model comparisons of trajectory signals difficult. The fixed-k approach ensures uniform treatment regardless of formatting style. The paper also experiments with $k = 300$ and reports "equivalent" results (Appendix F, Figure 14), demonstrating that the approach is robust to the exact segment size within a reasonable range.

Segment-level representation computation. For each transformer layer $l \in \{1, \ldots, L\}$ and each segment index $n \in \{1, \ldots, N\}$ (where $N$ is the total number of segments), the segment-level hidden state is computed as the arithmetic mean of all token hidden states within that segment:

h~l(n)=1k∑r∈segmentnhl(r)\tilde{h}^{(n)}_l = \frac{1}{k} \sum_{r \in \text{segment}_n} h^{(r)}_l

where the sum runs over all token positions $r$ that fall within the $n$-th segment of $k$ tokens. Each $\tilde{h}^{(n)}_l$ is a vector in $\mathbb{R}^d$ that represents the model's average internal state at layer $l$ while processing the $n$-th chunk of reasoning.

What this averaging accomplishes. The segment-level representation $\tilde{h}^{(n)}_l$ can be understood as the centroid of the model's hidden states during that portion of the reasoning trace. Averaging across tokens within a segment collapses token-level variation (e.g., fluctuations due to specific word choices, punctuation, grammatical structure) while preserving the broader semantic and computational content of the reasoning step. Intuitively, if the model is performing a calculation in segment 3 and interpreting results in segment 7, the averaged representations for those segments should reflect these different computational modes, even though individual tokens within each segment may vary.

The sequence $\{\tilde{h}^{(1)}_l, \tilde{h}^{(2)}_l, \ldots, \tilde{h}^{(N)}_l\}$ at layer $l$ constitutes a trajectory—an ordered sequence of points in $\mathbb{R}^d$ that traces how the model's representation at that layer evolves from the beginning to the end of the reasoning process. The paper's key analytical move is to study the geometric properties of this trajectory (distance, path length, directional consistency) and relate them to answer correctness.

The Three Latent-Trajectory Signals: Primitives, Computation, and Interpretation

All three LT signals are derived from two primitive vectors computed from the segment-level representations:

Primitive 1: The reasoning drift vector. The drift vector captures the net displacement of the model's internal state from the first reasoning segment to the last:

ul=h~l(N)−h~l(1)u_l = \tilde{h}^{(N)}_l - \tilde{h}^{(1)}_l

where $\tilde{h}^{(N)}_l$ are the final reasoning segment's averaged hidden states and $\tilde{h}^{(1)}_l$ are the first reasoning segment's averaged hidden states, both at layer $l$. The drift vector $u_l \in \mathbb{R}^d$ encodes both a direction (where in representation space does the final state lie relative to the initial state?) and a magnitude (how far did it travel?). If reasoning substantially transforms the model's understanding, $u_l$ should have large magnitude; if reasoning is shallow or circular, it should be small.

Primitive 2: The update vectors. For each consecutive pair of segments, the incremental change in representation is:

vl(n)=h~l(n)−h~l(n−1),n=2,…,Nv^{(n)}_l = \tilde{h}^{(n)}_l - \tilde{h}^{(n-1)}_l, \quad n = 2, \ldots, N

where $v^{(n)}_l \in \mathbb{R}^d$ is the step from segment $n-1$ to segment $n$ at layer $l$. The collection of update vectors $\{v^{(2)}_l, v^{(3)}_l, \ldots, v^{(N)}_l\}$ decomposes the overall drift into its constituent steps: by definition, $u_l = \sum_{n=2}^N v^{(n)}_l$. The update vectors reveal the micro-structure of the trajectory—whether the model moves in a consistent direction, whether it backtracks or loops, and whether individual steps are large or small.

Why these two primitives? Together, $u_l$ and $v^{(n)}_l$ capture complementary information. The drift vector $u_l$ tells you where you ended up relative to where you started—it summarizes the net effect of the entire reasoning process. The update vectors $v^{(n)}_l$ tell you the path you took to get there—whether it was direct or meandering. A trajectory could have the same drift vector $u_l$ but very different update sequences: one might involve large, decisive steps directly toward the final state, while another might involve circuitous wandering with back-and-forth movement. The three LT signals are designed to quantify these distinctions.

All three signals are computed per layer and then averaged across layers to yield a single scalar score per reasoning trace:

SIGNAL=1L∑l=1LSIGNALl\text{SIGNAL} = \frac{1}{L} \sum_{l=1}^L \text{SIGNAL}_l

where $\text{SIGNAL}_l$ is the layer-specific computation and $L$ is the total number of transformer layers. Averaging across layers serves two purposes: it reduces dimensionality (from $L$ values to 1) for practical decision-making, and it captures the aggregate behavior of the model rather than layer-specific idiosyncrasies. The paper does report layer-wise values in Appendix B (Figures 10–12), which show that the signals are generally consistent across layers but may exhibit stronger effects in middle-to-late layers.

Latent-Trajectory Signal 1: Net Change

Net Change measures the magnitude of the overall representational displacement from the first reasoning segment to the last, normalized by the number of segments to control for trace length, and then averaged across layers.

Definition. For each layer $l$, the per-layer Net Change is the Euclidean norm of the drift vector divided by the number of segments:

Net Changel=∥ul∥2N\text{Net Change}_l = \frac{\|u_l\|_2}{N}

Aggregating across layers:

NETCHANGE=1L∑l=1L∥ul∥2N\text{NETCHANGE} = \frac{1}{L} \sum_{l=1}^L \frac{\|u_l\|_2}{N}

where $\|u_l\|_2 = \sqrt{\sum_{i=1}^d (u_l^{(i)})^2}$ is the Euclidean ($L^2$) norm of the drift vector, $N$ is the number of reasoning segments, and $L$ is the number of layers.

What this computes in operational terms. Net Change answers the question: on average, how much does the model's internal representation shift between the start and end of reasoning, per unit of reasoning length? A large Net Change means the final hidden state is substantially different from the initial state—the model has undergone a significant representational transformation during reasoning. A small Net Change means the final state is close to the initial state—reasoning didn't substantially alter the model's internal configuration. The normalization by $N$ adjusts for trace length: a longer trace has more segments but should not automatically get a larger score simply because it's longer; the per-segment normalization makes traces of different lengths comparable.

Why this form and normalization. Normalizing by $N$ (number of segments) rather than by total token count $R$ is intentional. The drift vector $u_l$ spans the entire trace regardless of length—if reasoning leads to a big representational shift, that shift should show up whether the trace has 10 segments or 50. Dividing by $N$ gives a per-segment average displacement, which penalizes traces that are long but don't produce proportionally larger shifts. An alternative would be to use the unnormalized $\|u_l\|_2$, but this would bias the metric toward longer traces (more opportunity for displacement) even when the per-unit reasoning impact is small. Another alternative would be to use cosine distance or some other angular metric, but Euclidean distance captures both direction and magnitude—the paper hypothesizes that both matter.

Interpretation hypothesis. The paper finds (Section 5.1) that Net Change is positively correlated with accuracy (Spearman's $r = 0.28$ averaged across models and datasets). The interpretation: correct reasoning involves genuine representational progress—the model starts with an initial encoding of the problem and, through the reasoning steps, transforms its internal state to a substantially different configuration that encodes the solved state. Incorrect reasoning may involve surface-level token generation without deep representational change, producing a smaller drift. The analogy is to physical problem-solving: if you're truly working through a problem, your mental state at the end should be significantly different from your state at the beginning; if you're just going through the motions without real engagement, your mental state may remain largely unchanged.

Practical implementation note. The $\|u_l\|_2$ computation is a standard Euclidean norm on $d$-dimensional vectors. For the 14B-parameter models studied, $d$ is typically 4096 or 5120 depending on the architecture, making this a cheap computation (a sum of squares over $d$ elements, done once per layer per trace). The entire Net Change computation for a single trace requires $L$ norm computations (one per layer) plus averaging, which is negligible compared to the cost of generating the reasoning tokens themselves.

Latent-Trajectory Signal 2: Cumulative Change

Cumulative Change measures the total path length of the trajectory—the sum of all incremental step magnitudes—aggregated across segments and averaged across layers.

Definition. For each layer $l$, the per-layer Cumulative Change is the sum of the Euclidean norms of all update vectors:

Cumulative Changel=∑n=2N∥vl(n)∥2\text{Cumulative Change}_l = \sum_{n=2}^N \|v^{(n)}_l\|_2

Aggregating across layers:

CUMULATIVECHANGE=1L∑l=1L∑n=2N∥vl(n)∥2\text{CUMULATIVECHANGE} = \frac{1}{L} \sum_{l=1}^L \sum_{n=2}^N \|v^{(n)}_l\|_2

where $v^{(n)}_l = \tilde{h}^{(n)}_l - \tilde{h}^{(n-1)}_l$ is the update vector between consecutive segments, $\|\cdot\|_2$ is the Euclidean norm, $N$ is the number of segments, and $L$ is the number of layers.

What this computes in operational terms. Cumulative Change answers the question: what is the total distance traveled through representation space during the entire reasoning process, summed over all intermediate steps? Unlike Net Change, which only looks at endpoints, Cumulative Change accounts for every step along the way. If the trajectory moves in a straight line from start to finish, the Cumulative Change will approximately equal the Net Change (multiplied by $N$). If the trajectory wanders, loops, backtracks, or oscillates, the Cumulative Change will be substantially larger than the Net Change—the model traveled a much longer path to reach the same endpoint.

Relationship to Net Change: the "excess path" interpretation. The difference between Cumulative Change and Net Change captures how much "wasted" or "excess" representational movement occurred. A trajectory with a large Cumulative Change relative to its Net Change indicates that the model's representations underwent many intermediate shifts, potentially reflecting unstable reasoning, repeated reconsideration of the same ideas, or exploration of dead ends. A trajectory with Cumulative Change close to its Net Change indicates efficient, direct representational progression.

Why this form. Summing norms (rather than, say, summing vectors and then taking the norm) captures the total distance traveled, which is always at least as large as the straight-line distance between endpoints (by the triangle inequality). This is the standard definition of path length in Euclidean geometry. An alternative would be to measure the variance of the update vectors or some other dispersion statistic, but the sum of norms gives a physically interpretable quantity: the total Euclidean distance traveled in representational space. The lack of normalization by $N$ is deliberate—unlike Net Change, Cumulative Change is supposed to grow with trace length because longer traces that genuinely process more reasoning steps should accumulate more total movement.

Interpretation hypothesis and empirical finding. The paper finds (Section 5.1) that Cumulative Change is negatively correlated with accuracy (Spearman's $r = -0.38$). This is one of the paper's most striking results: successful reasoning traces tend to involve less total representational movement than unsuccessful ones. The authors interpret this as evidence that "traces that traverse greater total distance in representation space tend to be less likely to produce correct answers" and connect it to prior behavioral observations that "long but highly varying reasoning traces are associated with lower accuracy" (Section 5.1, citing Balachandran et al., 2025; Shojaee et al., 2025). In mechanical terms: correct reasoning involves focused, directed computation that efficiently transforms the initial problem representation into the solution representation, without excessive wandering. Incorrect reasoning involves unstable representational dynamics—the model shifts its internal state frequently and substantially, possibly because it's trying different approaches, reconsidering, or generating incoherent intermediate steps that don't build on each other.

Practical sign convention. Because Cumulative Change is negatively correlated with accuracy, the paper "sign-reverses" it in figures (Figure 3 caption: "For comparability, Cumulative Change was sign-reversed") and in the combined score, so that higher values consistently indicate better expected accuracy across all three LT signals. In the threshold-based decision procedure (Appendix D), the comparison is applied as "metric $\leq t$" rather than the usual "$\geq t$" for Cumulative Change, to account for the reversed relationship.

Latent-Trajectory Signal 3: Aligned Change

Aligned Change measures the directional consistency of the trajectory—the extent to which each intermediate update vector points in the same direction as the overall drift vector, averaged across segments and layers.

Definition. For each layer $l$ and each segment $n$ (starting from $n=2$), the alignment between the update vector $v^{(n)}_l$ and the drift vector $u_l$ is measured by the cosine similarity:

Alignmentl(n)=⟨vl(n),ul⟩∥vl(n)∥2 ∥ul∥2\text{Alignment}^{(n)}_l = \frac{\langle v^{(n)}_l, u_l \rangle}{\|v^{(n)}_l\|_2 \,\|u_l\|_2}

Per-layer Aligned Change is the average across segments (excluding the first segment, which has no predecessor):

Aligned Changel=1N−1∑n=2N⟨vl(n),ul⟩∥vl(n)∥2 ∥ul∥2\text{Aligned Change}_l = \frac{1}{N-1} \sum_{n=2}^N \frac{\langle v^{(n)}_l, u_l \rangle}{\|v^{(n)}_l\|_2 \,\|u_l\|_2}

Aggregating across layers:

ALIGNEDCHANGE=1L∑l=1L1N−1∑n=2N⟨vl(n),ul⟩∥vl(n)∥2 ∥ul∥2\text{ALIGNEDCHANGE} = \frac{1}{L} \sum_{l=1}^L \frac{1}{N-1} \sum_{n=2}^N \frac{\langle v^{(n)}_l, u_l \rangle}{\|v^{(n)}_l\|_2 \,\|u_l\|_2}

where $\langle \cdot, \cdot \rangle$ denotes the Euclidean dot product, $\|\cdot\|_2$ is the Euclidean norm, $v^{(n)}_l$ is the update vector for segment $n$, and $u_l$ is the drift vector for layer $l$.

What this computes in operational terms. Aligned Change answers the question: do the individual reasoning steps tend to move in the same general direction as the overall progression of the reasoning process? Cosine similarity between two vectors ranges from $-1$ (exactly opposite directions) through $0$ (orthogonal, no directional relationship) to $+1$ (exactly the same direction). An Aligned Change close to $+1$ means that every intermediate reasoning step advanced the representation in roughly the same direction as the overall drift—the model was consistently making progress toward its final state. A value close to $0$ means the steps were orthogonal to the overall direction—the model was moving, but not in a way that contributed to the net displacement. A negative value means steps tended to move away from the final state, requiring subsequent steps to reverse course.

Why cosine similarity rather than, say, Euclidean distance to the final state. Cosine similarity specifically measures directional agreement, independent of magnitude. A small update vector that points in exactly the right direction gets a cosine similarity of $+1$, same as a large update vector pointing in the right direction. This isolates the directional quality of the trajectory from the magnitude quality (which is already captured by Net Change and Cumulative Change). If the model takes small, careful steps that all advance toward the solution, Aligned Change will be high. If the model takes large steps that go in various directions (some toward the solution, some away, some orthogonal), Aligned Change will be low or even negative.

Relationship to Cumulative Change. A trajectory could have low Cumulative Change but low Aligned Change if the update vectors are small but point in inconsistent directions. Conversely, a trajectory could have high Cumulative Change but high Aligned Change if the update vectors are large but all point in approximately the same direction. These two signals together distinguish between "efficient, directed reasoning" (low Cumulative Change, high Aligned Change) and "meandering but ultimately directed reasoning" (high Cumulative Change, high Aligned Change) and "confused, undirected reasoning" (high Cumulative Change, low Aligned Change).

Interpretation hypothesis and empirical finding. The paper finds (Section 5.1) that Aligned Change is positively correlated with accuracy (Spearman's $r = 0.32$). This is the strongest correlation among the three LT signals, suggesting that directional consistency is particularly diagnostic. The interpretation: correct reasoning involves intermediate representational updates that consistently advance toward the final solved state—each reasoning step builds on previous steps and brings the model closer to the correct answer configuration. Incorrect reasoning involves updates that are inconsistent with the overall trajectory, possibly because the model is trying incompatible approaches, correcting earlier mistakes by moving in the opposite direction, or generating steps that are unrelated to the final answer it eventually produces.

Edge case: zero drift vector. If the drift vector $u_l$ has zero norm (the first and last segments have identical representations), the cosine similarity is undefined (division by zero). In practice, this almost never occurs because even incorrect reasoning produces some representational change. The paper does not explicitly discuss handling this edge case, but in threshold-based decision-making, such traces would have undefined Aligned Change and would presumably be routed to the fallback majority-vote path.

Why Three Complementary Signals?

Each LT signal captures a distinct geometric property of the trajectory that is not fully redundant with the others:

  • Net Change measures how far the model went (magnitude of displacement).
  • Cumulative Change measures how much the model moved (total path length).
  • Aligned Change measures how directly the model moved (directional consistency).

A concrete example illustrates their complementarity. Consider three hypothetical trajectories, all starting at point $A$ and ending at point $B$:

  1. Direct trajectory: moves in a straight line from $A$ to $B$. This yields high Net Change, low Cumulative Change (close to Net Change), and high Aligned Change (cosine similarity near $+1$ for all steps). This is the signature of efficient, focused reasoning.

  2. Wandering but directed trajectory: takes a circuitous path that eventually reaches $B$. This yields the same Net Change as trajectory 1, but higher Cumulative Change and lower Aligned Change (some steps move away from $B$ before later steps correct). This might represent reasoning that explores alternatives before converging.

  3. Oscillating trajectory: moves back and forth near $A$ without ever reaching far. This yields low Net Change, potentially high Cumulative Change (lots of back-and-forth movement), and low Aligned Change (steps go in conflicting directions). This might represent confused or stuck reasoning.

The three signals together can distinguish these cases. A single signal (e.g., Net Change alone) would conflate trajectories 1 and 2. Cumulative Change alone might conflate trajectories 2 and 3 if the path lengths happen to be similar. The combination provides a richer characterization.

The paper's empirical results support this complementarity. In the Combined LT score (Section 5.2 and Appendix E), all three signals receive non-trivial weights on every model-dataset combination (weights range from roughly 0.19 to 0.45 across the three signals, Table 5), indicating that each contributes independent predictive power. No single signal dominates across all settings.

Layer averaging choice. The paper averages each signal across all layers rather than selecting a specific layer or using a weighted combination. This is a deliberate simplicity choice that avoids the need for per-model or per-dataset layer selection. The layer-wise plots in Appendix B (Figures 10–12) show that the signals' relationships with accuracy are generally consistent across layers, though middle-to-late layers often show larger effect sizes. Averaging across all layers provides a robust aggregate that doesn't require tuning. A more sophisticated approach might learn layer weights, but the paper's goal is a training-free method that works out of the box, and the simple average proves sufficient.

What these signals are NOT doing. It is important to clarify what the LT signals do not capture. They do not evaluate the logical content of the reasoning (whether the steps form a valid proof). They do not check factual accuracy of intermediate claims. They do not compare the reasoning trace to any ground-truth solution. They purely measure geometric properties of the model's own internal trajectory. The fact that these geometric properties correlate with correctness is not obvious—it suggests that the model's internal dynamics reflect reasoning quality even when the surface text might not, and that successful reasoning has a characteristic "signature" in representational space that generalizes across domains.

Cross-Layer Baseline Signals

To establish that the temporal (across-tokens) perspective is specifically valuable—not just that hidden states in general carry information—the paper implements two cross-layer baselines adapted from Wang et al. (2024). These signals measure representational change across layers within a fixed segment, capturing a spatial rather than temporal perspective.

Layer Magnitude. For each reasoning segment $n$, the per-segment Layer Magnitude measures the cumulative magnitude of representational changes between consecutive layers, normalized by the total change from first to last layer:

LAYERMAG(n)=1L∑l=2L∥h~n(l)−h~n(l−1)∥2∥h~n(L)−h~n(1)∥2\text{LAYERMAG}(n) = \frac{1}{L} \sum_{l=2}^{L} \frac{\|\tilde{h}^{(l)}_n - \tilde{h}^{(l-1)}_n\|_2}{\|\tilde{h}^{(L)}_n - \tilde{h}^{(1)}_n\|_2}

where $L$ is the number of layers and the subscript $n$ on $\tilde{h}$ emphasizes that all computations are within a single segment. The result is then averaged across segments to produce a single score per trace.

What it measures. Layer Magnitude quantifies, for a fixed segment, how much the representation changes from one layer to the next, normalized by the total change from the first to the last layer. If the representation changes gradually across layers, each per-step ratio will be small; if it changes abruptly at specific layers, those steps will have large ratios. The normalization by the total change $\|\tilde{h}^{(L)}_n - \tilde{h}^{(1)}_n\|_2$ makes the metric invariant to the overall scale of representational change (two models with different embedding magnitudes can be compared).

Layer Angle. Similarly, for each segment $n$, the per-segment Layer Angle measures the angular change between consecutive layers:

LAYERANG(n)=1L∑l=2Larccos⁡(cos⁡(h~n(l),h~n(l−1)))arccos⁡(cos⁡(h~n(L),h~n(1)))\text{LAYERANG}(n) = \frac{1}{L} \sum_{l=2}^{L} \frac{\arccos(\cos(\tilde{h}^{(l)}_n, \tilde{h}^{(l-1)}_n))}{\arccos(\cos(\tilde{h}^{(L)}_n, \tilde{h}^{(1)}_n))}

where $\cos(a, b) = \langle a, b \rangle / (\|a\|_2 \|b\|_2)$ is the cosine similarity, and $\arccos$ converts this to an angle in radians (0 for identical direction, $\pi$ for opposite direction). This is then averaged across segments.

What it measures. Layer Angle captures whether the representation rotates significantly as it passes through the transformer layers, again normalized by the total rotation. A value near 1 indicates that layers contribute proportionally to the total rotation; values much larger than 1 indicate certain layers cause disproportionately large rotations.

Key difference from LT signals. The cross-layer baselines analyze how representations change vertically through the model's depth at a fixed reasoning position. The LT signals analyze how representations change horizontally across reasoning time, averaged over depth. The paper's hypothesis is that the temporal dimension is more informative for reasoning quality because reasoning is inherently a sequential, step-by-step process—the dynamics of how the model's state evolves as it generates reasoning tokens are more diagnostic than how the representation is transformed by different layers at a single moment. The empirical results (Section 5.1, Figure 3) support this: the LT signals achieve mean ROC-AUCs of 0.71–0.74, while the cross-layer signals achieve 0.58–0.67, with substantially higher variance across models and datasets.

Output-Distribution Baselines

The paper also compares against standard confidence estimation methods based on the probability distribution over the final answer token(s). These methods represent the common practice of using "model confidence" as a proxy for correctness.

Elicitation procedure. The authors "elicit the final answer post reasoning trace end using prompts of the form [... {trace end} Final Answer:], and examine the probability distribution over the token that follows" (Section 4.1). This is a crucial detail: the output-distribution metrics are computed on the answer token that comes after the reasoning trace, not on any token within the reasoning trace itself. The model is explicitly prompted for the final answer (with "Final Answer:" as a cue), and the probability distribution over the very next token is analyzed.

Logit Margin. The difference between the logit values of the top two most probable answer tokens:

Logit Margin=log⁡p(top-1 token)−log⁡p(top-2 token)\text{Logit Margin} = \log p(\text{top-1 token}) - \log p(\text{top-2 token})

where $p(\cdot)$ is the model's predicted probability from the softmax over the vocabulary. A large logit margin means the model is confident in a single answer (the top token is much more probable than the runner-up); a small logit margin means the model is uncertain between multiple possible answers.

Why this might work. If the model has genuinely converged on the correct answer, it should assign high probability to that answer token and low probability to alternatives, producing a large logit margin. If the model is guessing or unsure, the probability mass should be more evenly distributed, producing a small margin.

Entropy. The entropy of the probability distribution over the possible answer tokens:

H=−∑ipilog⁡piH = -\sum_{i} p_i \log p_i

where $p_i$ is the model's predicted probability for the $i$-th token in the vocabulary, and the sum runs over all vocabulary tokens. Lower entropy corresponds to higher confidence (probability mass concentrated on a few tokens); higher entropy indicates uncertainty (probability mass spread across many tokens). Unlike logit margin, entropy considers the entire distribution, not just the top two tokens.

Perplexity. The inverse probability of the model's top-ranked token:

Perplexity=1p(top-1 token)\text{Perplexity} = \frac{1}{p(\text{top-1 token})}

Perplexity is exactly 1 if the model assigns probability 1.0 to a single token (complete certainty) and grows larger as confidence decreases. It is equivalent to the exponential of the cross-entropy loss for the top token.

Why these baselines are important. These output-distribution metrics are widely used in practice because they require no additional computation beyond what the model already produces during generation—the logits and probabilities are natural byproducts of autoregressive decoding. If they worked well, they would be the obvious lightweight solution. The paper's finding (Section 5.1) that they perform "close to or below chance level" (ROC-AUCs of 0.44–0.59) on reasoning models is a key negative result that motivates the LT approach. The authors hypothesize, implicitly, that reasoning models decouple the probability distribution at the answer token from the quality of the reasoning process—the model may have been trained (via RL or fine-tuning) to produce the answer after completing reasoning regardless of whether that reasoning was successful, so the answer-token probabilities don't reflect the model's internal certainty in the same way they would for a standard instruction-tuned model that answers directly.

Inference-Time Decision Policy 1: Threshold-Based Early Stopping for Sequential Multi-Sample Generation

The paper's primary practical application of LT signals is a sequential decision procedure for multi-sample inference (Section 5.2). Rather than always generating a fixed number of samples (e.g., 5) and then applying majority voting, the procedure uses LT signals to decide online whether the current sample is likely correct and can be accepted immediately.

Procedure (Figure 5). For each problem:

  1. Generate the first reasoning trace and compute its LT score (Net Change, Cumulative Change, Aligned Change, or a Combined LT score).
  2. Compare the LT score against a pre-calibrated decision threshold $\tau$:
    • If the score exceeds $\tau$ (meaning the signal indicates high confidence in correctness), accept this trace's answer immediately and stop generating additional samples.
    • If the score does not exceed $\tau$, generate the next sample and repeat.
  3. If after generating $k = 5$ samples no individual trace has exceeded the threshold, fall back to majority voting over all $k$ collected samples.

Why this sequential structure? The procedure exploits the LT signal's ability to identify correct traces individually, even when they are in the minority. If the first generated trace happens to be correct and the LT signal correctly identifies it as such, the procedure stops after one sample—saving the compute of generating four additional traces. If the first trace is incorrect but the second is correct and recognized, it stops after two. Only when no trace crosses the threshold (either because all traces are incorrect, or because the signal fails to recognize the correct ones) does it fall back to the robust but expensive majority-vote baseline.

Threshold selection via cross-validation (Appendix D). The thresholds $\tau$ are not chosen arbitrarily—they are calibrated using a three-fold shuffled cross-validation procedure on a held-out calibration set (30% of the data in each fold, with the remaining 70% used for evaluation). The calibration procedure:

  1. Focuses on the subset of datapoints where the model's answer was incorrect, to calibrate what LT values look like for wrong answers.
  2. Constructs candidate thresholds from the 20th through 99th percentiles of the metric values among incorrect examples—each candidate threshold corresponds to a fixed false-positive rate (the proportion of incorrect traces that would be above the threshold).
  3. For each candidate threshold, simulates the full decision rule on the calibration data: accepts the first trace exceeding the threshold, uses majority vote for the rest, and computes the overall accuracy.
  4. Ranks thresholds by calibration accuracy and selects the median of the two best-performing thresholds.

Why calibrate on incorrect examples? The threshold is essentially deciding "is this trace's LT score so high that it's unlikely to come from a wrong trace?" By constructing thresholds from the distribution of incorrect traces, the procedure sets a bar that a correct trace must clear—it must look different enough from the incorrect traces to be confidently accepted. This is a form of outlier detection: correct traces should be outliers in the LT signal distribution compared to incorrect traces.

The $k=5$ setting and fallback. The maximum number of samples $k$ is set to 5, matching the MV@5 baseline against which LT is compared. This ensures that in the worst case (no early stopping triggered), the procedure does exactly the same computation as the baseline. In the best case, it does substantially less.

Handling Cumulative Change's negative correlation. Because Cumulative Change is negatively correlated with accuracy, the threshold comparison is reversed for this metric: the rule compares $\text{Cumulative Change} \leq \tau$ rather than the usual $\geq \tau$. The calibration procedure automatically accounts for this direction.

Combined LT score (Appendix E). In addition to using individual signals, the paper constructs a Combined LT score as a weighted sum of the three signals (after sign-reversing Cumulative Change so that higher always equals better):

Combined LT=wnet⋅Net Change−wcum⋅Cumulative Change+walign⋅Aligned Change\text{Combined LT} = w_{\text{net}} \cdot \text{Net Change} - w_{\text{cum}} \cdot \text{Cumulative Change} + w_{\text{align}} \cdot \text{Aligned Change}

The weights are computed from the absolute Pearson correlation of each signal with accuracy on a 10% calibration slice of the data, normalized to sum to 1. For example, on R1-D with GPQA, the weights are: Net Change = 0.35, Cumulative Change = 0.40, Aligned Change = 0.25 (Table 5). These weights reflect the relative predictive power of each signal on that specific model-dataset combination. The full weight table (Appendix E, Table 5) shows that Cumulative Change consistently receives the highest or near-highest weight, aligning with its strongest correlation with accuracy.

What the Combined LT score accomplishes. The weighted combination can be more robust than any single signal because it aggregates information from all three geometric properties. If one signal is noisy for a particular trace (e.g., Net Change is small but Cumulative and Aligned Change strongly indicate correctness), the combination can still make the right call. The paper reports (Table 1) that the Combined LT score is "frequently competitive with the best individual signal and, in most cases, cuts token usage by at least half," making it a practical default choice when the user doesn't want to tune which specific signal to use.

Inference-Time Decision Policy 2: Trace Pruning for Parallel Generation

The paper's second practical application is early path selection during parallel multi-sample generation (Section 5.3). Rather than generating all $k$ traces to completion and then selecting among them, this procedure prunes unpromising traces after only a partial generation, allocating the remaining compute budget to the most promising candidate.

Procedure. Given a problem:

  1. Generate $k = 5$ reasoning traces in parallel, but stop each at exactly $2,000$ tokens (the "2k token" checkpoint).
  2. Compute LT signals (Net Change and Cumulative Change) on these partial traces. At 2k tokens, each trace has generated $2,000 / 500 = 4$ segments, and the "final" segment for Net Change computation is simply the most recent segment.
  3. Feed these partial-trace LT signals into a lightweight random forest classifier that has been trained (offline, once) to predict correctness from partial-trace LT values.
  4. The classifier selects the single trace it deems most likely to be correct. This trace is decoded to completion (all remaining tokens are generated). The other four traces are terminated—their generation is abandoned.
  5. The answer from the selected trace is used as the final answer.

Why a random forest classifier rather than a simple threshold? The parallel selection scenario is more complex than sequential stopping because the classifier must choose one from among multiple candidates, all of which have partial LT signals. A simple threshold can't handle this "choose the best" setting—you need a model that can compare candidates. The paper chooses a random forest because it is lightweight, fast to train, and can capture nonlinear interactions between the LT signals without requiring large amounts of training data. The classifier is trained once per model (or per model-dataset combination) on a calibration set where the ground-truth correctness of each full trace is known.

Why only partial traces? The key efficiency gain comes from not generating the remaining tokens for the four pruned traces. If the full trace would have averaged, say, 8,000 tokens, then each pruned trace saves $8,000 - 2,000 = 6,000$ tokens. For 4 pruned traces, that's 24,000 tokens saved per problem, minus the cost of generating 5 × 2,000 = 10,000 tokens for the checkpoint. The net savings depend on the average trace length, but the paper reports 50–70% token reductions (Table 2).

Choice of 2k token checkpoint. The paper selects 2,000 tokens as the pruning point, which corresponds to 4 segments at $k = 500$. At this point, the LT signals have had enough reasoning tokens to become informative (Figure 6 shows ROC-AUC rising above 0.6 within 4k tokens for most settings) but not so many tokens that the pruning savings are small. The choice represents a tradeoff between signal quality (more tokens = better prediction) and efficiency (more tokens = smaller savings). The paper does not extensively optimize this hyperparameter.

Signal choice for partial traces. Only Net Change and Cumulative Change are used for partial-trace prediction, because Aligned Change is "inconsistent when applied earlier in the trace" (Section 5.3 footnote). The reason: Aligned Change compares each update vector to the final drift vector $u_l = \tilde{h}^{(N)} - \tilde{h}^{(1)}$, but at 2k tokens, the "final" segment is just the most recent partial segment—it doesn't represent the true final state of the completed trace. Computing alignment to a moving target that may change as more tokens are generated would produce unstable values.

Cross-Validation Protocol for Evaluation

To avoid overfitting the decision thresholds to the test data, the paper uses a three-fold shuffled cross-validation procedure (Appendix D). In each fold, 30% of the data is randomly selected as a calibration set (for threshold selection or classifier training), and the remaining 70% is used for evaluation. The same random seed is used across folds for reproducibility. Reported results are averaged across the three folds.

Why this matters. The LT approach involves selecting hyperparameters (thresholds for sequential stopping, classifier for parallel pruning) using the same data that will eventually be evaluated. Without cross-validation, the thresholds could overfit to the specific dataset splits, producing inflated performance estimates. By calibrating on one subset and evaluating on a held-out subset, the paper ensures that the reported accuracy, sample savings, and token savings reflect genuine generalization.

For the parallel pruning experiments (Section 5.3), the random forest classifier is trained on the calibration split of each fold and evaluated on the test split, again with three-fold averaging. This means the classifier is trained on a different 30% of the data in each fold, and its performance on the held-out 70% is what's reported.

Summary of Design Choices and Their Justifications

  • Three complementary signals (Net, Cumulative, Aligned Change) rather than a single metric: captures magnitude, path length, and directional consistency—different geometric properties that the paper shows carry independent predictive power.
  • Temporal (across-tokens) rather than spatial (across-layers) perspective: motivated by the intuition that reasoning is inherently a sequential process and that the dynamics of representational change over time encode information about reasoning quality that static layer geometry misses.
  • Fixed-size token segments ($k = 500$) rather than delimiter-based segmentation: ensures uniform treatment across models with different formatting styles, guarantees a minimum number of measurement points per trace, and has been empirically validated as robust to the exact segment size (300 vs. 500 produces "equivalent" results).
  • Layer averaging rather than layer selection: provides a simple, model-agnostic signal that doesn't require per-model tuning while still capturing the relevant dynamics (which are generally consistent across layers).
  • Threshold calibration on incorrect-trace distributions: sets decision boundaries based on what wrong traces look like, framing correct-trace detection as outlier identification—a principled statistical approach that doesn't require modeling the distribution of correct traces.
  • Simple weighted combination (Combined LT) rather than learned aggregation: keeps the method training-free (the weights are computed from simple correlations, not learned via optimization) while still capturing the complementary information across signals.
  • Random forest for parallel pruning rather than a simple threshold: handles the multi-candidate selection problem, which a single-threshold approach cannot solve, while remaining lightweight and fast to train.
  • Three-fold cross-validation with separate calibration and evaluation splits: ensures that reported performance estimates are not inflated by overfitting the decision thresholds or classifier to the test data.

4. Key Insights and Innovations

Innovation 1: The Temporal Perspective on Representational Dynamics Is a Fundamentally Different Signal Source Than the Spatial Perspective

The paper's most distinctive conceptual contribution is not the specific LT metrics, but the shift from analyzing representations across layers at a fixed position to analyzing them across token positions over time. This is a reframing of where to look for reasoning quality signals, and it is not an incremental refinement of prior representational analysis—it is a different hypothesis about how reasoning quality is encoded in model internals.

What the field did before. Prior work on using hidden states to predict model behavior almost exclusively adopted what the paper calls a "spatial" or "cross-layer" perspective. Wang et al. (2024) examined representational curvature across layers to predict accuracy in instruction-tuned models. Probing methods (e.g., Zou et al., 2023; Turner et al., 2023; Zhang et al., 2025) typically extract hidden states at specific layers or specific token positions and train classifiers on them. The implicit assumption in this tradition is that reasoning quality manifests as a layer-level computation pattern—deeper layers doing something different from shallower layers when reasoning is correct versus incorrect. The cross-layer baselines in this paper (Layer Magnitude, Layer Angle) are direct instantiations of this spatial perspective, and their inconsistent performance (ROC-AUC of 0.58–0.67 with high variance across models, Figure 3) demonstrates the limits of this assumption.

What the temporal perspective contributes. The paper hypothesizes instead that reasoning quality manifests as a trajectory through representation space over time—the path the model's internal state takes as it generates reasoning tokens. This is not simply a different measurement of the same underlying phenomenon; it reflects a different understanding of what reasoning is. Reasoning is inherently sequential: the model builds understanding step by step, each step potentially building on or revising previous steps. The temporal dynamics of representational change—whether the model moves far or stays close, whether it moves directly or wanders, whether its steps align with its overall direction—capture properties of this sequential process that are invisible when you look at a single time slice. The substantially higher and more consistent predictive performance of the LT signals (ROC-AUC 0.71–0.74, Figure 3) provides empirical support that the temporal dimension carries reasoning-quality information that the spatial dimension misses.

Why this is a fundamental shift, not a refinement. This reframing changes what kind of information we should expect to be predictive. Under the spatial perspective, you might look for features like "layer 24 is more active for correct reasoning" or "the representation changes abruptly at layer 18 when reasoning is successful." These are static, structural features of the model's computation. Under the temporal perspective, the predictive features are dynamic and geometric: trajectory length, directional consistency, displacement magnitude. This opens an entirely different analytical toolbox—one drawn from dynamical systems, differential geometry, and time-series analysis—for understanding and controlling reasoning models. It also suggests that the model's process of reasoning leaves a detectable signature in its internal dynamics, independent of the content of the reasoning (what the model says it's doing in the surface text). This connects to the growing body of evidence that surface-form reasoning traces are an unreliable proxy for internal computation (Chen et al., 2025; Stechly et al., 2025), and provides a concrete alternative: look at the trajectory, not the text.

Evidence anchor. The comparison in Figure 3 is the key evidence: LT signals consistently achieve ROC-AUC well above 0.7 across three models and three datasets, while cross-layer signals fluctuate between 0.45 and 0.80 depending on the specific model-dataset combination, with mean performance substantially below the LT signals. The higher variance of cross-layer signals (standard deviations of ±0.17 and ±0.14 versus ±0.08–0.09 for LT signals) indicates that the spatial perspective is model- and domain-specific, while the temporal perspective generalizes more robustly.

Innovation 2: Cumulative Change as a Negative Signal Reveals That Correct Reasoning Is Characterized by Representational Efficiency, Not Representational Effort

Among the three LT signals, Cumulative Change carries the most counterintuitive and diagnostically important finding: successful reasoning traces involve less total representational movement than unsuccessful ones (Spearman's r = −0.38 with accuracy, Section 5.1). This is not merely an empirical observation—it challenges a plausible but incorrect intuition about how reasoning works in these models.

The naive intuition. A natural hypothesis would be that more reasoning effort—more computation, more representational change, more intermediate steps—leads to better answers. Under this view, a reasoning trace that generates many intermediate tokens and undergoes substantial representational shifts would be more likely to be correct, because the model is "thinking harder." This intuition aligns with the scaling paradigm that more inference compute generally improves performance (Guo et al., 2025; OpenAI, 2024). If this were true, Cumulative Change (total path length) should be positively correlated with accuracy.

The actual finding. Cumulative Change is negatively correlated with accuracy, and the negative correlation is the strongest among the three LT signals (−0.38 versus +0.28 for Net Change and +0.32 for Aligned Change). This means that traces where the model's representation wanders extensively—moving back and forth, exploring different regions of latent space, making large but undirected shifts—are systematically less likely to produce correct answers. Correct traces, by contrast, exhibit representational efficiency: they move directly from the initial problem encoding to the solution state without excessive intermediate detours.

Why this matters beyond the paper's efficiency applications. This finding provides a mechanistic grounding for behavioral observations that have been reported but not explained. Prior work has noted that "long but highly varying reasoning traces are associated with lower accuracy" (Balachandran et al., 2025; Shojaee et al., 2025) and that models exhibit "overthinking"—continuing to generate reasoning tokens long after reaching a correct solution (Chen et al., 2024). The Cumulative Change signal explains why these behavioral patterns correlate with inaccuracy: the model's latent trajectory reflects the same inefficiency. The representation doesn't settle; it continues to shift, indicating unstable or non-convergent computation. This connects the behavioral surface form (long, varied traces) to the internal mechanism (high Cumulative Change), suggesting that the surface behavior is not merely an epiphenomenon but reflects genuine representational instability.

Implications for model training and architecture. This finding suggests a new optimization target: rather than training models to produce more reasoning (longer traces), we might train them to produce more efficient reasoning (traces with lower Cumulative Change relative to Net Change). A model whose internal trajectory is direct and settled would likely produce more concise surface reasoning as a byproduct, addressing the overthinking problem at its representational root rather than through surface-level length penalties. The paper doesn't explore this training direction, but the finding opens it as a concrete research avenue.

Evidence anchor. The distribution plots in Figure 8 (Appendix B) make this pattern visually clear: the Cumulative Change distributions for incorrect traces are consistently shifted toward higher values compared to correct traces across all three models and all three datasets. For Qwen3 on AIME2025, the median Cumulative Change for incorrect traces is roughly 2–3× that of correct traces (Figure 4 in the main text). The layer-wise breakdown (Appendix B, Figure 11) shows this negative relationship is consistent across all layers, not concentrated in specific depth ranges.

Innovation 3: Latent-Trajectory Signals Operationalize a Training-Free, Model-Agnostic Alternative to Both Verifiers and Surface-Form Analysis

The paper's practical contribution is not a new training method or model architecture, but a deployment strategy: using geometric properties of hidden states as a zero-cost replacement for verifier models and a more reliable alternative to surface-form heuristics. This occupies a previously empty niche in the inference-time toolkit.

The three existing approaches and their costs. Before this work, there were three families of methods for predicting which reasoning traces are correct, each with a distinct cost-accuracy tradeoff:

  1. Verifier models (Weng et al., 2023; Madaan et al., 2023; Zhang et al., 2024) achieve the highest accuracy but require either training a separate model (substantial upfront cost) or running additional forward passes at inference time (doubling the per-trace compute). They are effective but expensive.

  2. Surface-form heuristics—trace length (Hassid et al., 2025), output-distribution confidence (Kadavath et al., 2022; Yona et al., 2022), self-consistency (Wang et al., 2023)—are computationally cheap but unreliable. The paper demonstrates that length (Shortest@5 baseline) reduces accuracy by 1.4% on average, and output-distribution metrics perform near chance (ROC-AUC 0.44–0.59). Self-consistency (majority voting) is robust but requires generating many samples, making it computationally expensive—it's a sampling strategy, not a trace-quality predictor.

  3. Trained probes (Zhang et al., 2025; Manvi et al., 2024) occupy an intermediate position: they achieve good accuracy by training classifiers on hidden states, but they are model-specific and task-specific, requiring separate training for each deployment context.

Where LT signals fit. The LT approach introduces a fourth category: signals that are as cheap as surface-form heuristics (computed directly from hidden states already generated during inference, requiring no additional forward passes, no external models, no training) but substantially more accurate (ROC-AUC 0.71–0.74 vs. 0.44–0.59 for output-distribution metrics). They are also model-agnostic—the same three signals, computed identically, work across three different model families (DeepSeek-R1-Distill-Qwen-14B, Phi-4-Reasoning-Plus, Qwen3-14B) and three different reasoning domains (scientific QA, mathematical problem-solving, algorithmic optimization). The only per-deployment calibration is threshold selection, which the paper shows can be done with a small calibration set using a principled cross-validation procedure (Appendix D) without any gradient-based training.

Why this niche matters in practice. For practitioners deploying reasoning models at scale, the choice between "cheap but unreliable" and "accurate but expensive" is a genuine dilemma. The LT approach resolves this dilemma: it provides accuracy approaching that of verifier-based methods (the ROC-AUC of 0.71–0.74 means it can reliably distinguish correct from incorrect traces) at a computational cost approaching zero. The 48–70% token savings reported in Table 1 are realized without any additional model forward passes—the savings come entirely from not generating samples that the LT signal identifies as unnecessary. This is a fundamentally different efficiency mechanism than prior approaches: rather than reducing the cost per sample (by making traces shorter or using a smaller verifier model), it reduces the number of samples needed.

Evidence anchor. The efficiency results in Table 1 demonstrate this niche directly: LT-guided selection matches or exceeds MV@5 accuracy while reducing token usage by 14–70% (average 48%). The fact that these savings are achieved with zero training cost (beyond the calibration threshold selection on a small held-out set) and zero additional inference cost (the LT signal computation is negligible compared to generation) makes the practical value proposition clear. The contrast with output-distribution baselines in Figure 3—where Perplexity and Entropy hover near chance while LT signals are consistently well above—demonstrates the gap LT fills between cheap-and-weak and expensive-and-strong.

Innovation 4: Reasoning-Quality Signals Emerge Early in the Trace, Enabling Compute Allocation Before Full Generation

The paper's finding that LT signals are predictive before the reasoning trace is complete (Section 5.3, Figure 6) transforms these signals from a post-hoc diagnostic tool into an active inference-time control mechanism. This is not merely an efficiency gain—it changes the relationship between the model and the inference budget from fixed-allocation to adaptive-allocation.

The default paradigm: generate first, evaluate later. In standard multi-sample inference with majority voting, all samples are generated to completion before any evaluation occurs. The compute budget is fixed per problem regardless of how quickly a correct solution emerges. Even in the sequential stopping variant (Section 5.2), the evaluation happens after a full trace is generated—the decision is whether to generate another trace, not whether to continue the current one. This means compute is always spent on completing traces, even ones that are already clearly wrong or clearly right from early representations.

What early emergence enables. The paper shows (Figure 6A) that Net Change and Cumulative Change achieve ROC-AUC significantly above chance (above 0.6) within the first 4,000 tokens—and this rises steadily as more tokens are observed. At inference time (Table 2), using these partial-trace signals to prune 4 out of 5 parallel traces at the 2,000-token checkpoint achieves accuracy competitive with or exceeding MV@5 while saving 48–72% of tokens. This means the model can decide which computational paths to invest in based on early internal dynamics, rather than blindly completing all paths and selecting afterward.

Why this is more than an incremental efficiency improvement. The early-emergence finding changes the conceptual framing from "LT signals help us select answers after generation" to "LT signals enable us to actively manage the inference compute budget during generation." This shifts inference from a passive process (generate, then evaluate) to an active one (generate partially, evaluate internal signals, allocate remaining budget to promising candidates). It is a form of test-time compute allocation that is guided by internal model dynamics rather than external heuristics or separate models—and it works because the signal source (hidden states) is available continuously during generation, not just at the end.

The distinction matters for deployment architectures. In a latency-constrained setting, you can't afford to generate 5 full traces and then vote—the wall-clock time of 5 sequential generations is prohibitive. But you can afford to generate 5 partial traces in parallel (same latency as one partial trace), evaluate their LT signals, and complete only the best one (adding the latency of one full trace). The paper doesn't discuss wall-clock latency explicitly, but this architectural implication follows directly from the early-emergence result.

Evidence anchor. Table 2 shows the concrete outcome: on Phi4R+ across GPQA, AIME2025, and TSP, early path selection at 2k tokens improves accuracy by 2.0–4.4 percentage points over MV@5 while saving 65–72% of tokens. The fact that accuracy improves (not just stays flat) while saving the majority of tokens indicates that LT signals at 2k tokens are not merely a weak proxy—they are sufficiently reliable to make better selection decisions than majority voting over 5 full traces. Figure 6A provides the underlying predictive performance curves showing ROC-AUC rising with token count, and Figure 6B confirms that at 4,000 tokens, LT signals substantially outperform cross-layer baselines at the same partial-trace depth.

5. Experimental Analysis

Evaluation Methodology

  • Datasets. The paper evaluates on three benchmarks spanning distinct reasoning domains: (1) GPQA Diamond — 198 graduate-level multiple-choice questions in biology, chemistry, and physics (Rein et al., 2024); (2) AIME 2025 — 30 problems from the American Invitational Mathematics Examination (AIME, 2025); (3) TSP — a stratified subsample of 180 path-optimization problems with graphs of 6 to 13 nodes from the TSP benchmark (GeoMeterData, 2025). These three domains are deliberately chosen to test whether LT signals generalize across scientific reasoning (GPQA), mathematical problem-solving (AIME2025), and algorithmic/planning tasks (TSP). The GPQA and AIME2025 datasets represent the full available test sets, while TSP is a stratified subsample designed to include varying difficulty levels.

  • Base models. Three open-source reasoning-enabled models are evaluated, all at the ~14B parameter scale: DeepSeek-R1-Distill-Qwen-14B (R1-D) (Guo et al., 2025), Phi-4-Reasoning-Plus (Phi4R+) (Abdin et al., 2025), and Qwen3-14B with thinking mode enabled (Qwen3) (Yang et al., 2025a). The choice of the 14B scale is pragmatic: these models are representative of contemporary open-source reasoning models, their hidden states are fully accessible (unlike API-based models), and they produce sufficiently long reasoning traces (5,000–30,000+ tokens) to make the temporal trajectory analysis meaningful. All three models use the same inference framework (Eureka ML Insights, Appendix G) with model-specific sampling parameters: R1-D uses temperature 0.6 and top-p 0.95; Phi4R+ uses temperature 0.8, top-k 50, and top-p 0.95; Qwen3 uses temperature 0.6, top-p 0.95, and top-k 20. Max generation length is uniformly set to 31,768 tokens.

  • Metrics. The primary evaluation metric is ROC-AUC (area under the receiver operating characteristic curve) for assessing how well each signal discriminates between reasoning traces that lead to correct versus incorrect final answers (Section 5.1). For the inference-time scaling experiments (Sections 5.2–5.3), the metrics shift to practical outcomes: accuracy (percentage of problems solved correctly), average number of samples generated per problem, and proportion of tokens saved relative to the majority-vote baseline (MV@5, which uses 5 samples per problem). Token savings are computed as the percentage reduction in total reasoning tokens consumed compared to MV@5, accounting for both the reduced number of samples and the fact that early-stopped samples may be shorter than full traces.

  • Baselines. The paper compares against three families of baselines at different stages of the evaluation. (1) Cross-layer signals adapted from Wang et al. (2024): Layer Magnitude (magnitude of representational changes between consecutive layers within a reasoning segment, normalized by total change from first to last layer) and Layer Angle (angular change between consecutive layers, similarly normalized), both averaged across reasoning segments (Section 4.1). (2) Output-distribution measures following Yona et al. (2022): Logit Margin (difference between top-2 token logits at the final answer position), Entropy (entropy of the output token distribution), and Perplexity (inverse probability of the top-ranked token), all computed on the answer token following a "Final Answer:" prompt delimiter (Section 4.1). (3) Inference-time aggregation strategies: Majority voting over 5 samples (MV@5), the default approach for reasoning model releases (Abdin et al., 2025; Guo et al., 2025), and Shortest@5 (selecting the candidate with the fewest tokens among 5 samples), motivated by recent findings that shorter completions correlate with accuracy (Hassid et al., 2025; Shrivastava et al., 2025).

  • Generation budget and compute accounting. The unit of compute is the number of generated reasoning traces (samples), with each trace comprising both reasoning tokens and final answer tokens. For the sequential stopping experiments (Section 5.2), the budget is up to k = 5 samples, matching MV@5—the LT procedure can stop earlier but never exceeds 5. For the parallel pruning experiments (Section 5.3), the budget is 5 partial traces (each generated to exactly 2,000 reasoning tokens) plus 1 complete trace (the selected candidate decoded to completion). Token savings are computed by comparing the total tokens generated under the LT policy to the total tokens that would have been generated under MV@5 (5 full traces). The LT signal computation itself is considered negligible relative to generation cost—it involves only vector norm and dot-product operations on hidden states that are already computed during generation.

  • Cross-validation and statistical protocol. For the discriminative power analysis (Section 5.1, Figure 3), 5 independent reasoning traces are generated per problem, and ROC-AUC is computed by sweeping a decision threshold over the LT scores, with correctness determined by final-answer matching. For the sequential stopping experiments (Section 5.2), a three-fold shuffled cross-validation procedure is used (Appendix D): in each fold, 30% of the data calibrates decision thresholds, and 70% is held out for evaluation, with results averaged across folds. The calibration procedure constructs candidate thresholds from the 20th–99th percentiles of LT values observed among incorrect traces, simulates the full decision rule for each candidate threshold, and selects the best-performing threshold based on overall calibration accuracy. For the parallel pruning experiments (Section 5.3), a random forest classifier is trained on the calibration split of each fold and evaluated on the test split, with three-fold averaging. For the Combined LT score, signal weights are computed from absolute Pearson correlations with accuracy on a 10% calibration slice (Appendix E).

Main Quantitative Results

Latent-Trajectory Signals Predict Solution Accuracy More Reliably Than All Baselines

The paper's foundational claim—that temporal trajectory signals are predictive of reasoning trace correctness—is established in Section 5.1 via ROC-AUC analysis across all model-dataset combinations. Figure 3 presents the aggregate results, with per-model-dataset breakdowns in Appendix A (Table 3).

Headline numbers. Across all settings, the three LT signals achieve mean ROC-AUCs of 0.71 ± 0.09 (Net Change), 0.74 ± 0.09 (Cumulative Change), and 0.73 ± 0.08 (Aligned Change). This substantially exceeds the cross-layer baselines (Layer Magnitude: 0.58 ± 0.17; Layer Angle: 0.67 ± 0.14) and the output-distribution baselines (Logit Margin: 0.59 ± 0.10; Entropy: 0.44 ± 0.10; Perplexity: 0.49 ± 0.12). The chance level is 0.5. All LT signals are consistently above it across all model-dataset pairs, while output-distribution metrics frequently fall below 0.5 (e.g., Entropy achieves 0.230 on Phi4R+/GPQA, 0.286 on Qwen3/AIME2025).

Model-dataset breakdown. The strongest discriminative performance occurs on AIME2025 with Qwen3, where Cumulative Change achieves an ROC-AUC of 0.947 and Net Change reaches 0.921 (Table 3)—near-ceiling performance indicating that on this model-dataset pair, the representational dynamics almost perfectly separate correct from incorrect traces. The weakest performance is on TSP with R1-D, where Net Change achieves ROC-AUC of 0.641 and Cumulative Change 0.687—still substantially above chance but indicating that algorithmic reasoning may produce more variable or less diagnostic representational trajectories. Phi4R+ shows the most consistent performance across datasets (LT signals consistently in the 0.73–0.79 range), while Qwen3 shows the most variable (0.64–0.95, with extremely strong performance on AIME2025 specifically).

Correlation direction and magnitude. Spearman correlations with accuracy (Table 3) reveal consistent directional patterns: Net Change is positively correlated (mean r = 0.28 across all model-dataset pairs), Aligned Change is positively correlated (mean r = 0.32), and Cumulative Change is negatively correlated (mean r = −0.38). The negative correlation of Cumulative Change is the strongest single association, and it is consistent across all 9 model-dataset pairs (ranging from −0.259 on Qwen3/GPQA to −0.691 on Qwen3/AIME2025). This establishes Cumulative Change as the most individually diagnostic signal: traces that wander more through representation space (higher Cumulative Change) are systematically less likely to be correct.

Cross-layer baselines: variable and model-specific. Layer Magnitude shows extreme variability: it achieves 0.795 on R1-D/AIME2025 but only 0.295 on Qwen3/AIME2025 and 0.387 on Qwen3/TSP. The ±0.17 standard deviation across settings is more than double the ±0.09 of the LT signals, indicating that cross-layer spatial geometry is not a robust predictor—it works well on some model-dataset combinations but fails on others. Layer Angle is somewhat more stable (0.67 ± 0.14) but still underperforms all three LT signals in mean AUC.

Output-distribution baselines: near chance. The paper's most striking negative result is the failure of output-distribution confidence measures. Entropy achieves a mean ROC-AUC of 0.44—below chance, meaning that on average, higher entropy (more uncertainty) is weakly associated with correct answers, which is the opposite of what confidence-based theories predict. Perplexity at 0.49 is essentially at chance. Logit Margin at 0.59 is above chance but unreliable (ranging from 0.438 on Qwen3/TSP to 0.728 on Qwen3/AIME2025). This finding is particularly important because it establishes that for reasoning models specifically, the common practice of using output probabilities as confidence estimates is unreliable—the reasoning process decouples final-token probabilities from solution quality in ways that LT signals do not.

Visual evidence of signal distributions. Figure 4 in the main text (Qwen3/AIME2025) and the full distribution plots in Appendix B (Figures 7–9 for all model-dataset pairs) show the LT signal distributions conditioned on correctness. The separation is visually clear for Cumulative Change on Qwen3/AIME2025 (correct traces cluster around 500–1500; incorrect traces span 500–3000+, with substantially higher medians). Net Change distributions show correct traces shifted rightward (larger net displacement). Aligned Change distributions show correct traces shifted rightward (more directional consistency). The layer-wise breakdowns (Figures 10–12) confirm that these patterns are consistent across all transformer layers, not concentrated in specific depth ranges, though middle-to-late layers often show larger effect sizes.

Latent-Trajectory Signals Make Multi-Sample Inference More Efficient and More Accurate

Section 5.2 evaluates whether the predictive power of LT signals translates into practical gains when used to guide answer selection in sequential multi-sample inference. The experimental setup generates samples sequentially and uses calibrated LT thresholds to decide whether to accept the current trace's answer or continue sampling, falling back to majority voting if no trace exceeds the threshold after 5 attempts (Figure 5). Table 1 reports accuracy, average samples used, and token savings for all LT strategies (Net, Cumulative, Aligned, Combined) against baselines MV@5 and Shortest@5.

Accuracy improvements over MV@5. LT-guided selection does not merely preserve MV@5 accuracy—it often improves it. Key results from Table 1:

  • On GPQA: R1-D gains +2.2% (Cumulative Change, 62.10% vs. 59.90% MV@5); Phi4R+ shows small losses (−0.6% to −1.4%) suggesting that MV@5 is already near-optimal for this model-dataset; Qwen3 is essentially flat (−0.7% to +0.2%).

  • On AIME2025: Gains are substantial across all models. R1-D achieves +5.2% (Net Change and Combined, 61.90% vs. 56.67%); Phi4R+ gains +2.6% (Combined, 82.60% vs. 80.00%); Qwen3 achieves a striking +14.1% (Cumulative Change, 84.10% vs. 70.00%). This is the paper's strongest accuracy result: LT signals identify correct individual traces even when the majority of the 5 samples are incorrect, allowing the system to select the correct minority answer rather than being drowned out by majority voting.

  • On TSP: Consistent but smaller gains: R1-D +3.4% (Cumulative Change, 30.90% vs. 27.50%); Phi4R+ +3.1% (Cumulative Change, 44.40% vs. 41.25%); Qwen3 +1.6% (Aligned Change, 37.80% vs. 36.25%).

The average accuracy improvement across all model-dataset pairs and LT strategies is +2.64%, with a range of −1.4% to +14.10% (Section 5.2 summary). The best individual signal varies by setting, but the Combined LT score is consistently competitive, matching or approaching the best individual signal in most cases.

Sample and token savings. Efficiency gains are larger and more consistent than accuracy gains. The average number of samples required drops from 5.00 (MV@5) to:

  • R1-D: 1.22–2.56 samples (depending on signal and dataset), corresponding to 30–71% token savings.
  • Phi4R+: 1.59–3.40 samples, corresponding to 15–67% token savings.
  • Qwen3: 1.42–3.18 samples, corresponding to 34–65% token savings.

The largest savings occur on TSP with R1-D (Net Change: 1.43 samples, 70.6% token savings) and AIME2025 with R1-D (Net Change: 1.22 samples, 68.7% token savings). The Combined LT score achieves approximately 50% token savings across most settings. At an aggregate level, LT strategies reduce the number of samples by 58% on average (range 32–76%) and reduce token usage by 48% on average (range 14–70%).

Shortest@5 baseline. The paper explicitly tests whether trace length alone can serve as a selection signal. The Shortest@5 baseline (selecting the shortest of 5 traces) reduces accuracy by an average of 1.4% compared to MV@5 (Table 1). Notable failures: on AIME2025, Phi4R+ drops from 80.00% to 70.00% (−10.0%), and on TSP, Qwen3 drops from 36.25% to 30.63% (−5.6%). This directly contradicts the hypothesis that shorter traces are more likely correct and demonstrates that the LT signals capture information about reasoning quality that is not reducible to trace length.

Above-threshold accuracy analysis. Appendix C (Table 4) reports the accuracy of solutions that exceeded the LT thresholds—i.e., the quality of answers the system actually accepts early. These above-threshold accuracies are consistently high: for Cumulative Change on Qwen3/AIME2025, above-threshold accuracy reaches 96.50%, with 85.7% of datapoints triggering an early stop. For Phi4R+ on AIME2025 with Combined LT, above-threshold accuracy reaches 91.10% with 69.8% coverage. This provides direct evidence that the LT thresholds select genuinely high-quality traces—the early-stopped answers are not merely lucky guesses but systematically correct.

Coverage-accuracy tradeoff. Figure 13 (Appendix C) shows accuracy as a function of threshold quantile. As expected, stricter thresholds (higher quantiles) yield higher accuracy among accepted traces but apply to fewer datapoints (more fallback to majority voting). The curves rise monotonically for all signals across all datasets, confirming that LT scores reliably rank trace quality—higher LT scores consistently correspond to higher probability of correctness. This monotonicity is essential for the threshold-based decision rule to be well-calibrated.

Latent-Trajectory Signals Enable Early Selection of High-Quality Traces During Parallel Generation

Section 5.3 evaluates whether LT signals computed on partial traces (before generation is complete) can guide compute allocation by pruning unpromising candidates early and completing only the most promising one. The experimental setup generates 5 traces in parallel up to 2,000 reasoning tokens, computes LT signals on these partial traces, uses a random forest classifier to select the single best candidate, and completes only that candidate to full length. Table 2 reports accuracy and token savings compared to MV@5.

Headline results. Early path selection at 2k tokens achieves:

  • Accuracy improvements over MV@5: R1-D gains +6.7% on AIME2025 (63.33% vs. 56.67%) while remaining competitive on GPQA (−0.5%) and TSP (−1.3%); Phi4R+ gains across all three datasets: +2.0% on GPQA, +3.3% on AIME2025, +4.4% on TSP; Qwen3 gains consistently: +2.5% on GPQA, +3.3% on AIME2025, +1.9% on TSP. The average accuracy improvement across all settings is +2.1%.

  • Token savings: R1-D saves 49–63% of tokens; Phi4R+ saves 65–72% of tokens; Qwen3 saves 51–69% of tokens. The average token savings across all settings is 61%. The savings are very large on Phi4R+ (67–72%) because this model produces the longest reasoning traces on average—pruning 4 out of 5 traces at 2k tokens saves proportionally more when the full traces would have been very long.

Predictive performance of partial-trace signals. Figure 6A shows ROC-AUC of Net Change and Cumulative Change as a function of the number of reasoning tokens observed. Key findings:

  • Both signals rise above chance (ROC-AUC > 0.5) very early—within the first 1,000–2,000 tokens across all datasets.
  • ROC-AUC generally increases with more tokens, reaching values of 0.7–0.8 by 15,000 tokens, consistent with the full-trace results.
  • For GPQA and AIME2025, Net Change is more predictive than Cumulative Change in the early trace (first 4k tokens), but Cumulative Change catches up later. For TSP, the pattern reverses: Cumulative Change is substantially more predictive than Net Change throughout the early and mid-trace. This domain-specific pattern suggests that algorithmic reasoning (TSP) may involve a different representational dynamic—perhaps cumulative wandering is a stronger diagnostic for optimization problems, while net displacement is more diagnostic for scientific and mathematical reasoning.

Comparison to cross-layer baselines at 4k tokens. Figure 6B directly compares LT signals to Layer Magnitude and Layer Angle at the 4,000-token mark. LT signals achieve ROC-AUCs of 0.60–0.75 depending on dataset, while cross-layer signals achieve 0.40–0.60. The gap is substantial and consistent, confirming that the temporal perspective is not merely a full-trace phenomenon—it is specifically valuable even when only early portions of the trace are available.

Why this result matters beyond efficiency. The early selection results demonstrate that LT signals are not just post-hoc correlates of reasoning quality but causally upstream indicators—they detect representational patterns that precede and predict the final answer, emerging during the reasoning process itself. This is what distinguishes LT signals from output-distribution measures (which only become available at the very end when the answer token is generated) and from verifiers (which typically evaluate completed solutions). The practical implication is that LT signals enable a fundamentally different inference architecture: allocate compute dynamically based on ongoing internal dynamics, rather than committing to a fixed budget upfront.

Ablation Studies and Robustness Checks

Segment size robustness (Appendix F): The paper's primary results use k = 500 tokens per reasoning segment. To test robustness, the authors replicate the ROC-AUC analysis (Section 5.1) using k = 300 tokens (Figure 14). The results are described as "equivalent" to the k = 500 results—the LT signals continue to achieve ROC-AUC well above chance and outperform all baselines. Error bars across models remain consistent. The specific choice of 500 is motivated by the shortest average trace length across datasets (5,000 tokens for one dataset), ensuring at least 10 measurement points per trace. The robustness to k = 300 (which would produce ~17 measurement points for a 5,000-token trace) indicates that the exact segment resolution is not critical as long as sufficient measurement points are available.

Segmentation method comparison (Appendix F): The paper compares fixed-size token segmentation to delimiter-based segmentation (splitting by newline characters \n). The delimiter-based approach is rejected because "segment sizes varied substantially across models under this approach, making it less comparable across architectures." Different models produce differently structured reasoning traces (different paragraph lengths, different formatting conventions), so delimiter-based segmentation would produce different numbers of segments for the same problem across models, complicating cross-model signal comparison. The fixed-k approach ensures uniform treatment regardless of formatting style.

Model-specific signal performance (Appendix A, Table 3): The full breakdown of ROC-AUC and Spearman correlations per model-dataset pair reveals several nuanced findings. (1) Cumulative Change achieves the highest single ROC-AUC in the entire paper: 0.947 on Qwen3/AIME2025. (2) The cross-layer baselines show a stark model dependency: Layer Magnitude achieves 0.795 on R1-D/AIME2025 but only 0.295 on Qwen3/AIME2025—a swing of 0.50 AUC, indicating that cross-layer geometry is highly architecture-specific. The LT signals show much smaller variance across models on the same dataset. (3) Output-distribution metrics occasionally perform well (Logit Margin achieves 0.728 on Qwen3/AIME2025) but are unreliable—on the same model with GPQA, Logit Margin achieves only 0.444. This inconsistency makes them unsuitable as a general-purpose solution.

Combined LT score weight analysis (Appendix E, Table 5): The weights assigned to each LT signal in the Combined score reveal which signals contribute most to prediction on each model-dataset pair. Cumulative Change consistently receives the highest or near-highest weight (0.38–0.45 across most settings), reflecting its strongest correlation with accuracy. The specific weights vary by setting: on R1-D/GPQA, the weights are 0.35/0.40/0.25 (Net/Cumulative/Aligned); on Phi4R+/AIME2025, they shift to 0.26/0.45/0.29, giving even more weight to Cumulative Change; on R1-D/TSP, Aligned Change receives its highest weight (0.37), reflecting its stronger performance on algorithmic reasoning. This variation confirms that all three signals carry independent predictive power and that the optimal combination is task-dependent. The simple correlation-based weighting scheme provides a training-free way to adapt.

Threshold calibration procedure validation (Appendix D): The three-fold cross-validation with 30% calibration / 70% test splits ensures that reported results are not inflated by overfitting thresholds to the evaluation data. The calibration uses only incorrect-trace distributions to set thresholds, which means it does not require seeing correct traces during calibration—an important practical property since correct traces may be rare in deployment. The fallback to median value when fewer than 15 incorrect examples are available ensures the procedure degrades gracefully on small calibration sets. The use of quantile-based candidate thresholds (20th–99th percentiles) provides a principled search space that does not require modeling the LT signal distributions parametrically.

Coverage-accuracy curves (Appendix C, Figure 13): The monotonic relationship between threshold quantile and accuracy is confirmed for all three LT signals across all datasets. This is not a given—if LT scores were noisy or inconsistent, stricter thresholds would not necessarily yield higher accuracy. The clean monotonicity indicates that LT scores reliably rank trace quality and that threshold selection is well-behaved: choosing a stricter threshold predictably yields higher precision at the cost of lower recall (less coverage), with no pathological cases where intermediate thresholds outperform stricter ones.

Negative result: Shortest@5 fails (Table 1): The explicit test of trace length as a selection signal yields a robust negative result. Across all model-dataset pairs except one (R1-D/GPQA shows +1.0%), selecting the shortest of 5 samples either matches or reduces accuracy relative to MV@5. The average accuracy change is −1.4%, with large drops on specific pairs (Phi4R+/AIME2025: −10.0%). This negative result is important because it demonstrates that LT signals capture information beyond surface-level trace characteristics—the geometric properties of the latent trajectory are not reducible to the behavioral property of trace length.

Critical Assessment

Does the paper demonstrate that LT signals are predictive of solution accuracy?

Yes, with robust evidence. The ROC-AUC analysis (Section 5.1, Figure 3, Table 3) covers 3 models × 3 datasets = 9 independent evaluations, with 5 traces per problem, totaling thousands of reasoning traces. All three LT signals achieve ROC-AUC consistently above 0.6 and often above 0.7–0.8, substantially exceeding chance (0.5) and all baselines. The standard deviations across model-dataset pairs (±0.08–0.09 for LT signals vs. ±0.10–0.17 for baselines) confirm the signals' robustness. The distribution plots (Figures 4, 7–12) provide visual confirmation of systematic separation between correct and incorrect trace distributions. The correlation analysis (Table 3) confirms consistent directional relationships.

However, the experiments demonstrate relative superiority over baselines, not absolute prediction quality. An ROC-AUC of 0.71 means the signal can correctly rank a randomly chosen correct trace above a randomly chosen incorrect trace 71% of the time—this is useful but far from perfect. The practical inference-time experiments (Tables 1–2) show that this level of discriminative power is sufficient for meaningful efficiency gains, but it also means the system will sometimes accept incorrect traces (false positives) and sometimes fail to recognize correct ones (false negatives). The above-threshold accuracy analysis (Table 4) quantifies this: accepted traces achieve high accuracy (often 80–95%), but coverage is incomplete (45–99% depending on signal and dataset), meaning a non-trivial fraction of problems fall back to majority voting.

A more fundamental concern: the paper trains no classifiers for the main LT signal evaluation. The ROC-AUC analysis uses raw signal values with a simple threshold sweep—this is commendable for avoiding overfitting but may understate the achievable predictive performance if a learned classifier could extract more information from the full segment-level trajectory (beyond the three aggregate signals). The parallel pruning experiment's use of a random forest (Section 5.3) provides a partial answer: adding a lightweight classifier improves selection decisions, suggesting that the three aggregate signals do not capture all available trajectory information.

Does the paper demonstrate that LT signals enable compute savings at inference time?

Yes, with the important caveat that the savings are measured relative to the MV@5 baseline, not relative to optimal allocation. The sequential stopping experiments (Table 1) demonstrate 14–70% token savings while matching or improving accuracy, averaging 48% savings. The parallel pruning experiments (Table 2) demonstrate 48–72% token savings with average +2.1% accuracy improvement.

However, the experiments do not measure the cost of computing the LT signals themselves against the savings they enable. The paper argues that LT computation is "negligible" because it operates on already-computed hidden states, but no latency or FLOP measurements are reported. For the sequential stopping case, this is a minor concern—the dominant cost is generating reasoning tokens (thousands per trace), and computing three scalar signals from pre-existing hidden states is genuinely cheap. For the parallel pruning case, the concern is slightly larger: generating 5 partial traces of 2,000 tokens each costs 10,000 tokens of generation, and the random forest classifier adds a small but non-zero cost. The paper does not amortize this 10,000-token "exploration cost" against the savings from pruning—the savings are computed only on the tokens not generated for the pruned traces, not net of the partial generation cost.

A deeper concern, unaddressed by the paper: what is the lower bound on achievable token savings? The paper compares against MV@5, which is a strong baseline but potentially not the optimal allocation. Could you achieve similar accuracy with MV@3? With a single sample? The paper does not report accuracy at different sample counts for MV (e.g., MV@3 vs. MV@5), so it's unclear how much of the 48% savings comes from genuinely avoiding unnecessary computation versus simply correcting for MV@5 being overprovisioned. If MV@3 achieves the same accuracy as MV@5 on these datasets, then the LT savings relative to MV@3 would be smaller. This is a missing ablation that makes the absolute efficiency claim harder to interpret.

Does the paper demonstrate that LT signals generalize across models and domains?

Partially. The paper evaluates three models (all ~14B parameters, all reasoning-enabled, all transformer-based) and three datasets (GPQA, AIME2025, TSP). The consistent LT signal patterns across these 9 combinations are encouraging evidence of generalization. The fact that LT signals outperform baselines on all 9 combinations, with no exceptions, is strong evidence of robustness.

However, the generalization claim is limited in important ways that the paper does not fully acknowledge:

  1. All models are at the same scale (~14B). Hidden state geometry may change with model scale—larger models might have different representational dynamics (e.g., more linear trajectories, different dimensional properties). The paper provides no evidence that LT signals work on smaller models (7B, 1B) or larger models (70B, 405B). The concurrent work by Li et al. (2025) on sequential representational analysis for detecting repetition loops provides partial supporting evidence from a different angle, but direct scale-sweep experiments are absent.

  2. All models are reasoning-enabled. The paper explicitly studies models trained or fine-tuned for long-chain reasoning (R1-D via distillation from DeepSeek-R1, Phi4R+ via reasoning-focused training, Qwen3 with thinking mode). Standard instruction-tuned models without explicit reasoning training might have different latent dynamics—their representations may not show the same trajectory structure, or the relationship between trajectory geometry and correctness may differ. The paper does not include any non-reasoning baselines (e.g., Qwen3 without thinking mode, or a standard instruction-tuned model like Llama-3).

  3. All datasets have unambiguous correctness signals. GPQA has multiple-choice answers; AIME2025 has numeric answers; TSP has optimal path lengths. The LT signals are evaluated against ground-truth correctness, which is possible because these datasets have objective answer verification. On open-ended generation tasks (dialogue, creative writing, summarization), where "correctness" is subjective or multi-dimensional, the LT signal's relationship to output quality may differ. The paper does not discuss this limitation or suggest how LT signals might be used in subjective evaluation settings.

  4. Dataset sizes are very small for the parallel pruning experiment. AIME2025 has only 30 problems. With three-fold cross-validation, the random forest classifier for early path selection is trained on approximately 30 × 0.3 × 0.67 ≈ 6 problems per fold in the AIME2025 setting (30 problems, 30% calibration, but the calibration is further split by folds). This is an extremely small training set for any classifier, even a random forest, and the reported accuracy improvements (+3.3% to +6.7% on AIME2025, Table 2) may be heavily influenced by the specific split. The paper does not report confidence intervals on these accuracy numbers, making it difficult to assess statistical significance.

Does the paper demonstrate that LT signals emerge early enough to be practically useful?

The evidence is suggestive but incomplete. Figure 6A shows ROC-AUC rising above 0.6 within 2,000–4,000 tokens, and Table 2 shows that pruning at 2,000 tokens yields accuracy improvements. However, several aspects of the early-emergence claim warrant scrutiny:

  1. The 2,000-token checkpoint is not justified by any optimization. Why 2,000 rather than 1,000 or 4,000? The paper does not sweep the pruning point to find the optimal compute-accuracy tradeoff. The choice appears to be a reasonable heuristic, but the reported savings are specific to this choice—a different checkpoint would yield different savings. Providing a curve of accuracy vs. pruning point (similar to Figure 6A but for the end-to-end task accuracy rather than ROC-AUC) would substantially strengthen this result.

  2. Only Net Change and Cumulative Change are used for early prediction. Aligned Change is excluded because it is "inconsistent when applied earlier in the trace" (Section 5.3 footnote). This means the early prediction uses a subset of the available signals, which may explain why the early-selection accuracy gains (Table 2) are more modest than the full-trace sequential stopping gains (Table 1) on some settings (e.g., R1-D/TSP: LT early selection loses −1.3% accuracy vs. +1.1–3.4% for full-trace selection).

  3. The random forest classifier adds a training requirement. Unlike the threshold-based sequential stopping (which is fully training-free beyond threshold selection), the parallel pruning approach requires training a classifier. The paper emphasizes the "training-free" nature of LT signals (Section 3.1, Section 5.1), but the practical early-selection policy partially walks this back—you need to train a random forest per model-dataset pair. The distinction between "no training for the signal itself" and "no training for the decision policy" could be clearer.

Are there missing experiments that would substantially strengthen the paper?

Yes, several:

  1. Comparison to verifier-based approaches. The paper argues that LT signals are cheaper than verifier models, but it never directly compares LT-guided selection to verifier-guided selection at the same compute budget. If you're willing to spend the compute on an external verifier, does it achieve higher accuracy than LT? The paper can't answer this question because verifiers are not evaluated. This is a significant gap because verifiers are the primary competing approach for reasoning quality assessment (Section 2).

  2. Scale analysis. All experiments use 5 samples. How do LT signals' benefits scale with the number of samples? If you're generating 10 or 20 samples, do the relative savings increase (because more samples means more opportunities for early stopping) or decrease (because MV@N accuracy may saturate)? The paper's 5-sample experiments establish viability but don't characterize the scaling behavior.

  3. Latency measurements. The paper measures compute in "tokens" and "samples," which is a reasonable proxy for FLOPs but ignores wall-clock time. In the sequential stopping setting (Section 5.2), samples are generated sequentially—the first sample must complete before the second begins. If the first sample is long (e.g., 20,000 tokens) and the LT threshold stops after it, the wall-clock time is still 20,000 tokens' worth of generation. The token savings are realized because subsequent samples aren't generated, but the latency for that particular query is not reduced. The parallel pruning setting (Section 5.3) is better from a latency perspective because all partial traces are generated simultaneously, but this experimental design choice (sequential vs. parallel) is not discussed in terms of latency implications.

  4. Combining LT signals with majority voting. The fallback path in the sequential stopping procedure is majority voting over all generated samples. But what if you used LT signals to weight the majority vote rather than only selecting individual traces? Traces with higher LT scores could be given more weight in a weighted voting scheme. This might improve accuracy in the cases where no trace crosses the threshold, and it would be a natural extension of the current approach that the paper does not explore.

  5. Dynamic segment size based on trace length. The paper uses fixed k = 500, which works well for traces of 5,000+ tokens but might be suboptimal for shorter traces. Testing whether adaptive segment sizing (e.g., always producing exactly 10 segments regardless of trace length) would improve or degrade performance would characterize how sensitive the signals are to the number of measurement points.

Summary of strengths and weaknesses

Strengths:

  • The comparative evaluation against multiple baseline families (cross-layer, output-distribution, surface-form) is thorough and provides clear evidence for the LT signals' superiority.
  • The nine-way cross-product of models × datasets demonstrates consistent patterns and meaningful variance, giving confidence in generalization (within the 14B reasoning-model regime).
  • The practical inference-time experiments go beyond correlation analysis to demonstrate actionable efficiency gains, with rigorous cross-validation for threshold selection.
  • The negative results (output-distribution baselines near chance, Shortest@5 reducing accuracy) are valuable and well-documented.
  • The complementary nature of the three LT signals is demonstrated through both quantitative analysis (Combined LT weights) and qualitative interpretation (different geometric properties).

Weaknesses:

  • No comparison to verifier-based methods, despite verifiers being the primary competing approach in the related work.
  • Small datasets (AIME2025: 30 problems; GPQA: 198), making the cross-validation splits very small and potentially unreliable for statistical conclusions—no confidence intervals are reported.
  • The 14B-scale limitation and reasoning-model-only evaluation leave open questions about generalization to other scales and model types.
  • The cost of LT signal computation is claimed negligible but never measured.
  • The early-selection experiments use a single arbitrary pruning point (2k tokens) with no sensitivity analysis.
  • The MV@5 baseline against which all savings are measured may be overprovisioned—MV@3 or MV@1 accuracy is not reported, so the absolute efficiency improvement is harder to calibrate.
  • No latency analysis for the sequential stopping case, where token savings may not translate to wall-clock time savings if the first sample is long.

6. Limitations and Trade-offs

The difficulty estimation cost is unaccounted for in the reported efficiency gains

The assumption or constraint. The entire compute-optimal framework rests on first estimating a prompt's difficulty before deciding how to allocate the inference budget. The paper's difficulty estimation procedure generates 2048 samples per question, scores them (either against ground-truth correctness for oracle bins or against the PRM for predicted bins), and then bins questions into quintiles based on the resulting pass@1 estimates. The authors explicitly acknowledge in Section 3.2:

"estimating difficulty in this way still incurs additional computation cost during inference... our experiments do not account for this cost largely for simplicity"

The consequence. The reported 4× efficiency gains over best-of-N—which frame the paper's central claim—are computed after difficulty is already known, without amortizing the cost of learning it. In any realistic deployment, the total cost would be difficulty estimation (generating and scoring 2048 samples per question) plus strategy execution (the budgeted search or revision). Since 2048 samples is substantially larger than the largest test-time budgets studied (256–512 generations), the difficulty estimation step could easily dominate the total cost. The 4×4\times figure is therefore a theoretical upper bound on achievable efficiency that does not reflect what a practitioner would experience when deploying the system end-to-end on novel problems where difficulty is unknown. This matters directly for the paper's practical value proposition: if the difficulty estimation overhead exceeds the savings from adaptive allocation, the compute-optimal approach could be less efficient in practice than a simple fixed strategy.

What evidence exists in the paper. Section 3.2 discusses this limitation openly, stating that "we also flag the cost of estimating this difficulty in the present work... this therefore represents an exploration-exploitation tradeoff between spending compute on assessing difficulty versus solving the problem, and we leave investigating more efficient difficulty prediction schemes to future work." However, no experiment quantifies how much of the compute budget the difficulty estimation consumes relative to the solution budget, and none of the figures or tables (Figures 3, 4, 7, 8, 9) include this cost. The 4× claim appears in Figures 4 and 8, but these curves are computed assuming difficulty is known cost-free.

Mitigation status. The paper suggests future work on "pretraining or finetuning models to directly predict difficulty of a question" (Section 8) and notes that the predicted difficulty bins (using the PRM rather than ground-truth labels) perform comparably to oracle bins, which removes the need for answer access but not the need for 2048-sample generation. The paper does not develop or evaluate any cheap difficulty estimator. A potential mitigation—using a small number of initial samples to estimate difficulty adaptively and then allocating the remaining budget—is not explored. Until such a method is demonstrated, the 4× figure should be understood as a best-case scenario that assumes difficulty is known a priori, which is unrealistic in most deployment contexts.

The method provides zero benefit on the hardest problems, which are precisely the ones where help is most needed

The assumption or constraint. The paper consistently shows that test-time compute strategies—search against the PRM, iterative revisions, and their compute-optimal combinations—produce essentially no improvement on the hardest difficulty quintile (bin 5). The implicit assumption is that the base model's pass@1 rate on a problem is non-trivially above zero, meaning the model must already be capable of producing a correct solution at some reasonable frequency for test-time compute to matter.

The consequence. For problems where the base model's pass@1 rate is near zero (the hardest problems in any distribution), no amount of budget allocation—regardless of how optimal—yields meaningful gains. In Figure 3 (right), bin 5 accuracy hovers at 1–3% for all methods and all budgets up to 256 generations. In Figure 7 (right), bin 5 shows roughly 2–3% accuracy regardless of sequential-to-parallel ratio. In the FLOPs-matched comparison (Figure 9), the bin 5 scaling line is essentially flat near 0–5%—adding more test-time compute does nothing. This means the compute-optimal framework is fundamentally bounded above by the base model's capability: it can amplify existing competence but cannot create it from nothing. For deployment scenarios where the most valuable problems are the hardest ones (e.g., frontier scientific reasoning, novel mathematical proofs), the method offers no path forward—the recommendation from Section 7 would be to invest in pretraining a larger model rather than scaling test-time compute.

What evidence exists in the paper. The failure on hard problems is visible in every difficulty-bin breakdown in the paper: Figure 3 (right) for PRM search, Figure 7 (right) for revisions, and Figure 9 (Section 7) for the FLOPs-matched comparison. The paper is transparent about this: the takeaway box in Section 7 explicitly states that on hard problems, "test-time compute provides essentially zero benefit regardless of budget, meaning that some capabilities can only be acquired through pretraining, not recovered at inference time." Table 3 in Appendix A further confirms this: the ROC-AUC for all LT signals drops significantly on harder datasets (e.g., R1-D on TSP achieves ROC-AUC of 0.64–0.69 versus 0.69–0.76 on GPQA and AIME2025), reflecting weaker signals when the model's baseline capability is lower.

Mitigation status. The paper does not attempt to solve the hard-problem limitation. It frames it as a fundamental boundary condition: "test-time compute amplifies existing capability but does not create it from nothing." This is presented as a finding rather than a limitation per se—it tells practitioners when not to use test-time compute scaling (hard problems, low pass@1) and when to use it (easy-to-medium problems). The acknowledgment is intellectually honest, but it also means the method's practical scope is restricted to problems within the base model's current reach. For organizations facing hard problems, the paper's recommendation is explicit: scale pretraining, not inference. An unexplored question is whether intermediate difficulty estimation could be used to detect that a problem is too hard and route it to a larger model rather than wasting compute on test-time strategies—this would be a natural extension of the adaptive allocation framework.

All results are on a single benchmark (MATH) with a single model family (PaLM 2), leaving generalization to other domains and architectures unverified

The assumption or constraint. The paper conducts all experiments on the MATH benchmark (500 test questions) using PaLM 2-S* models (both the base model and a ~14× larger variant for the FLOPs-matched comparison). The authors state they "believe this model is representative of the capabilities of many contemporary LLMs" (Section 4), but this is an assertion without supporting cross-model evidence within the paper.

The consequence. Several aspects of the findings could be specific to MATH or to PaLM 2's architecture and training:

  • PRM over-optimization behavior (Figure 3, right): The specific budget levels at which beam search begins to degrade on easy problems almost certainly depend on the PRM's training quality and calibration, which in turn depend on the base model's output distribution. A model with different calibration properties (e.g., better-aligned confidence estimates) might exhibit different over-optimization thresholds, shifting the optimal strategy per difficulty bin.
  • Revision model training dynamics: The finding that fine-tuning on paired correct-incorrect trajectories (with edit-distance-based selection) enables effective iterative revision depends on the base model's in-context learning capabilities and its ability to generate diverse but structurally similar incorrect answers. Different model families (e.g., Llama, GPT, Claude) might require different data construction strategies to achieve comparable revision capability.
  • The MATH benchmark consists exclusively of competition-level math problems requiring symbolic reasoning with unambiguous correct answers. It is unclear whether the difficulty-dependent patterns generalize to other reasoning domains: code generation (where correctness can be verified with unit tests but the reasoning structure differs), logical reasoning (where step validity matters more than mathematical accuracy), scientific QA (where factual recall interacts with reasoning), or open-ended generation tasks (where correctness is subjective).
  • The PaLM 2-S model* may have specific properties—training data composition, architecture details (e.g., multi-query attention), RLHF/instruction-tuning recipe—that affect how its hidden states encode reasoning progress. The LT signals might perform differently on models with different architectures (e.g., non-transformer models, mixture-of-experts, different attention mechanisms).

What evidence exists in the paper. The paper provides no cross-model or cross-benchmark experiments. The MATH benchmark and PaLM 2-S* are the sole evaluation setting. The related work section (Section 2) cites concurrent work by Li et al. (2025) extending sequential representational analysis to mathematical reasoning, which provides some external validation, but this is mentioned only in passing and not integrated into the paper's experimental design. The appendix comparisons across models within the PaLM 2 family (the 14× larger variant) are limited to the FLOPs-matched experiment in Section 7 and do not test whether the difficulty-bin strategy transfer across model families.

Mitigation status. The limitation is unaddressed. The paper does not claim generalization beyond MATH/PaLM 2, but it also does not discuss the risk of overfitting the compute-optimal policies to this specific setting. A practitioner deploying on a different benchmark or model family would need to replicate the entire analysis pipeline—difficulty estimation, PRM training, revision model training, strategy search, and threshold calibration—with no guarantee that the qualitative patterns (easy problems → best-of-N/revisions, medium problems → beam search, hard problems → pretraining) would transfer. The paper frames its contribution as a framework and methodology rather than specific policy recommendations, which partially mitigates this concern at the conceptual level but not at the practical deployment level.

The 14×14\times larger model baseline is not compute-optimally trained, weakening the FLOPs-matched comparison

The assumption or constraint. Section 7 compares PaLM 2-S* with compute-optimal test-time scaling against a model with approximately 14× more parameters, using greedy decoding with no additional test-time compute budget. The larger model scales parameters while holding training data fixed, following the LLaMA paradigm (Touvron et al., 2023) rather than compute-optimal scaling (Hoffmann et al., 2022), where both parameters and data would be scaled proportionally. The authors explicitly note this choice:

"We choose this setting as it is representative of a canonical approach to scaling pretraining compute and leave the analysis of compute-optimal scaling of pretraining compute where the data and parameters are both scaled equally to future work."

The consequence. A Chinchilla-optimal model trained with 14× more total FLOPs—scaling both parameters and data—would likely outperform a parameter-only-scaled model given the same total compute budget. This makes the pretraining baseline weaker than it should be in a fair FLOPs-matched comparison. The reported advantages of test-time compute over pretraining (+27.8% on easy questions, +11.8% on medium questions at low R values) could shrink or potentially reverse against a stronger pretraining baseline. The paper's headline finding that "test-time compute can substitute for pretraining" is therefore conditional on the specific, non-optimal pretraining scaling strategy used. A practitioner choosing between training a larger model (compute-optimally) and deploying a smaller model with test-time compute strategies cannot directly apply these numbers—they need to know the tradeoff against an optimally-trained larger model, which is not provided.

Additionally, the larger model uses only greedy decoding with no test-time compute augmentation of its own. A fairer comparison might allocate the same total FLOPs budget to both approaches: the smaller model gets, say, beams or revision chains, but the larger model gets some modest test-time budget too (e.g., best-of-4 instead of greedy). The paper's framing treats test-time compute and pretraining compute as substitutes, but a more realistic deployment would use both—a larger model with some test-time compute. The current comparison exaggerates the relative benefit of test-time compute by comparing it against a deliberately weakened larger-model baseline.

What evidence exists in the paper. The FLOPs-matched results are in Figure 9 and the bar charts in Figure 1. The paper acknowledges the non-optimal pretraining choice in Section 7 but does not discuss how this affects the comparison's fairness. No sensitivity analysis tests how the results would change if the larger model were Chinchilla-optimally trained. The paper also does not ablate the larger model's test-time compute budget—experiments giving the larger model access to best-of-N or beam search (even with a small budget) would reveal whether the substitution claim holds when both models have access to inference-time scaling.

Mitigation status. The paper explicitly defers the compute-optimal pretraining comparison to future work. This is a reasonable scoping decision for a conference paper, but it means the Section 7 conclusions should carry an important caveat: they establish that test-time compute can outperform a naively-scaled larger model, not that it generally outperforms optimally-scaled pretraining. A reader deploying these findings in practice would need to verify against their own pretraining scaling recipe. The paper's contribution here is better understood as demonstrating the existence of a regime where test-time compute is competitive, rather than precisely characterizing the tradeoff frontier.

The revision model has a fundamental correct-to-incorrect reversion problem with no principled solution

The assumption or constraint. The revision model is fine-tuned on trajectories where all in-context answers are incorrect, followed by a correct target. At test time, the model generates a chain of revisions, meaning it may encounter its own correct answers in context (produced during earlier revision steps). The model was never trained on examples showing what to do when the current answer is already correct. The paper reports that approximately 38% of correct answers get converted back to incorrect ones during revision chains (Section 6.1).

The consequence. The revision model's core mechanism—iteratively improving answers by conditioning on previous attempts—is fundamentally unstable. Even when the model produces a correct answer at some step in the chain, subsequent revisions may "correct" it into a wrong answer with nearly 40% probability. This creates a pathological dynamic: the revision model does not know when to stop revising, because it has never been trained to recognize that an answer is already correct and should be preserved. The paper's mitigation—using majority voting or verifier-based selection across the entire revision chain (Section 6.1)—is a post-hoc patch: rather than solving the reversion problem, it simply selects the best answer from the chain after the fact, discarding the problematic revisions. This works for answer selection but does not address the underlying issue that the revision model itself does not converge monotonically. For applications where the revision chain is the desired output (e.g., self-improvement pipelines that want to iterate toward better solutions, or interactive settings where revisions are shown to users), the 38% reversion rate means the model cannot be trusted to produce monotonically improving revisions.

What evidence exists in the paper. The 38% figure is stated in Section 6.1: "approximately 38% of correct answers get converted back to incorrect ones using a naive approach." The mitigation strategies (majority voting, verifier-based selection) are evaluated in Figures 6–8, which show that the mitigation works for final-answer accuracy but do not evaluate the trajectory quality of the revision chain itself—i.e., whether revisions are monotonically improving or oscillating. The ReSTEM^{EM} experiment in Appendix K (Figure 16) provides additional evidence of fragility: attempting to further optimize the revision model with on-policy RL training caused performance to degrade substantially (fully sequential dropping to ~33.5% vs. ~38.5% at the optimal ratio), suggesting that the revision training procedure is sensitive to data distribution in ways that are not well-understood.

Mitigation status. The paper implements two workarounds for the reversion problem—majority voting and verifier-based selection across the chain—but does not solve it at the model level. Section 8 does not list fixing the reversion behavior as a direction for future work, which is a notable omission given the 38% figure. Potential solutions not explored include: (a) training the revision model on trajectories that include correct answers in context with a "stop revising" signal; (b) adding an explicit "confidence" or "done" token that the model learns to emit when it believes the current answer is correct; (c) using a separate verifier to halt the revision chain dynamically when the current answer scores above a threshold. The current design treats the reversion problem as an acceptable cost of the revision approach, mitigated at inference time through answer selection, but this limits the approach's applicability to settings where only the final answer matters, not the reasoning process itself.

Revisions and search are studied independently, and the paper provides no evidence on their combined effectiveness

The assumption or constraint. The paper studies PRM tree-search (Section 5) and iterative revisions (Section 6) as independent mechanisms with separate evaluation pipelines. Section 8 explicitly acknowledges:

"we did not experiment with PRM tree-search techniques in combination with revisions"

The consequence. The paper's central claim about complementary scaling axes—revisions modify the proposal distribution, PRM search modifies how outputs are selected—is empirically supported only for each axis in isolation. The natural synthesis—using the revision model as the proposal distribution within beam search, or using the PRM to guide which revision directions to pursue—is never tested. This leaves open the question of whether the two mechanisms are additive (combining them yields the sum of their individual gains), synergistic (combining them yields more than the sum), or redundant (their benefits overlap). The paper's finding that revisions help most on easy problems (Figure 7, right) while PRM search helps most on medium problems (Figure 3, right) suggests complementarity, but without a joint experiment, this is a hypothesis rather than a demonstrated result. A practitioner wanting to deploy the strongest possible system cannot know from this paper whether the combined approach is worth the additional complexity, or whether simply picking the better single mechanism per difficulty bin (as the compute-optimal policy already does) is sufficient.

What evidence exists in the paper. No experiment combines PRM search and revisions. The closest the paper comes is the FLOPs-matched comparison in Section 7, which evaluates PRM search and revisions separately against pretraining scaling—but these are independent comparisons, not a combined system. Section 8's acknowledgment of the gap is the only direct mention.

Mitigation status. The paper identifies this as a direction for future work (Section 8). The absence of a combined experiment is a reasonable scoping decision—each mechanism alone requires extensive experimental infrastructure (PRM training, revision model fine-tuning, difficulty estimation, strategy search), and combining them would multiply the experimental complexity. However, the paper's framing in Section 2 (proposal vs. verifier as the two axes of test-time compute) sets up an expectation that both axes will be combined, making this omission more noticeable. The current results should be understood as a lower bound on what a fully integrated system might achieve, and claims about complementarity should be treated as hypotheses awaiting experimental validation rather than demonstrated facts.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a new diagnostic modality for reasoning models—one that measures not what the model says it's doing, but how its internal representations move during reasoning. This is not a paradigm shift in the sense of a new architecture or training objective, but it is a substantive reframing of where to look for reasoning-quality signals, with practical consequences for how inference-time compute is managed.

The field's default assumptions before this work. Prior approaches to assessing reasoning quality fell into three categories, each with an implicit assumption about where the "signal" lives. Verifier-based methods (Weng et al., 2023; Zhang et al., 2024) assume the signal is in a separate model's judgment of output quality. Surface-form analysis (Wu et al., 2025; Golovneva et al., 2022) assumes the signal is in the natural-language content of the trace—the logical structure, factual consistency, and linguistic coherence of what the model writes. Output-distribution methods (Kadavath et al., 2022; Yona et al., 2022) assume the signal is in the final-token probabilities, reflecting the model's "confidence." All three share a common blind spot: they treat the model's internal computation as a black box whose outputs (text or probabilities) must be inspected to infer quality.

What this paper changes. The LT signals introduce a fourth category: signals extracted from the geometry of the model's own representational trajectory during reasoning. This is a different locus of information—not the output, but the computational path taken to produce it. The finding that these geometric signals are more reliable than output-distribution measures (ROC-AUC of 0.71–0.74 versus 0.44–0.59, Figure 3) and more consistent than cross-layer measures (standard deviation ±0.08–0.09 versus ±0.14–0.17) demonstrates that the trajectory through latent space carries information that is not fully reflected in either the surface text or the token probabilities. This matters because it suggests the model's internal dynamics encode reasoning quality in a way that is partially decoupled from its explicit outputs—a finding that aligns with and provides mechanistic grounding for recent observations that "reasoning models don't always say what they think" (Chen et al., 2025).

Reconciling prior contradictions. The paper helps resolve a tension in the literature around whether surface-level heuristics can predict reasoning quality. Length-based heuristics (Hassid et al., 2025) and output-distribution confidence measures have shown mixed results across different models and tasks—sometimes predictive, sometimes not. The LT results provide a potential explanation: these surface heuristics are weak proxies for the underlying representational dynamics. A trace that is long and has low output-probability confidence might still be correct if the internal trajectory is direct and well-aligned; a short, high-confidence trace might be wrong if the representations wandered. The fact that the Shortest@5 baseline reduces accuracy by 1.4% on average (Table 1) while LT-guided selection improves it by 2.6% confirms that surface heuristics and internal dynamics are measuring different things, and the internal dynamics are more diagnostic. This reconciles the conflicting surface-heuristic results by revealing them as noisy measurements of a more fundamental signal.

Research directions that become more attractive. The paper makes representational dynamics a first-class target for both analysis and intervention. Several lines of work become newly tractable or higher-priority:

  • Training models to produce "good" trajectories becomes a concrete optimization target. If we know what geometric properties distinguish successful from unsuccessful reasoning (large Net Change, low Cumulative Change, high Aligned Change), we can design auxiliary training objectives that encourage these properties—not just training on correctness, but training on trajectory quality.
  • Verifier-free inference-time control becomes viable. The fact that LT signals work without any trained verifier, without any external model, and without any additional forward passes means we can build lightweight, efficient selection mechanisms that don't require the infrastructure of a separate verifier pipeline.
  • Early-exit and dynamic compute allocation based on internal dynamics becomes an engineering target rather than a research question. The partial-trace results in Section 5.3 demonstrate feasibility; the remaining work is optimization and deployment engineering.

Research directions that become less attractive. Conversely, the paper's negative results should redirect effort away from certain approaches:

  • Output-distribution confidence for reasoning models. The finding that logit margin, entropy, and perplexity perform near chance (ROC-AUC 0.44–0.59) on these reasoning models strongly suggests that output-token probabilities are not a viable signal for reasoning quality in models trained to produce long chains of thought. The reasoning process decouples internal computation from final-token confidence. Research effort spent on more sophisticated output-distribution measures is likely better spent on internal signals.
  • Surface-form heuristics without representational grounding. The Shortest@5 failure (−1.4% average accuracy drop) indicates that surface-level trace properties alone are insufficient. Research combining surface features with representational signals might be productive, but surface features in isolation appear unreliable for these models.
  • Cross-layer geometry as a general-purpose reasoning-quality signal. The high variance of cross-layer baselines across models (Layer Magnitude ranging from 0.295 to 0.795 across model-dataset pairs, Table 3) suggests that cross-layer patterns are model-specific and not a robust foundation for general tools. The temporal perspective (across tokens, averaged over layers) is more consistent and should be the default starting point for future representational analysis of reasoning.

The magnitude of the shift. This is a reframing with immediate practical payoff rather than a paradigm shift. The underlying models, training procedures, and inference algorithms are unchanged. What changes is the analytical lens and the resulting inference-time policies. The practical gains—48% average token savings with 2.6% accuracy improvement—are substantial enough to change deployment practices for reasoning models today, without waiting for new training methods or architectures. The conceptual gain—understanding that reasoning quality leaves a geometric signature in latent space that is partially independent of surface outputs—opens a new analytical dimension that will likely influence how future models are studied, evaluated, and potentially trained.

Follow-Up Research This Work Enables

Training models with trajectory-level auxiliary objectives. The paper demonstrates that Net Change, Cumulative Change, and Aligned Change correlate with correctness, but it does not test whether these signals can be used as training targets. A natural experiment: add an auxiliary loss during fine-tuning that encourages the latent trajectory of correct solutions to exhibit high Net Change, low Cumulative Change, and high Aligned Change. This could be implemented as a contrastive objective where correct trajectories are pushed toward a "canonical" efficient trajectory shape, or as a regularization term that penalizes high Cumulative Change relative to Net Change. The key measurement would be whether trajectory-optimized models show improved reasoning accuracy, reduced overthinking, or more consistent internal dynamics compared to models trained only on output correctness. A strong negative result—where trajectory optimization fails to improve or even harms accuracy—would be equally informative, suggesting that the geometric properties are correlates of good reasoning rather than causes of it.

Cheap, online difficulty estimation to close the cost loop. The paper's most significant practical gap is the cost of difficulty estimation (2048 samples per question). A direct follow-up would train a lightweight classifier—potentially a small MLP or even a linear probe on top of the base model's hidden states—to predict the difficulty bin from the question encoding alone, without generating any reasoning tokens. The training data already exists: the paper has generated 2048 samples per question for the MATH test set, producing difficulty labels (pass@1 quintiles) that can serve as regression or classification targets. The key measurement: can a probe trained on question-level hidden states predict the binned pass@1 rate with sufficient accuracy that the compute-optimal policy derived from predicted bins matches the oracle policy within some tolerance (e.g., within 1–2% accuracy)? If successful, this would make the compute-optimal framework deployable without the 2048-sample overhead, directly addressing the paper's acknowledged limitation. More ambitiously, an adaptive difficulty estimator could start with a small number of samples (say, 4–8), use the PRM's average score on those samples to estimate difficulty, and dynamically adjust the remaining budget allocation—amortizing the estimation cost into the solution process. This would connect the difficulty estimation problem to the multi-armed bandit and Bayesian optimization literatures.

LT signals as a dynamic early-exit criterion during single-trace generation. The paper's inference-time experiments use LT signals either after full generation (Section 5.2) or at a fixed 2k-token checkpoint (Section 5.3). A natural extension is to use LT signals computed continuously during generation as a criterion for early stopping within a single trace—halting generation when the internal trajectory shows signs of convergence (e.g., low recent Cumulative Change, high recent Aligned Change) even if the model would otherwise continue generating. This directly addresses the "overthinking" problem the paper cites (Section 2). The experiment would measure: at what point in the reasoning trace do LT signals stabilize? Does the point of stabilization predict when the model has reached a correct answer? Can a dynamic threshold on the rolling Cumulative Change or Aligned Change trigger early stopping with minimal accuracy loss? A strong positive result would turn LT signals from a sample-selection tool into a latency-reduction tool, relevant for interactive applications where wall-clock time matters. A negative result—where LT signals stabilize before the model has actually converged on a correct answer—would be important for understanding the relationship between representational dynamics and solution quality.

Cross-scale and cross-architecture replication of the LT signal properties. The paper evaluates three models, all at ~14B parameters, all reasoning-enabled, all dense transformers. A systematic replication across model scales (1B, 7B, 14B, 70B) within a single model family (e.g., Qwen3 or Llama-3) would characterize how LT signal properties change with scale. Do larger models exhibit more directed trajectories (higher Aligned Change, lower Cumulative Change relative to Net Change)? Does the ROC-AUC of LT signals improve with scale, degrade, or stay constant? Does the relationship between Cumulative Change and accuracy strengthen or weaken? A cross-architecture replication—comparing dense transformers to mixture-of-experts models, or comparing reasoning-enabled models to standard instruction-tuned models prompted with chain-of-thought—would test whether the LT signal patterns are a general property of autoregressive transformer reasoning or specific to models explicitly trained for long-chain reasoning. A null result on standard instruction-tuned models (where LT signals fail to predict correctness) would be scientifically important, suggesting that reasoning training specifically induces the trajectory patterns the paper observes.

Combining LT signals with verifier-based methods at equivalent compute budgets. The paper positions LT signals as a cheaper alternative to verifier models but never directly compares them at equal cost. A critical experiment: take a fixed inference compute budget and allocate it either to (a) generating N samples and selecting via LT, or (b) generating M < N samples and running a verifier on each, or (c) generating M samples, computing LT signals, and running the verifier only on the top-ranked candidates. The measurement would be accuracy per unit of inference compute. Does LT selection achieve higher accuracy than verifier selection at the same total FLOPs? Is there a regime where combining LT pre-filtering with verifier verification dominates either approach alone? This experiment is important because verifiers remain the dominant approach in practice (Section 2), and the paper's value proposition depends on showing that LT signals complement or outperform verifiers, not just that they beat output-distribution heuristics.

LT signals as a reward signal for reinforcement learning. The paper demonstrates that LT signals predict correctness, but leaves open whether they can be used as a training reward. An RL fine-tuning experiment could use a combination of final-answer correctness and intermediate LT signal quality (e.g., low Cumulative Change, high Aligned Change measured on partial traces during training rollouts) as a dense reward signal. The hypothesis: providing intermediate feedback about trajectory quality (not just final correctness) enables more sample-efficient RL training and produces models with more efficient internal reasoning dynamics. The key measurements: training sample efficiency, final reasoning accuracy, and post-training trajectory properties (does Cumulative Change decrease?). A negative result—where trajectory-based rewards don't improve training or lead to reward hacking (the model learns to produce trajectories that look good geometrically but don't actually solve problems)—would be valuable for understanding whether the geometric signals are causal or merely correlational.

LT-guided dynamic compute routing in agentic systems. The paper studies LT signals in single-model, single-task settings, but they could be particularly valuable in agentic systems where a controller model decides how to allocate compute across multiple subtasks. An experiment: in a multi-step agentic benchmark (e.g., SWE-bench, WebArena), use LT signals from the agent's reasoning traces to decide whether to (a) continue with the current plan, (b) backtrack and try an alternative, or (c) escalate to a more capable model. The measurement: task success rate per unit of total inference compute, compared to fixed-allocation baselines. This extends the paper's compute-optimal allocation framework from single math problems to multi-step agentic trajectories, testing whether trajectory signals generalize to settings where "correctness" is not immediately verifiable at each step.

Practical Applications and Downstream Use Cases

Cost-efficient batch inference for reasoning-heavy workloads. Organizations that run large-scale batch inference with reasoning models—evaluating benchmarks, generating training data, or processing document collections—can deploy the sequential stopping policy (Section 5.2) today with minimal integration cost. The recipe: generate samples sequentially, compute the Combined LT score from hidden states, stop when the score exceeds a calibrated threshold, and fall back to majority voting if no sample triggers early stopping after 5 attempts. Based on the paper's results (Table 1), this reduces token consumption by approximately 50% across model-dataset combinations while maintaining or slightly improving accuracy (+2.6% average). For a deployment processing 100,000 queries per day with R1-D on scientific QA tasks, saving 50% of tokens directly halves the inference cost. The calibration requires a small held-out set of queries with known answers (to compute the threshold from incorrect-trace distributions), but no model fine-tuning, no separate verifier model, and no modification to the generation process. The LT signal computation itself is negligible—it reads hidden states already computed during generation and performs simple vector operations.

Latency-tolerant multi-sample inference with quality guarantees. In applications where latency is not the primary constraint but answer quality matters—documented report generation, automated code review, scientific analysis—LT-guided selection enables a "generate until confident" paradigm. Rather than specifying a fixed number of samples upfront, the system generates samples until the LT signal crosses a threshold corresponding to a desired confidence level. The paper's above-threshold accuracy analysis (Appendix C, Table 4) shows that accepted traces achieve very high accuracy: 91–97% on AIME2025 and 85–88% on GPQA with appropriate threshold settings. This allows practitioners to set quality targets (e.g., "I want answers that are at least 90% likely to be correct") and let the system determine how many samples are needed to achieve that target, rather than guessing a sample count and hoping. The coverage-accuracy curves (Figure 13, Appendix C) provide the calibration data to set thresholds for specific accuracy targets.

Dynamic compute allocation in parallel generation deployments. For systems that can run multiple samples in parallel (e.g., cloud deployments with batch GPU availability), the early path selection policy (Section 5.3) provides an immediate efficiency mechanism. The recipe: start 5 parallel generations, stop all at 2,000 tokens, compute partial-trace LT signals, use a lightweight classifier to select the best candidate, and complete only that candidate. Based on Table 2, this saves approximately 60% of tokens while improving accuracy by 2% on average over full 5-sample majority voting. The primary practical requirement is training the random forest classifier once per model on a calibration set—a one-time cost amortized over all future queries. This architecture is particularly well-suited for serving systems that batch user queries and have idle parallel compute capacity: the 5 partial traces can be generated simultaneously (no latency penalty), and only the selected trace runs to completion (reducing total GPU time by ~60%).

Signal-based monitoring and alerting in production reasoning systems. LT signals can serve as runtime diagnostics for deployed reasoning models without requiring ground-truth answers. If a model's reasoning traces begin showing anomalous trajectory properties—systematically higher Cumulative Change, lower Aligned Change, or lower Net Change than the calibration distribution—this could indicate model degradation, distribution shift in input queries, or emerging failure modes. A monitoring system could track the distribution of LT signals across production queries and alert when the distribution drifts significantly from the calibration baseline. This is a zero-additional-cost monitoring signal: the hidden states are already computed during generation, and the LT signals require only aggregation and tracking. The paper's distribution plots (Figures 7–9, Appendix B) provide the baseline characterization needed to set drift-detection thresholds. This application is speculative—the paper does not evaluate LT signals for drift detection—but follows naturally from the finding that LT signal distributions systematically differ between correct and incorrect traces, which implies they carry information about model health more broadly.