SEAL: Steerable Reasoning Calibration of Large Language Models for Free
Authors: Runjin Chen
Zhenyu Zhang
Junyuan Hong
Souvik Kundu
Zhangyang Wang
Venue: COLM 2025 (2025)
Keywords: LLM
Reasoning
Representation Engineering
TL;DR: We developed a training-free method that improves LLM accuracy and efficiency by calibrating CoT reasoning traces through a learned steering vector, reducing redundant thoughts and enhancing performance across multiple benchmarks.

Abstract: Large Language Models (LLMs), such as OpenAI’s o1-series have demonstrated compelling capabilities for complex reasoning tasks via the extended chain-of-thought (CoT) reasoning mechanism. However, recent studies  reveal substantial redundancy in the CoT reasoning traces, which not only increases inference latency but also negatively impacts model performance by diverting attention to unnecessary reasoning paths. To address this issue, we investigate the internal reasoning structures of LLMs and categorize them into three primary thought types: execution, reflection, and transition thoughts. Moreover, our analysis reveals that excessive reflection and transition thoughts are strongly correlated with failure cases and these thought categories exhibit clear separation in the latent space. Based on these, we introduce SEAL (**S**teerable r**EA**soning ca**L**ibration), a training-free approach that seamlessly calibrates the CoT process, improving accuracy while demonstrating significant efficiency gains. SEAL consists of an offline stage for extracting the reasoning steering vector in the latent space, followed by an on-the-fly calibration of the reasoning trace through representation intervention using the steering vector. Notably, the steering vector exhibits strong transferability across various tasks. Extensive experiments across multiple models (DeepSeek-R1-Distill and QwQ-32B-Preview) and benchmarks (Math500, GSM8K, LiveCodeBench) validate the effectiveness of SEAL,  up to a 11\% improvement in accuracy while reducing reasoning tokens by 11.8\% to 50.4\%.

Published as a conference paper at COLM 2025
SEAL: Steerable Reasoning Calibration of Large Language Models for Free
Runjin Chen Zhenyu Zhang" Junyuan Hong'
Souvik Kundu²
Zhangyang Wang'
'The University of Texas Austin, intel {chenrunjin, thenyu.zhang, jyhong, cclaasang/eutexxs..oo @utexas.edee souvikk, kundu@inee..ccoom com
Abstract
Large Language Models (LLMs), such OpenAl's ol-series have demon- strated compelling capabilities for complex reasoning tasks via the extended chain-of-thought (CoTI) reasoning mechanism. However, recent studies (Fu et al., 2024; Wang et al., 2025) reveal substantial redundancy in the CoT reasoning traces, which not only increases inference latency but also nega- tively impacts model performance by diverting attention to unnecessary reasoning paths. To address this issue, we investigate the internal reason- ing structures of LLMs and categorize them into three primary thought types: execution, reflection, and transition thoughts. Moreover, our anal- ysis reveals that excessive reflection and transition thoughts are strongly correlated with failure cases and these thought categories exhibit clear sep- aration in the latent space. Based on these, we introduce SEAL (Steerable rEAsoning caLibration), a training-fie free approach that seamlessly calibrates the CoT process, improving accuracy while demonstrating significant effi- ciency gains. SEAL consists of an offline stage for extracting the reasoning steering vector in the latent space, followed by on-the-fly calibration of the reasoning trace through representation intervention using the steering vector. Notably, the steering vector exhibits strong transferability across various tasks. Extensive experiments across multiple models (DeepSeek- R1-Distill and SWQ-32B-Preeviee LiveCodeBench) validate the effectiveness of SEAL, up to 11% improve- ment accuracy while reducing reasoning tokens by 11.8% to 50.4%. Our code is publicly available at https://g/ thub.
and benchmarks (Math500, GSM8K,
1 Introduction
Recent advancements in Large Language Models (LLMs) have demonstrated significant success in extending their capabilities beyond simple language understanding tasks to more complex reasoning tasks, such as mathematical problem-solvine Geometry, 2024; Ahn et al., 2024; Luo et al., 2023; Yuan et al., 2023), planning (Wang et al., 2023; Valmeekam et al., 2023), and code debugging (Xia al., 2024; Zhong et al., 2024). The primary factor contributing to this success is the ability of LLMs to execute an extended tfain-of-thought (Wei et al., 2022) reasoning process, which emulates human- cognitive problem-solving by dynamically scaling test-time computation. Notable examples include AlenAl's ol -eriess models(OpenAT, 2024) and its open-source counterparts (Guo et al., 2025; Team, 2024; Muennighoff et al., 2025). These models are designed to explore diverse reasoning strategies, reflect on their decisions, iteratively refine solutions, and rigorously verify correctness- closely emulating human cognitive processes.
(AlphaProof Alpha-
However, such an extended reasoning process introduces significant inference overhead due to the auto-regressive nature of LLMs. The generation process is typically memory-bound, with the KV cache size growing linearly with sequence length, leading to increasingly expen- sive memory transfer latency and further exacerbating inference inefficiencies. Moreover, lengthy reasoning is not always necessary. Studies have shown that LLMs often determine
"qqual contribution.

---

Published as a conference paper at COLM 2025
the correct final answer early in the reasoning process but continue generating excessive and redundant thought sequences (Fu et al., 2024). Such inefficient long responses can even degrade final performance, tion loops (Chen et al., 2024) or suffer from underthinking due to unnecessary reasoning detours (Wang et al., 2025).
models may become trapped in redundant verifica-
Can we identify and calibrate the flawed reasoning pathways in current LLMs? In this paper, we first decompose the entire reasoning process into a structured sequence of consecutive thoughts and categorize them into three types: (i) execution thoughts, (ii) reflection thoughts, and (iii) transition thoughts. Our analysis reveals that LLMs allocate significantly more thoughts to samples where they fail to produce the correct answer. We further analyze the conceptual representations of each thought type and observe that they are highly distinguishable in the latent space of deep layers. Building on this analysis, we propose SEAL (Steerable rEAsoning caLibration), a training-free free approach calibrate reasoning paths, achieving win-win of both efficiency and capability. With SEAL, we first perform an offline extraction of the reasoning steering vector in the latent space using small subset of the training data (around one hundred samples). Then, during inference, dynamically adjust the hidden states through arithmetic operations with the steering vector, enabling efficient reasoning calibration.
Our key contributions are as follows: (i) We systematically study the reasoning process of 01 O1/Ri- LLMs and identify three distinct types of thoughts that compose the overall rea- soning flow. Further, our analysis reveals that these thought types are highly distinguishable in the latent space; (ii) We propose training-fres strategy, SEAL, that effectively calibrates the reasoning process, reducing token consumption per question while simultaneously improving accuracy. (iii) Extensive experiments across diverse models (DeepSeek-RI-Dise and (OQQ-32--Preview) and various challenging benchmarks (such as Math500, GSM8K, L Live demonstrate that SEAL achieves consistent accuracy improvement by up to 11 ,, along with 11.8% to 50.4% token savings.
2 Recognizing Reasoning Patterns in LLMs
Question
In how many ways can people around round table no two of people Pierre, Rosa, and Thomas can sit next to euch other' (Seating arrangements which are rotations of each other are trented as the same.)
Response
Okny, so problem where need figure out many ways people around
with a condition: Pierre, Rosa, and T Thomss can't sit next to each other. Hmm, circulur permotations can be triky, but lot me try to break down slep by step.
Finst, remember for considered the same, So, for ? people, it would normally be 6 720 ways. But here, we have restrictions, so need to subtract the cases where Pierre Ross, and Thomas are silling next each other.
permutations, number ways arrango people around round table
because rotations are
In this case, the sets would the arrangements where least Pierre, Ross, and Thomas sitting next each other. So, need calculate arangements where then add back in the cases where all tiree are sitting together because they were subtracted too many times.
lotal number urangemennts wilhoul any restriction,
then silling logetheer
Alternaively, aoother approach is to fins arrange the non-restricted people might be more strigghforward method.
Pietre,
Thomas the gaps between That
So, petting all together, total number of arrangements the number of ways arrange the 4 people multiplied number of ways place Piere, Ross, and Thomas the gaps. That
144
Wail, but
answer? Let double-check.
Wait, no, hocmuse when we fix one penson to eliminate cotational symmery, we might have avercounted or undereounted something. et me think.
Execution Thoughts
Reflection Thoughts
Transition Thoughts
Figure 1: One example from DeepSeek-RI-Distill-weens for math question, where the entire response is divided into individual thought blocks.
2

---

Published as a conference paper at COLM 2025
We begin with preliminary study on the reasoning patterns of Ol-like LLMs that em- ploy extended chain-of-thought (CoT) reasoning processes. To analyze the fine-grained reasoning steps, we observed that the model often uses "\n'n" to separate distinct steps in its responses. Therefore, we decompose the generated output O into a sequence of interconnected thoughts, segmenting each thought using two line break symbols, such that O T2,,T,,.,, T.). Our experiments demonstrate that different thoughts can be catego- rized into distinct types, each exhibiting unique roles within the reasoning process. Figure illustrates representative example for math question using DeepSeek- CeepSeek-R1-Distinee RI-Distill-Qwen-/ We identify three types of thoughts: (i) Execution thoughts, where the model analyzes the problem and solves it step by step; (ii) Reflecting thoughts, where the model pauses the reasoning process to verify its steps; and (iii) Transition thoughts, where the model shifts its reasoning flow and rethink the problem from different perspective.
Considering the statistical properties of various thoughts throughout the reason- ing process, we present the results in Fig- ure 2. Firstly, the task difficulty in- creases, the model generates longer re- sponses for correctly answering the ques- tions, with the average token budget ex- panding from 1,534 to 3,323. This trend aligns with intuition, as more complex questions necessitate greater reasoning efforts for resolution, leading to longer response sequences. However, for sam- ples of the same difficulty level, the num- ber of thoughts in incorrect samples significantly higher than in correct ones, with each type of thought exhibiting more steps in incorrect cases. Given that the dif- ficulty of correct and incorrect samples is comparable, these results suggest that such excessive reasoning steps introduce reasoning process and may negatively impact performance.
Esccution
Reflection
Carreeti A Tokee 1534
Incorvent: Tekes
Diffieult Level
Incerrect: 'Takknn -933
3
Cerrect: T'Tkko 2009
Incorretti il Telon - 9611
Cornec: & Taken 2015
Incereet: Tikke 9247
Conrect: Takes 3323
Incerrett:
9297
# TToughts
Figure 2: Statistics on the number of different types of thoughts for subsets of samples that the model answered correctly and incorrectly. The results are derived from DeepSeek-R1-Dise Qwen-1.5B on the the Math-500 task. Response lengths are reported numerically.
significant redundancy beyond the necessary
Additionally, the increase in thoughts for incorrect samples is largely driven by rise in reflection and transition thoughts, as each reflection or transition step typically followed by several execution steps. As shown in Figure 9, this pattern aligns with recent studies, such as Chen al. (2024), which demonstrate that allocating excessive reasoning steps to simple questions is ineffective. Similarly, Fu et al. (2024) finds that models often identify the correct answer early in the reasoning process but continue with redundant reasoning steps. Wang et al. (2025) argues that frequent transition thoughts disrupt the continuity of reasoning, leading to underthinking and performance degradation. Inspired by these studies, summarize two major flaws in current O1-like reasoning process: (i) Efficiency: Frequent reflection and transition thoughts consume a significant token budget, introducing substantial efficiency overhead. Given that LLMs rely on auto-regressive generation and require increasing KV cache storage for long-contex processing, excessive reasoning steps impose considerable cost for computation and memory transfer. (ii) Effectiveness:: Reflec- tion and transition thoughts can lead to either overthinking or underthinking, diverting the model from the essential reasoning path. This distraction results suboptimal performance, as the model fails to focus on the most direct and necessary reasoning steps.
In the following section, we aim to analyze the roles of different thoughts in the latent space and explore a controllable approach to mitigate redundant reflection and transition thoughts, thereby enhancing both the efficiency and effectiveness of the reasoning process.
3

---

Published as a conference paper at COLM 2025
3 Different Reasoning Patterns are Distinguishable in the Latent Space
To analyze the underlying mechanisms of different reasoning patterns, one challenge lies in the diversity of tokens present in various thoughts within the same category. Specifically, for all thoughts classified as reflection thoughts, the specific tokens in each instance exhibit substantial variation, as they are closely tied to the particular details of the question, as illustrated in Figure 1. This variability complicates detailed analysis. Meanwhile, trans- former models process input sequences layer-wise manner, with representations at each layer capturing and accumulating conceptual knowledge rather than token-specific content. These latent space representations offer a meaningful way to understand reasoning dynam- ics. Thus, we conduct a preliminary study to analyze how different reasoning patterns are structured within the latent space.
Layer:
Layer: 5
Layer: 10
Layer:
Layer: 20
Layer: 28
Reflection Thoughts
Transition Thoughts
Execution Thoughts
Figure 3: Results of t-SNE visualization of different reasoning thoughts in the latent space.
Experiments are conducted using DeepSeek-R--Disill---eeee the Math-500 (Lightman et al., 2023) task. We first execute the general inference process and collect the representations H; corresponding to the "\n\ n" of each thought in layer i. These representations encapsulate the entire information of each thought and determine the initial token of the subsequent thought, making them a strong indicator for analyzing the conceptual behavior of different thoughts. We then apply T-distributed Stochastic Neighbor Embedding (t-SNE) (Van der Maaten & Hinton, 2008) to project Hi into two- dimensional space. The results are presented in Figure 3, reveal several key observations: (i) Execution thoughts are clearly separable from non-execution thoughts (i.e., reflection and transition thoughts) in the latent space. For example, at Layer 20, execution thoughts exhibit almost overlap with other types of thoughts. (ii) The separability of different thought is significantly better in deep layers, whereas the initial layers struggle to distinguish them. This aligns with the expectation that shallow layers primarily capture low-level features, while deeper layers encode more abstract conceptual and semantic knowledge (Liu et al., 2024; Jin al., 2024). (iii) Reflection and transition thoughts are more similar each other than to execution thoughts. Intuitively, both reflection and transition thoughts involve reconsidering or modifying previous reasoning steps, whereas execution thoughts represent the original step-by-step reasoning process. Based on these experiments, different reasoning patterns are qualitatively distinguishable in the latent space.
(Guo et al., 2025) on
4 Steerable Reasoning Calibration
Based on our preliminary investigation, we propose SEAL, a training-free framework designed to achieve Steerable rEAsoning caLibration. As illustrated in Figure 4, SEAL comprises two stages: the off-the-shelf extraction of the reasoning steering vector and the on-the-fly intervention in the latent space during decoding. The core insight behind SEAL is to identify the steering vector that controls the ratio of reflection and transition thoughts. And use that vector to effectively reduce redundant token usage, achieving win-win of efficiency and accuracy.
4.1 Extraction of Reasoning Steering Vector
Collecting Reasoning Processing. We begin by using a validation set comprising samples from reasoning benchmarks. In experiments, we by default to use a selected set of
4

---

Published as a conference paper at COLM 2025
Execution Thoughts
Output Represemations
Reflection Vector
Extract Reasoning Steering Vector
H
Reflection Thoughts
MLP
R
Execution
Transition Thoughts
Attention
Reasoning Stearing Vector
H
Collect Reasoning
Processing
Input Representctions
Transition Vector
Vonilla Decoding (Token Cost: 5K)
Execution Reflection
Execution
Transition
Execution
Transition
woth offer?
Execution
Reflection
Exeecttio
Final Arower
Question
Decoding with Reasoning Steering Vector (Token Cost: 2k)
Reasoning Calibration
Execution
Reflection
Execution
Final Answer
Figure 4: Overview of our SEAL framework. The upper subfigure illustrates the offline extraction process of the reasoning steering vector, while the lower subfigure depicts the inference process utilizing the extracted steering vector.
1000 training samples from the training set of the Math (Hendrycks et al., 2021) dataset and performed inference using the target model, such as DeepSeek-R1-De R1-Distill- -eistill--Qe--7B,, to generate the whole reasoning process for each sample. Similar Section 3, we segmented the reasoning process into set of individual thoughts using a line-breaker symbol. Each thought was then categorized into one of three predefined classes: execution, reflection, or transition thoughts. The classification was performed through keyword identification. For example, if thought contained keywords like Alternnttively, it was categorized as transition thought. The complete list of keywords used to classify transition and reflection thoughts is provided in Appendix B. Any remaining thoughts were classified as execution thoughts.
Calculating Steering Vector. For each thought j, we extract the output representations from the 1th transformer blocks corresponding the first token " "\n)""", denoted as H/, We then compute the average representations for each thought category:
HC
1
Σ ΣH!, CE (Execution, Reflection U Transition] jEC
Nc
Based on the results in Section 2, the primary objective of SEAL is to mitigate unnecessary reflection and transition thoughts while preserving essential execution thoughts. To achieve this, we compute the reasoning steering vector S as the arithmetic combination of different thought vectors, i.e.,
= H HgT H
Decoding with Latent Space Intervention
We then perform on-the-fly calibration of the reasoning process using the reasoning steering vector S. Specifically, during the decoding process, at the end of each thought, we intervene in the representations of all (n' tokens by applying an offset derived from S, formulated as: = H + a S, where a is a hyperparameter controlling the strength the intervention. Since the extraction process conducted offline, it does not introduce any additional latency

---

Published as a conference paper at COLM 2025
overhead during decoding. Furthermore, the computational cost of latent space intervention negligible, compared with the original forward pass.
For hyperparameter selection, conduct series of ablation studies in Section 5.3.1 and, by default, set a 1.0 and the intervention layer as 20 for Deepseek-Rl-Distill -is---iiiiillll-----lll -.eell..e and Seopseeek-R-isstiii -i--issill----en--T 55 for
Preview. Additionally, validation set used for extracting the steering vector generalizes well across different tasks, such transferring from mathematical reasoning to code generation. Further results are provided in Section 5.2.1
find that the
Experiments
5.1 General Setup
We evaluate the effectiveness of our SEAL with several popular reasoning models, including Khepssek-RI-disttll---eeer
(Guo al., 2025) and QwQ- 32B-Preview (Team, 2024; Yang et al., 2024a). And we conduct the experiments on four datsets: (i) Math500 (Hendrycks al., 2021): A challenging math dataset comprising problems from high school math competitions. We adopt subset of 500 problems selected by OpenAl'
test set. Additionally, the Math dataset categorizes problems by difficulty on a scale from 1 to We designate the subset of 500 problems with difficulty levels or 5 the hard test set. (ii) GSM8k Cobbe et al. (2021): A dataset of high-quallis problems at the grade school math level. This dataset exhibits high linguistic diversity while relying on relatively simple grade school math concepts. The test set consists of 1,319 problems. (iii) LiveCode Jain et al. (2024): A dataset containing 400 Python coding problems released between May 2023 and March 2024, each accompanied by set of test samples for verifying program correctness.
5.2 End-to-End Results
Table 1: Comparison results on the Math500 task. The reasoning steering vector of SEAL is derived from a subset of training samples from the Math500 task.
Math-500
Math-500 (Hard)
Methods
Accuracy@1 (1)
#Tokens (4)
Accuracy@1 (1) #Tokens (L)
67.0
4526
54.2
5737
Logits PenallyTransition
68.2 (+1.2)
3660
55.7 (+1.5)
4766
Logits Penalty Reflection
75.0 (+8.0)
4416
65.3 (+11.1)
5644
Logits VenaltyBoth
76.6 (+9.6)
3340
63.7 (+9.5)
4552
30.
SEAL
78.0 (+11.0)
3154
68.3 (+14.1)
4086
Deepseek-N R1 Distill-Qwend
85.8
3389
79.8
4176
Logits Penalty Transition
86.2 (+0.4)
3264
79.4 (-0.4)
4108
Logits Penalty Reflection
88.2 (+2.4)
2905
81.7 (+1.9)
3773
Logits PenaltyBoth
87.4 (+1.6)
2807
80.9 (+1.1)
3596
SEAL
89.4 (+3.6)
2661
84.0 (+4.2)
3365
3-BB-Previeww
90.4
2113
86.6
2793
Logits renssty'ransition
90.2 (-0.2)
2115
85.5 (-1.1)
2820
Logits Penalty Reflection
88.8 (-1.6)
2104
84.0 (-2.6)
2778
we
Logits PenaltyBoth
89.4 (-1.0)
1966
83.2 (-3.4)
2681
SEAL
91.0 (+0.6)
1716
85.5 (-1.1)
2323

---

Published as a conference paper at COLM 2025
Table 2: Generalization results of SEAL across different datasets. The reasoning steering
vector is obtained from a subset of training samples from the Math500 task.
GSMSK
LivecodeBench
Methods
Accuracy@1 (1)
#Tokens (J)
Accuracy@1 (1)
#Tokens (J)
Deepseek-RI-Distill--eene
74.1
2015
18.5
8205
Logits Penalty Transition
75.2 (+1.1)
1862
16.8 (-1.7)
8180
Logits PenallyReflection Reflection
78.5 (+4.4)
1214
26.0 (+7.5)
7160
Logits Bent
78.3 (+4.2)
1100
25.8 (+7.3)
7050
SEAL
82.0 (+7.9)
999
28.5 (+10.0)
6923
Deepseek-RV RI- --Disiill-Wenn
88.0
1142
44.5
6856
Logits PenaltyTransitionn
88.6 (+0.6)
1058
45.8 (+1.3)
6697
Logits Reffettyeolection
87.9 (-0.1)
904
44.0 (-0.5)
6166
30.
Logits PenaltyBoth
88.6 (+0.6)
885
46.3 (+1.8)
6065
SEAL
88.4 (+0.4)
811
51.7 (+7.2)
5974
M-Q--3B--Preieeee
95.4
698
62.5
6016
Logits Penally'ransiten
Iransition
95.1 (-0.3)
657
63.5(+1.0)
5856
Logits FenaltyReflection
95.8 (+0.4)
664
63.0 (+0.5)
5847
w0.
Logits PenaltyBoth
95.0(-0.4)
644
63.0(+0.5)
5847
SEAL
95.7 (+0.3)
525
63.5 (+1.0)
5309
5.2.1
Baseline and Evaluation Metrics.
We compare SEAL with another training-fre free method, namely logits penalty Wang et al. (2025). Following their setup, we reduce the logits of tokens associated with characteristic reflection transition words, such 'wait' and 'alternatively." The adjustment values were selected from {-1, -3, -10, -20), with -3 generally yielding the best results. For each task, we report both the average accuracy and token count across the test set to assess the effectiveness and efficiency of SEAL. To ensure reproducibility, we use greedy search during decoding. Results using sampling are additionally reported in the appendix E.
5.2.2 Main Results.
SEAL demonstrates superior performance and signifi- cant efficiency gains. As shown in Table and 2, across diverse models and tasks, SEAL not only improves accu- racy but also reduces response length, enhancing reason- ing efficiency. For example, SEAL enhances performance by up 14.1% in accuracy while reducing token usage by 28.8% on hard problems in the Math-500 benchmark. This improvement stems from the model's ability to avoid ex-
Deepscek -isttill-wwenl.....
1400
Bass
w: Logi Penalty
1200
w. Ours
Thoughhs
1000
cessive rechecking and minimize unnecessary transition thoughts after steering, leading to a more direct path to the final answer. More results sequence length com- parisons can be found in Appendix F. Additionally, SEAL prevents the model from becoming trapped an endless cycle of rechecking and switching, further optimizing the reasoning process.
400
O.O.D. Reflecting
O.O.D. Transiiinn
Figure 5: Logits Penalty makes other reflection and transition thoughts increase
The reasoning steering vector exhibits high transferabil- ity across different tasks. We applied the steering vector extracted from the MATH dataset to GSM8K oout-of-distribution samples within the same domain) as well as LiveCodeBench (transferring to a different domain). SEAL consistently enhanced both performance and efficiency across all datasets (As shown in Table 2), with accuracy improvements ranging from 0.3% to 10.0%, while reducing token usage by up to 50.4%. This indicates that the underlying patterns of rechecking and switching thoughts
7

---

Published as a conference paper at COLM 2025
generalizable across different tasks and domains. Consequently, our method can be effec- tively applied to new domains without incurring the additional computational overhead of extracting new steering vector for each task.
Latent space calibration is more effective than token-space adjustment. One limitation of the Logit Penalty (i..,, token-space adjustment) method is that it typically operates such individual tokens, such as alternatively or wait, rather than adjusting at the conceptual level. However, reflection and transition thoughts are often conveyed through phrases or longer sentences, such as let me double-check or another approach is. These cases are difficult to suppress using Logit Penalty alone. Furthermore, we observed that even after lowering the logits of representative tokens for these thoughts, the model still exhibited tendency toward reflection and transition-albe expressions. To quantify this effect, we measured the number of reworded reflection and transition steps. As shown in Figure 5, logit penalty led to an increase such steps. In contrast, our steering method suppresses the entire reflection/ Inlectiion/taasiitinn /ransiiioon concept rather than just specific tokens. As a result, these steps were significantly reduced, demonstrating that steering is stronger and more effective approach than logit penalty.
in more implicit manner, through rephrased
5.2.3 Quantitative Evaluation of Efficiency
Table 3: End-to-end efficiency comparison on the Math500 task benchmark. RD denotes the relative reduction ratio compared to the baseline method. Both the average and maximum reduction ratios are reported.
Throughput (#ooken/ second)
#Tokens/ /Sampee Max. RD (%)
Time/Sample 'ammle (second)
Models
Aug. RD
Avg.
Avg. RD (%)
Max. RD (%)
Avg.
Deepseek Siepaeek----istill---eeeeae Qwen-1.58
41.4
N/A
N/A
4666.9
N/A
N/A
112.7
SEAL
43,5
34.00
80.46
3047.7
37.89
83.65
20.0
Deepoeek Ri--ii--il---eeee-- a. SEAL
37.2
N/A
N/A
3522.1
N/A
N/A
94.6
39.5
28.78
81.26
2508.6
32.88
86.61
63.5
We report the end-to-end efficiency results Table 3 using 50 random samples in Math500 benchmark. Without loss of generality, our implementation is based on the Hugging Face Library with BF16 precision. Throughput and time cost are measured on a single NVIDIA GH200 GPU without offloading. Our observations indicate that the additional computation introduced by adding the steering vector is negligible. SEAL even achieves slight improvement throughput (i.e,, approximately tokens per second) by eliminating the overhead of KV cache in extremely long sequences. Additionally, SEAL significantly reduces token consumption in responses, resulting in an average reduction in response time per query by 32.9% to 97.9% Notably, the most improved sample achieves reduction of 83.65% to 86.61%. These results further substantiate the efficiency gains and practical advantages attained through our approach.
5.3 Ablation Study
In this section, we present ab- lation studies on the effects of
applying the steering opera- tion across different reasoning types, layers, and strengths.
Table 4: Ablation study of steering type. Experiments are conducted with
Method
Math500
CSM8K
LiveCodeBench
Baseline
85.8
88.0
44.5
5.3.1 Ablation
SEAL (weakening Reflection)
88.6
88.4
50.7
Study about the Steering Type
SEAL (weakening Transition)
87.8
88.5
49.0
SEAL (weakening Execution)
65.0
79.6
27.5
Table 4 presents the results of steering different reason- ing types. We observe that weakening execution thoughts leads to performance degrada- tion, execution plays crucial role in the reasoning process. In contrast, reducing the
SFAL.
89.4
88.9
51.7
8

---

Published as a conference paper at COLM 2025
influence of reflection and transition thoughts individually can still enhance performance. Moreover, enabling the steering vector to weaken both reflection and transition yields the most significant improvements. Consequently, the optimal reasoning formulation is given by S Hg HgT-
5.3.2 Ablation Study about the Steering Layer
4200 ?
-906
4990
1758
3900
10
25
26
15
15 Steniigg
10
15
25
Sterring
Steninn Layer
Figure 6: Ablation study of the steering layers. Zoom in for better visualization.
In this section, aim to identify the optimal layer for steering. We extract reasoning steering vectors from different layers and apply corresponding steering to evaluate their effectiveness. The results, shown in Figure 6, indicate that mid-to-late layers yields the best performance, and the optimal layer shows strong generalization across different model and tasks. This aligns with the typical forward pass dynamics of LLMs: early layers focus pri- marily on token-level representations, while middle layers progressively merge information across tokens to form higher-level concepts Liu et al. (2024); Jin et al. (2024). In contrast, the final layers primarily summarize context to predict the next token. Consequently, concept-level steering tends to be more effective in the middle layers.
5.3.3
Ablation Study about the Steering Strength
Deepoekk Ovess
Drepors
JrnoskBBend, Deguock
Owmi
Dopperk Datl
15.6-
2 12
27.5
25.0-
125
22.5
2 T1.
200
815
15.
C t
055
Figure 7: Ablation study of the steering strength. Zoom in for better visualization.
We further investigate the effect of steering strength on the final outcomes, with results presented in Figure 7. Our findings show that applying the reasoning steering vector ef- fectively reduces reflection and transition thoughts. However, minimizing these thoughts does not always yield better performance. This suggests that a balanced number of reflec- tion and transition steps can be beneficial for arriving at the correct final answer. In our experiments, a steering coefficient of a 1.0 consistently demonstrated strong performance across various tasks, and we maintained this setting throughout all our experiments.
6 Conclusion
In this paper, we investigate the internal reasoning dynamics of large language models (LLMs), revealing that excessive engagement in reflection and transition thoughts often introduces inefficiencies and errors during extended chain-of-thought reasoning. By catego- rizing reasoning steps into execution, reflection, and transition components, we show that these types exhibit clear and consistent separability within the latent space. This insight enables more precise control over the reasoning process. Leveraging this observation, we propose SEAL, lightweight, training-fres method that calibrates representations to steer reasoning trajectories. Specifically, SEAL adjusts hidden states on the fly using a precom- puted steering vector, effectively promoting execution while mitigating the influence of

---

Published as a conference paper at COLM 2025
less productive thoughts. Our approach improves both reasoning efficiency and accuracy without requiring model fine-tuning or architectural modifications. Experimental results across various LLMs and benchmarks confirm the robustness and generality of SEAL. not only reduces inference time but also consistently enhances performance, offering a practical and interpretable solution for optimizing reasoning in language models.
Acknowledgment
Z. Wang is in part supported by NSF Awards 2523383 (AlMing), the NSF AI Institute for Foundations of Machine Learning (IFML), and an Intel single PI SRS gift funding.
References
Janice Ahn, Rishu Verma, Renze Lou, Di Liu, Rui Zhang, and Wenpeng Yin. Large lan- guage models for mathematical reasoning: Progresses and challenges. arXiv preprint ar arXim:242..01157, 2024.
Team AlphaProof and Team AlphaGeometry. Ai achieves silver-medal standard solving international 178 mathematical olympiad problems. DeepMind blog, 179:45, 2024.
Lingjiao Chen, Jared Quincy Davis, Boris Hanin, Peter Bailis, Ton Stoica, Matei A Zaharia, and James Y Zou. Are more Ilm calls all you need? towards the scaling properties of compound ai systems. Advances in Neural Information Processing Systems, 37:45767-45790, 2025.
Xingyu Chen, Jiahao Xu, Tian Liang, Zhiwei He, Jianhui Pang, Dian Yu, Linfeng Song, Qiuzhi Liu, Mengfei Zhou, Zhuosheng Zhang, et al. Do not think that much for 2+ 3=? the overthinking of ol-like llms. ar preprint ar xrXi::2412221187, 2024.
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers solve math word problems. arXiv preprint arXiv::110.14166 2021.
Yichao Fu, Junda Chen, Siqi Zhu, Zheyu Fu, Zhongdongming Dai, Aurick Qiao, and Hao Zhang. Efficiently serving Ilm reasoning programs with certaindex. ar preprint arXiv:2412.20993, 2024.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in llms via reinforcement learning, ar preprint Xix:22001.12444 2025.
Shibo Hao, Sainbayar Sukhbaatar, Dijia Su, Xian Li, Zhiting Hu, Jason Weston, and Yuan- dong Tian. Training large language models to reason in a continuous latent space. ar preprint wiv:2211.06777 2024.
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset. In Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track (Round 2), 2021.
Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Ar- mando Solar-Lezama, Koushik Sen, and Ion Stoica. Livecodebench: Holistic and contami- nation free evaluation of large language models for code. arXiv preprint ar #rXiv:2433.09974 2024.
Mingyu Jin, Qinkai Yu, Jingyuan Huang, Qingcheng Zeng, Zhenting Wang, Wenyue Hua, Haiyan Zhao, Kai Mei, Yanda Meng, Kaize Ding, et al. Exploring concept depth: How large language models acquire knowledge and concept at different layers? arXiv preprint ar 070066440.07066, 2024.
10

---

Published as a conference paper at COLM 2025
Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, llya Sutskever, and Karl Cobbe. Let's verify step by step. In The Twelfth International Conference on Learning Representations, 2023.
Zhu Liu, Cunliang Kong, Ying Liu, and Maosong Sun. Fantastic semantics and where to find them: Investigating which layers of generative lims reflect lexical semantics. arviv preprint Xix::2403.005000 2024.
Haipeng Luo, Qingfeng Sun, Can Xu, Pu Zhao, Jianguang Lou, Chongyang Tao, Xiubo Geng, Qingwei Lin, Shifeng Chen, and Dongmei Zhang. Wizardmath: Empowering mathematical reasoning for large language models via reinforced evol-instruct. arXiv preprint ar Xix:2308. 09580,, 2023.
Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, and Tatsunori Hashimoto. sl: Simple test-time scaling. Xiv preprint ar arXiv22011113993 2025.
OpenAl. Learning to Reason with LLMs, 2024. URL https://openai..com/ /ndex/ learning-to-reasonn- warpoonwwithhllae th-1lms.
Yuval Shalev, Amir Feder, and Ariel Goldstein. Distributional reasoning in Ilms: Parallel reasoning processes in multi-hop reasoning. arviv preprint arXiv:2406. 13858, 2024.
Jihoon Tack, Jack Lanchantin, Jane Yu, Andrew Cohen, Ilia Kulikov, Janice Lan, Shibo Hao, Yuandong Tian, Jason Weston, and Xian Li. Llm pretraining with continuous concepts. arv preprint ar arXiv:2502.08524 2025.
Qwen Team. Qwq: Reflect deeply on the boundaries of the unknown, unknown, November 2024. URL https://qwenlmm gi github. ho/blog/qwq-- -ere--2b--pperr prbbprreiiww...
Karthik Valmeekam, Matthew Marquez, Sarath Sreedharan, and Subbarao Kambhampati. On the planning abilities of large language models-a critical investigation. Advances in Neural Information Processing Systems, 36:75993-76005, 2023.
Laurens Van der Maaten and Geoffrey Hinton. Visualizing data using t-sne. Journal of
machine learning research, 9(11), 2008
Yue Wang, Qiuzhi Liu, Jiahao Xu, Tian Liang, Xingyu Chen, Zhiwei He, Linfeng Song, Dian Yu, Juntao Li, Zhuosheng Zhang, et al. Thoughts are all over the place: On the underthinking of ol-like 1lms. Xiv preprint ar XXio:2501.18885, 2025.
Zihao Wang, Shaofei Cai, Guanzhou Chen, Anji Liu, Xiaojian Ma, and Yitao Liang. Describe, explain, plan and select: Interactive planning with large language models enables open- world multi-task agents. arviv preprint ar xrXio:2302.0156/ 2023.
Jan Wehner, Sahar Abdelnabi, Daniel Tan, David Krueger, and Mario Fritz. Taxonomy, opportunities, and challenges of representation engineering for large language models. Xiv preprint ar 1964: 2025.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824-24833 2022.
Zhengxuan Wu, Aryaman Arora, Atticus Geiger, Zheng Wang, Jing Huang, Dan Jurafsky, Christopher D Manning, and Christopher Potts. Axbench: Steering llms? even simple baselines outperform sparse autoencoders. ar arviv preprint ar XxXo:2200..1714. 2025.
Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. Agentless: Demysti- fying llmed software engineering agents. Xiv preprint arXiv:2407.00 0849,, 2024.
11

---

Published as a conference paper at COLM 2025
An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jialong Tang, Jialin Wang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Ma, Jin Xu, Jingren Zhou, Jinze Bai, Jinzheng He, Junyang Lin, Kai Dang, Keming Lu, Kegin Chen, Kexin Yang, Mei Li, Mingfeng Xue, Na Ni, Pei Zhang, Peng Wang, Ru Peng, Rui Men, Ruize Gao, Runji Lin, Shijie Wang, Shuai Bai, Sinan Tan, Tianhang Zhu, Tianhao Li, Tianyu Liu, Wenbin Ge, Xiaodong Deng, Xiaohuan Zhou, Xingzhang Ren, Xinyu Zhang, Xipin Wei, Xuancheng Ren, Yang Fan, Yang Yao, Yichang Zhang, Yu Wan, Yunfei Chu, Yuqiong Liu, Zeyu Cui, Zhenru Zhang, and Zhihao Fan. Qwen2 technical report. ar preprint ar arXft:2407.10671, 2024a.
Sohee Yang, Elena Gribovskaya, Nora Kassner, Mor Geva, and Sebastian Riedel. Do large language models latently perform multi-hop reasoning? arXiv preprint ar arXio:2402.16837 2024b.
Zheng Yuan, Hongyi Yuan, Chengpeng Li, Guanting Dong, Keming Lu, Chuanqi Tan, Chang Zhou, and Jingren Zhou. Scaling relationship on learning mathematical reasoning with large language models. arXiv preprint ar arXiv:2308.01825, 2023.
Huaixiu Steven Zheng, Swaroop Mishra, Hugh Zhang, Xinyun Chen, Minmin Chen, Azade Nova, Le Hou, Heng-Tze Cheng. Quoc V Le, Ed H Chi, et al. Natural plan: Benchmarking Ilms on natural language planning. arviv preprint arXiv:2406.044500 2024.
Li Zhong, Zilong Wang, and Jingbo Shang. Debug like a human: A large language model debugger via verifying runtime execution step-by-step. arXiv preprint ar 2r:::24002.16906 2024.
Andy Zou, Long Phan, Sarah Chen, James Campbell, Phillip Guo, Richard Ren, Alexan- der Pan, Xuwang Yin, Mantas Mazeika, Ann-Kathrin Dombrowski, et al. Represen- tation engineering: A top-down approach to ai transparency, 2023. URL https://arxiu. org/abs/2310.014055.
12

---

Published as a conference paper at COLM 2025
A Related Works
Reasoning in Latent Space. Some studies have found that LLMs inherently perform latent reasoning within their hidden computations Yang et al. (2024b); Shalev et al. (2024); Hao et al. (2024); Tack al. (2025). Yang et al. (2024b) explores reasoning paths in multi- hop reasoning tasks and finds that intermediate entities can be recovered from latent representations. Shalev et al. (2024) shows that multiple parallel latent reasoning paths may exist in the middle layers. Collectively, these works demonstrate that LLMs naturally engage in reasoning within their internal latent representations, embedding reasoning concepts and cues. Additionally, several approaches have sought to further enhance and refine reasoning within the latent space of existing models Tack et al. (2025); Hao et al. (2024). These efforts collectively inspire further advancements in optimizing reasoning paths at the level of latent representations.
Under-thinking and Overthinking. Several studies have shown that current O1-like models exhibit both overthinking and underthinking issues in their reasoning paths Chen et al. (2024; 2025); Wang et al. (2025); Fu et al. (2024). Overthinking, (2024), refers to allocating excessive computational resources to simple questions with minimal performance gains. Fu al. (2024) further reveals that LLMs often determine the correct final answer early in the reasoning process but continue generating excessive and redundant thought sequences. Conversely, underthinking, as described Wang et al. (2025), occurs when models frequently switch between thoughts without sufficiently exploring promising reasoning paths to reach a correct solution. Our work aims to identify these flawed reasoning patterns within the latent space and apply steering techniques to mitigate them.
discussed in Chen et al.
Representation Engineering (RepE). RepE Zou et al.; Wehner et al. (2025); Wu et al. (2025) places the model's latent representations at the core analysis, identifying target concepts within these representations and steering them to control model behavior. These methods offer advantages such as efficiency, flexibility, and strong interpretability. Inspired by RepE, our work adopts similar approach to mitigate flawed reasoning patterns in the model's reasoning path.
B Criteria for Recognizing Reflection, Transition, and Execution Thought
B.1 Criteria for different thoughts
Table 5: Criteria for recognizing reflection, transition, and execution thoughts
Prefix:
Alternatively
think differenly, another way, another ap- proach, another method, another solution, another strategy, another technique
Phrase:
Transition
Prefix: Wait
Reflection
Phrase:
verify, make sure, hold on, think again, 's correct, 's incorrect, Let me check, seems right
Through observation, we have summarized set of rules to determine whether given step belongs to reflection, transition, or execution. These rules can be categorized into two main types.
The first type is the prefix rule, which relies on the observation that many transition or reflection thoughts often begin with words such as "wait" or "alternatively" If step starts with these words, we classify it as a transition or reflection. However, this criterion alone is insufficient, many steps do not meet this condition.
13

---

Published as a conference paper at COLM 2025
To address this limitation, designed the phrase rule, which identifies common phrases that frequently appear in the middle of step. As shown in Table 5, any of these predefined phrases occur within a step, we classify it as a transition reflection. Steps that do not meet either of these criteria are categorized as execution. During the classification process, letter case is ignored.
B.2
Ablation on different criteria
Table 6: Ablation study of thoughts recognizing criteria with Deepseck-Rt-Distilll-en
1.5B
MATH-500
GSM
LiveCodeBench
Methods
Accuracy81() Tokens())
Accuracy@1()
Tokens(()
Pass@1(() Tokens(.)
Base
67.0
4526
74.1
2015
18.5
8205
SEAL (W. Prefix Only)
78.0
3115
81.7
999
25.3
7119
SEAL (w. Phrase Only)
75.6
3522
80.4
1210
23.5
7466
SEAL
78.0
3153
82.0
999
28.5
6923
We also conducted an ablation study on the criteria rules, evaluating the performance of using only the prefix rule only the phrase rule to extract reflection and transition thoughts for steering. The results, presented in Table 6, indicate that even with only subset of the rules, can still achieve competitive results. This suggests that we do not need overly rigid pattern designs; as long as these rules capture key concept-level information about reflection and transition, we can obtain an effective steering vector. Naturally, more precise rules can further enhance performance.
B.3 LLM-Based Labeling and Comparison with Heuristic Method
In addition to the keyword-basel categorization introduced above, we also experimented with using frontier model (GITT-4o) to label thought types. Given the full reasoning context and the current step, we prompted the LLM to classify each thought as execution, reflection, or transition.
Interestingly, our experiments showed that the keyword-based method achieves slightly better end-task performance in SEAL shown in Table 7.
Table 7: Comparison of thought labeling methods on MATH500 and Deepseek-R1-7B-Diss
Method
Accuracy (%)
Baseline
85.8
SEAL (Keyword-based)
89.4
SEAL (LLM--ased)
88.6
That said, the LLM-based method remains appealing due to its ease of adaptation to new domains, languages, or expanded categories, and could be especially useful in scenarios where heuristic rules are hard to define or scale.
C SEAL Performance on In-Distribution Steering Vector
We also experimented with generating the steering vector using in-distribution data from GSM8K and LiveCodeBench. For GSM8K, we followed the same approach in MATH- 500, selecting 1000 samples from the training set to construct the steering vector. For LiveCodeBench, since used the authors' released version1 as test set, leveraged 480 samples from the difference set between the later released version and the first version to collect thoughts and generate the steering vector.
As shown in Figure 8, steering vectors derived from in-distribution data proved effective but did not perform well as those from MATH-500. This discrepancy can be attributed to the
14

---

Published as a conference paper at COLM 2025
Table Performance SEAL with a Reasoning Steering Vector Derived from In- In-Distribution
Samples
GSM8K
LivecodeBench
Methods
Accuracy@1 (1)
#Tokens (1)
Pass@1 (t)
#Tokens (4)
Base SEAL
74.1
2015
18.5
8205
80.9
1196
23.8
7218
Deepseek-R1-Dishee R1-Distill-Qwen--7
Base
88.0
1142
44.5
6856
SEAL 88.6
786
49.0
6015
relatively homogeneous nature of GSM8K and LiveCodeBench samples, whereas MATH- 500 encompasses wider range of difficulty levels and problem types, making it easier to obtain more generalized steering vector. These results further validate our hypothesis that it is unnecessary to extract a new vector for each task individually, well-curated, high-quality dataset is sufficient to generate a generalizable steering vector.
D Generalization to Open-Ended Planning Tasks
To further evaluate the generalizability of SEAL beyond structured domains such as math- ematics and programming, conducted additional experiments more open-ended reasoning benchmark: the NaturalPlan dataset( Zheng et al. (2024)), which focuses on natural language calendar planning.
Importantly, we reused the reasoning steering vector extracted from the MATH domain, to assess cross-domain transferability. As shown in Table 9, SEAL achieved consistent improvements in both accuracy and response length compared to the baseline, indicating that the latent patterns of reflection and transition overuse also appear in more open-ended planning contexts.
Table Results on the calendar planning task from the NaturalPlan benchmark using Crepseek-RI-Disttl--2
Method
Accuracy (%)
Avg. Response Length
Baseline
14.9
6341
SEAL (Math Vector)
18.6
3531
15

---

Published as a conference paper at COLM 2025
E Results with Sampling-Based Decoding
Table 10: Comparison results on the Math500 and LiveCodeBench. Using = 0.6, top-p
0.95 for decoding
Math-500
LiveCode
Methods
Accuracy@1 (1) #Tokens (4)
Pass@1 (1)
#Tokens ())
Deepseck-RI--Dsiill--eeeee
79.9
4021
29.6
7639
W. Logits PenaltyTransition Logits Reffetinnn
80.9 (+1.0)
3802
29.3 (-0.3)
7567
78.8 (-1.1)
3416
28.9 (-0.7)
6727
w. Logits PenaltyBoth
80.3 (+0.4)
3218
28.2 (-1.4)
6755
SEAL
81.6 (+1.7)
2976
32.2 (+2.6)
6468
Deepseek- M--eck--R--iissee Mel---iitil---eenn
89.7
3334
49.7
6609
Logits PenaltyTranaae Transition
88.5 (-0.2)
3318
48.7 (-1.0)
6652
Logits renaltyReflection
89.7 (+0.0)
2942
53.1 (+3.4)
5920
W. Logits PenaltyBoth
90.3 (+0.6)
2831
53.8 (+4.1)
5895
W. SEAL
91.3 (+1.6)
2695
56.3 (+6.6)
5871
QwQ-32B
91.1
3650
76.2
5610
Logits Transionnnniiion
90.7 (-0.4)
3547
75.3 (-0.9)
5648
w.
Logits Penalty PenaltyReflection Reflection
91.9 (+0.8)
3270
81.2 (+5.0)
5216
Logits PenaltyBoth
92.1 (+1.0)
3150
81.5 (+5.3)
5169
Wc SEAL
92.5 (+1.4)
3160
82.8 (+6.6)
4959
We also experimented with decoding via sampling, using temperature ! = 0.6 and top-p 0.95. The results reported in Table 10, averaged over three runs. Similar to greedy decoding, we observe that SEAL achieves both improved performance and reduced token usage.
Comparison of Generated Sequence Lengths
Deepseck-R1-De -iaassck-R---isslll--e-ee Math500
12000
Base Correct
Incorrect
Ours Correct
Ours Incorrect
10000
# Tokens
8000
6000
4000
2000
Level
Level
Level
Level 4
Level 5
Figure 8: Comparison results of generated sequence lengths. We report the average sequence lengths for samples across different difficulty levels and separately for subsets where the model produces correct or incorrect answers. The experiments are conducted on the Math500 model.
task using the ReepSeek-Ki-Disiil---ee--
As shown in Figure 8, applying SEAL significantly reduces sequence length for subsets where the model produces incorrect answers. This reduction occurs because the original reasoning process is often disrupted by unnecessary reflection and transition thoughts.
16

---

Published as a conference paper at COLM 2025
Mitigating these distractions allows the model to focus on the core reasoning path, enhancing performance while minimizing extra token consumption. Additionally, SEAL can slightly reduce redundant tokens even for correctly answered samples, further demonstrating its efficiency gains.
G
Disentangling SEAL's Gains from Truncation Effects
While SEAL demonstrates performance improvements, one may question whether the gains stem primarily from suppressing redundant thoughts or simply from shortening the sequence length, which might reduce token-level errors. To disentangle these effects, we conducted a controlled comparison against a baseline that forcibly limits reasoning length without semantic steering.
Specifically, we introduced a fixed "think budget" mechanism, where the model in- structed to insert an </think> token once the total token count in the reasoning process exceeds a preset budget. After this point, the model proceeds directly to the answer sum- marization phase. We set the budget to 3500 tokens, closely matching the average output length of SEAL to ensure fair comparison.
Table 11: Comparison between SEAL and simple truncation baseline on Deepseek-Rl-Distill- 7B (MATH500).
Method
Accuracy (%)
Avg. Response Length
Baseline
85.8
3389
Baseline + Think Budget 3500
85.0
2540
SEAL
89.4
2661
shown in Table 11, the truncation-based baseline underperforms SEAL, despite producing similarly shorter outputs. This demonstrates that SEAL's advantage not merely due to sequence shortening. Instead, it effectively guides the model to suppress specific types of non-productive reasoning, such unnecessary reflection and transition thoughts, leading to better-calibrated and more accurate reasoning trajectories.
H Thoghts Patten Demonstration Examples
We present reasoning path for sample from MATH-500 in Figure 9. This sample is relatively easy, and the model able to arrive at the correct answer within a few reasoning steps. However, instead of confidently settling the correct solution, the model repeatedly attempts to verify and recheck its previously correct answer, continuously switching its thoughts. Ultimately, this leads the model into loop, causing deviate from the correct reasoning path and produce an incorrect final answer.
17

---

Published as a conference paper at COLM 2025
Question
Simplify V2....079) (...9..00..222222322...
Response
Okay,, liis solve: simplify the cagrasium v/2.5 0.77) diviaad by 2.5). wrile visualise better.
square of squared squard)), The denominator 2.7 Alright,
first.
know that 2.5 squared is 6.25 hecause 2.5 times 2.5 6.25. Similarfy, 0.7 squared is 0.49 becouse 0.7 times 0.7 is 0.49, So, subtracting those, 6.25 ninus 0.49, Let me do subrraction
0.49, Hmm,, 6.25 minus 0.4
minus 0.09
5.76,
inside square
Therefoce,
square
Now, what'' the square root 5.767 remember that squared is 5.76 because 2.4 times 2.4 Let me vardy that: 2 times 4s4,, 0.4 times is U.S,2 times 0.4 anotber 0.8, and 0.4 times 0.4 0.16, Adding thowe up 0.8 + 0.16 5,76, Yep, that's correct So, the sumentor simplifice to 2:4.
Now, moving on to denominator 2.7 minu. That's stnightforord 2.7 minus is 0.2. So, the denominster 0.2.
now; the expeession simplifies to 2.4 divided by 0.2 Let compute that. 2.4 divided by 0.2. Hmm, 0.2 gors into 2.4 how many times? Well, 0.2 times because 0.2 times 10 is 2, and 0.2 times 0.4, so is 2.4. So, 0.2 times 12 2.4, which means 2.4 divided by 0.2 is 12.
Waii, me čosbleshock flat division 24 divided by 0.2. Another way think about it mulliply mimensior and denominsttrr by 10 climinate deximal. So, divided which
times
0.2
So, putting it all logetber, the sumerator simphifies 2.4, the denominator simplifies to 0.2, and dividing thom gives 12, Thersfore, the simplified expresioo is 12,
make
any
my colculations.
through step agsin.
Firsi, 2.5 squared 6.25, comeer. 0.7 squarad 0,49, everect. Subtractnng 0.49 fiom 6.25 gives. 5.76, conret. Square romt of is 2.4, cverect. Denominnator: 2.7 minus
2.5 is 0.2 correct Then, 2.4 divided by 0.2 is 12, correct.
solid. Altestatvvll, tlink the
aquares. eapressios [2.5 0.7). compute
square 2.5t-0.7 which (2.5
2.5 minus 0.7 la 188 and 2.5 plus 0.7 3.2. So, 1.8 times 3.2 equal so 5.76, which is Dhe same before. So, the square mot of776 2.4. which is the same before. that's another confirm
So, the deneminator is 0.2, 2.4 divided by 0.2 12. So, that's consistent.
Ahematively; can think of the entire expression as viyl Hylc di where 2-2.5, b-0 c=2.7, d-2.5, Butt in this cass, c- 0.2, which is small number, the division by a small number makes the essult larger, which why we get
Wali, mustier Boouge
denemisater 0.2, which numerater vip! br) denominator (a So, the expression viel bryaa b). Maybe can simplity expression algebraically.
the diffesence between and the sumerator's expecasion. Haun, inseresting
Let me write that: "ls* b' b). Since a" -b' facoors into (a eXa b), so Vita bifa b))aa b). Then, that's equal to viaa b) byla b). Which simplifies to byhlj-b) by. Whit, that cureet?
that step by step, vial- b/) Vi(a bya b), that's equal via times via b).
expeesson is [Vla
dicidal by (a bj. So, that's aquil [Nix b)/ V/s because 4is cancels
Via from the numerstor.
So, in this case, is 2.5 and bis 0.7. plugging we V22.5 + 0.7) divided by 1:2.5 (275 Let's compute that.
0.7 2.5 0.7 is and 2.5 1.8 So, 18.2 divided by v1.8. Hmm,, me compute that.
Finst, v3.2. ((165) 4855, which approximately 1,78K, Similarty, vE.8 (V5*3)
which 3045, approximonely 1,322 dividing 4i-5 by 3-45
But wail, that contrdiess my eaclier result of 12. Hmm, that can't right. So, where did go wrong?
Wait, hold check alpebra again. So, starting with Vas Wi That apail
bijla Which
via *Ke byte
by-ka
But my numerical coampls, plugzing 2m2. and b-0.7, get (33.)) 8). Let me compute that mumorically.
V3.2 is apprxiimiaaly 1.788, and vi.8 sppeooimmttlly 1.342, 1.788 divided 1,342 approsimately 1333, which 4:3. Rut cerlier, lodi 12, So, florfe problem.
Wiii, which one correst? is 4/3 Hmm, that's cunissnng
is bt bib 1.8. So, b) v3.2, apprntimately 1,785, and b)) appeocimanely 1.788 divided by 1.542 is approximately 1.333, which is 4/3.
Execcution Thoughts
Reflection Thoughts
Transition Thoughts
Figure 9: One example from ReepScck-Ri--istill--eeee for a math question where the model fails to provide the correct answer after multiple reflections and transitions, even though had arrived at the correct answer(12) multiple times before.
18


Reviews:
[{"review_id": "yEn1Ec6nLH", "reviewer": "Reviewer_hU5P", "summary": "This paper proposes SEAL, a new method to reduce redundant reasoning in LLMs without additional training. The authors find that CoT often include unnecessary reflection and transition steps that waste tokens and can mess up reasoning. SEAL computes a steering vector that shifts the model’s hidden states toward the execution direction. During generation, this vector is added to the hidden state after each thought, steering the model to focus on direct problem-solving steps. The approach is training-free and model-agnostic. SEAL can improve accuracy by up to 11\\% and cut reasoning tokens by 12–50\\% on math and coding benchmarks.", "questions": "", "limitations": "", "rating": 7, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "1. Insightful analysis of reasoning patterns: The paper identifies three intuitive reasoning thought categories (execution, reflection, transition) and empirically shows that failure cases have substantially more reflection/transition steps than successes.\n2. Latent space insights: The work demonstrates that the three thought types are separable in latent space (especially in deeper transformer layers).\n3. Training-free intervention: SEAL method effectively steers hidden states using a learned vector offset, rather than fine-tuning model's weights. This representation-level intervention is new and avoids additional training cost or architectural changes.\n4. Performance improvements: SEAL leads to notable improvements on complex reasoning tasks.", "reasons_to_reject": "1. Heuristic categorization: The method identifies reflection vs. transition thoughts by detecting keywords. This may limit generality for different domains or writing styles. A more automated or learned way to label thought types could strengthen the approach.\n2. Diminishing returns on advanced models: The gains of SEAL decrease with very capable models such as the case of the 32B model. This suggests that powerful models already manage their reasoning well, and steering can overshoot. The authors may want to discuss when SEAL might hurt performance or how to detect such cases.\n3. Balanced steering: While SEAL aims to reduce reflection, the results indicate not all reflection is bad. The authors also need to tune a steering strength to avoid eliminating too much. This fine balance might be tricky to find for each model/task.\n4. Scope of benchmarks: All experiments are on math or coding tasks with structured problem-solving. It remains to be seen how SEAL performs on more open-ended reasoning such as commonsense QA or planning.", "questions_to_authors": "1. Can SEAL mis-steer the reasoning process? For example, could the model skip necessary verification steps when reflection is suppressed? How does the method detects and handles the situations where injecting the steering vector harms performance?\n2. The paper fixed a steering coefficient. How was this value chosen? How sensitive are the results to this parameter?", "extra_scores": {}}, {"review_id": "A5ice8mD7a", "reviewer": "Reviewer_goZm", "summary": "This paper presents SEAL, a novel, training-free approach for calibrating reasoning in large language models (LLMs) by steering their internal representations to suppress redundant \"reflection\" and \"transition\" thoughts during chain-of-thought (CoT) reasoning. The method is motivated by empirical observations that excessive non-execution reasoning steps correlate with reduced model performance and increased inference cost.", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "1. The paper identifies a meaningful problem: redundancy in chain-of-thought (CoT) reasoning in LLMs, particularly due to excessive \"reflection\" and \"transition\" thoughts. This is well-motivated with empirical data.\n\n2. Demonstrated across multiple datasets (Math500, GSM8K, LiveCodeBench) and models, SEAL consistently improves accuracy while reducing token usage significantly.\n\n3. The steering vector extracted from one task generalizes to others, which suggests robustness and practical utility without task-specific retraining.", "reasons_to_reject": "1. The method heavily relies on heuristic identification of thought categories and the assumption that their latent representations are separable. There is minimal theoretical grounding or formal analysis of why the steering vector should work as described.\n\n2. While SEAL demonstrates performance improvements, it's unclear whether the gains stem from suppressing redundant thoughts or from simply shortening sequences (which may reduce token-level errors). There is no disentangled analysis isolating these effects.\n\n3. The method depends on specific hyperparameters (e.g., the steering layer and coefficient α), but the ablation study is shallow and lacks statistical robustness (e.g., no confidence intervals or multiple seeds). It is unclear how stable the results are across different configurations.", "questions_to_authors": "1. How sensitive is SEAL to the quality and domain of the dataset used to extract the steering vector?\n\n2. Could more robust, possibly learned classifiers improve thought type identification beyond keyword matching?", "extra_scores": {}}, {"review_id": "zGT4kqnvTk", "reviewer": "Reviewer_ssbp", "summary": "This paper proposes SEAL (Steerable rEAsoning caLibration), a training-free method that improves the efficiency and accuracy of large language models (LLMs) in complex reasoning by identifying and calibrating flawed reasoning paths. SEAL extracts a reasoning steering vector in the latent space, which is then used to dynamically adjust hidden states for more efficient and accurate reasoning.", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "-\tThe statistical analysis of the three types of thoughts (execution, reflection, and transition) with task difficulty and the analysis of latent representations are insightful. Key observations (e.g., “frequent reflection and transition thoughts consume a significant token budget”, “execution thoughts are clearly separable from non-execution thoughts in the latent space”) could inspire future research on understanding LLM reasoning.\n-\tThe proposed framework SEAL for controlling the ratio of reflection and transition thoughts is promising.  Experiments with three models (Deepseek-R1-distill-Qwen-1.5B, Deepseek-R1-distill-Qwen-7B, QwQ-32B-Preview) on three datasets (Math500, GSM8k, LiveCodeBench) demonstrate improvements in both accuracy and efficiency.", "reasons_to_reject": "-\tThe categorization of the three types of thoughts is based on keyword identification, which is rather coarse. The table includes only a limited set of keywords, potentially leading to misclassification. It remains unclear how this affects the performance and reliability of SEAL in reasoning steering.\n-\tSome claims in the paper lack sufficient justification and would benefit from further clarification. For example, in lines 145-146, “This aligns with the expectation that shallow layers primarily capture low-level features, while deeper layers encode more abstract conceptual and semantic knowledge”. It’s not clear how this observation explains the separation of different thought types in deeper layers. Does the model rely on distinct features to generate each type of thought?\n-\tThe idea of computing the reasoning steering vector as an arithmetic combination of different thought vectors lacks clear intuition. How does this approach selectively mitigate “unnecessary” reflection and transition thoughts while preserving “essential” execution thoughts? As presented, the method seems to generally penalize reflection and transition thoughts, without a mechanism to distinguish between useful and redundant instances.\n-\tThere is a typo in line 198—“four datasets”. Only three datasets are used in the experiments.", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "RmnFbFLZQz", "reviewer": "Reviewer_b7rX", "summary": "The paper proposes a way to calibrate the reasoning trace of o1 style reasoning models that usually produce long CoT chains to solve reasoning tasks. First they present evidence of the reasoning thoughts belonging to two categories: execution (ones involved in the step-by-step breakdown), and reflection and transition (ones where the model reflects on the steps and explores alternative approaches) using the hidden representations of the tokens separating thoughts (\\n\\n). They formulate a reasoning steering vector that encourages the models to execute more and reflect&transition less, which is computed by using a few 100 reasoning trace examples. During inference, the hidden representation of a thought is imputed with this steering vector, making the model obtain higher accuracy while utilizing fewer tokens. Overall, the paper is structured and reads well, presents a novel and computationally efficient approach to get these reasoning models to perform more efficiently.", "questions": "", "limitations": "", "rating": 7, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "- The paper is well-written and the topic is very relevant across domains\n- The idea of grouping thoughts into the ones involved in the task breakdown and those for exploring alternate paths is not novel but the approach of doing it with just few examples is novel\n- The offline computation of the steering vector involves a simple vector addition which is very neat\n- This steering vector generalizes well across domains; at least the math and code that were tested", "reasons_to_reject": "- Several works in the past have demonstrated how math and code domains benefit each other, so it would have been better to see this approach applied to a more distant domain rather than code using the steering vector from math. This would have been a better indicator of the generalizability of this approach", "questions_to_authors": "- Related to the mentioned weakness, what about for agentic tasks, how can this method be adopted?", "extra_scores": {}}]

Author rebuttal:

Meta-review: This paper first analyzes CoT reasoning traces and found that the thoughts (identified using \n\n boundaries) can be divided into three types: execution, reflection, and transition. They also showed that in hidden states these different types are also distinguishable using tSNE. Their analyses also found that redundant reasoning primarily results from unnecessary reflection and transition steps. To improve reasoning efficiency, the authors introduce a training-free approach that uses a steering vector added after each thought block during inference, encouraging LLMs toward execution-oriented reasoning. Experiments demonstrate the steering vector improves both accuracy and efficiency, and even generalizes across tasks.

Pros:
1. Reviewers find the categorization of CoT reasoning into execution, reflection, and transition, and that they are distinguishable in hidden states, to be insightful.
2. The proposed approach, being training-free, improves performance in terms of both accuracy and efficiency without requiring fine-tuning.

Cons:
1. As pointed out by a reviewer, the gain seems to diminish on advanced models, which might already be doing reasoning well and steering is less helpful.
2. The approach requires specifying hyperparameters, notably the layer and steering coefficient. Results from the authors during rebuttal (Table R3) indicate sensitivity to the chosen layer, potentially limiting practicality.

Overall, reviewers positively rate this paper (with scores of 7, 6, 6, 7), especially regarding the insightful categorization of CoT reasoning and the effective training-free steering approach to promote execution. Therefore, I recommend accepting this paper.
Decision: Accept