Steering Large Reasoning Models towards Concise Reasoning via Flow Matching
Authors: Yawei Li
Benjamin Bergner
Yinghan Zhao
Vihang Prakash Patil
Bei Chen
Cheng Wang
Venue: Accepted by TMLR ()

Abstract: Large Reasoning Models (LRMs) excel at complex reasoning tasks, but their efficiency is often hampered by overly verbose outputs. Prior steering methods attempt to address this issue by applying a single, global vector to hidden representations—an approach grounded in the restrictive \textit{linear representation hypothesis}. In this work, we introduce FlowSteer, a nonlinear steering method that goes beyond uniform linear shifts by learning a complete \textit{transformation between the distributions} associated with verbose and concise reasoning. This transformation is learned via \textit{Flow Matching} as a velocity field, enabling precise, input-dependent control over the model's reasoning process. By aligning steered representations with the distribution of concise-reasoning activations, FlowSteer yields more compact reasoning than the linear shifts. Across diverse reasoning benchmarks, FlowSteer demonstrates strong task performance and token efficiency compared to leading inference-time baselines. Our work demonstrates that modeling the full distributional transport with generative techniques offers a more effective and principled foundation for controlling LRMs.

Published in Transactions on Machine Learning Research (02/2026)
Steering Large Reasoning Models towards Concise Reason- ing via Flow Matching
Yawei Li LMU Munich
Benjamin Bergner
bbergner&amazzon.com
Amazon
Yinghan Zhao
yinghan::9amczon.com
Amazon
Vihang Prakash Patil
prihang@amaazon.com
Amazon
Bei Chen
chenbe@armazon.com
Amazon
Cheng Wang
cungumm@amazon.com
Amazon
Reviewed on OpenReview:
https: // openreview. net/ forum? qucJeR
Abstract
Large Reasoning Models (LRMs) excel at complex reasoning tasks, but their efficiency is often hampered by overly verbose outputs. Prior steering methods attempt to address this issue by applying single, global vector hidden representations an approach grounded in the restrictive lnnea representation hypothesis. In this work, introduce FlowSteer, nonlinear steering method that goes beyond uniform linear shifts by learning a complete transformation between the distributions associated with verbose and concise reasoning. This transformation is learned via Flow Malching as a velocily field, enabling precise, input- dependent control over the model's reasoning process. By aligning steered representations with the distribution of conciso-reasoning activations, FlowSteer yiclds more compact rea- soning than the linear shifts. Across diverse reasoning benchmarks, FlowSteer demonstrates strong task performance and token efficiency compared to leading inference-time baselines. Our work demonstrates that modeling the full distributional transport with generative tech- niques offers more effective and principled foundation for controlling LRMs.
1 Introduction
Recent Large Reasoning Models (LRMs), such as the OpenAI ol-scrics AOenAA 2024 and DeepSock-Ri R1 series (uuo al.) 2025), leverage Chain-of-Thouue Thought (CoT) reasoning (Wei et al. 2022 tackle complex problems in domains like mathematics and coding (Ahn et al. 2024 AlphaProof & AlphaGeometry 2024
Luo et al. 2023)). By externalizing their reasoning into intermediate steps, LRMs achieve strong performance on logic-intensive tasks. However, key challenge has emerged: their reasoning paths are often excessively verbose (Chen et al. 2025b). These over-extended traces are often filled with unnecessary self-rellection,
which not only inflates computational costs but also diminishes accuracy (Chnn et al. 2025a Huang et al. 2025).
"This work was done during internship Amazon.

---

Published in Transactions on Machine Learning Research (02/2026)
To address this inefficiency, steering methods have emerged as promising, lightweight solution for com- pacting the reasoning paths of LRMss (Chen et al. 2025a Azizi et al., 2025). These methods alter model's behavior by directly manipulating its hidden representations at inference time. The core principle is to identify internal representations that lead to verbose outputs (source) and transform them toward repre- sentations associated with concise outputs (target). Most existing approaches, however, rely on the lineur representation hypothesis (Park et al.; 2024). This hypothesis posits that complex model behaviors can be controlled by shifting a hidden representation along single direction, i.e. a steering vector. While simple to implement, this linear approach applies the same shift to all source representations, irrespective of their individual starting positions. This rigid transformation ignores the complex geometry of the underlying representation space (Wang et al. 2025b), risking pushing steered representations off the data manifold and leading to suboptimal performance (Rodriguez et al. 2025 Huang el. al., 2025).
In this work, we introduce FlowSteer, novel steering approach that does not rely on the linear representa- tion hypothesis. Building on the perspective of steering as a distribution transport problem (Rodriguez al., 2025), we leverage Flow Malching (FM) (Lipman et al., 2023 Liu 2022) to learn a nonlinear velocity field that maps the "verbose" representation distribution to the "concise" one. This technique enables full distri- butional alignment that respects the data manifold, overcoming key limitation of prior linear approaches. However, applying Flow Matching to the LRM activation space is non-trivial; we uncover two phenomena that impede naive implementation. First, we identify that massive activation magnitudes severely destabilize training dynamics. We address this via a robust training strategy featuring ressier-resistant normalization and a Huber loss (Huber] 1992). Second, we observe that representations frequently stagnate in low- new-velccty zomes, failing to reach the target state. To counteract this, we introduce a novel probabilistic guidance mech- anism that ensures trajectorics effectively converge to the target manifold. Importantly, FlowStecr operates while keeping the original LRM parameters intact; the resulting flow model is lightweight MLP, adding minimal overhead during inference. Our contributions are as follows:
We propose a novel Flow Matching- basod nonlinear stecring method that better preserves the target representation distribution. Quantitalive experiments show that. FlowSteer has roughly 5.4x better distri- butional alignment to target representations compared to the linear steering baseline.
We reveal and systematically address critical challenges unique to using flow models within LRM activation space. We introduce a suile of novel techniques that ensure both stable training and the effective generation of steering trajectories, successfully overcoming pitfalls caused by massive activations and velocity stagnation.
We demonstrate that the superior distributional alignment. translates into reasoning efficiency. Specifi- cally, we evaluate FlowSteer across five reasoning benchmarks and LRMs at 1.5B, 7B, and 32B scales. Sta- tistical tests confirm that our approach requires fewer tokens than other inference-time baselines achieve comparable performance. Notably, in the best case, FlowSteer achieves up to 6.0% absolute accuracy increase over the nent-best method while further reducing token consumption by 14.5%.
2 Preliminaries
2.1 Reducing reasoning path length by linear steering
Hidden representation sets Steering methods for efficient LRMs operate by intervening on the model's 's hidden representations Id at a specific transformer block during inference. The core of these methods is the construction of two sets of representations: a source set S associated with verbose reasoning and a target
set T associated with concise reasoning (Huang et al. 2025). Different approaches populate these sets in different ways. For instance, ASC (Azizi et al. 2025) and Manifold Stecring (Huang ct al.) 2025) generate paired responses to the same prompt. a verbose CoT and a concise one and assign representations from the former to and the latter to T. Another approach, SEAL (Chen et al., 2025a), derives these sets by analyzing a single COT. It categorizes reasoning stops into different functional roles, identifying "Reflection/ "Refloction/Transitonn Transitiin"" steps as verbose and "Execution" steps as concise; the hidden states corresponding to these steps are then extracted to populate S and T, respectively.
2

---

Published in Transactions on Machine Learning Research (02/2026)
Steering vector
The steering vector u is typically defined as the difference-in-means:
Σ
Σ x
(1)
S
ØET
25S
where v encodes the direction toward more concise reasoning paths. To enhance robustness against noise in the hidden representations, Manifold Steering (Muang et al. 2025) additionally applies Principal Com- ponent Analysis (PCA) projection to At inference time, once token is identified for intervention, its representation z is shifted using the steering vector:
x'= x +==++0 y0,
where x' is the updated representation. The coelficient y E IR is either fixed hyperparameter (Chen el. al. 2025a; Zhao et al. 2025 Azizi et al. 2025) or value dependent on æ (Huang et al.) 2025). Because these methods adjust hidden representations via a simple affine transformation, we refer to them as lincar steering methods and term the coefficient y the linear strength.
2.2 Preliminaries on Flow Matching
From interpolation to velocity fields Flow Matching is a recent generative modeling technique to learn a smooth interpolation between a source distribution po and a target distribution pl, enabling sampling from Pi given samples from Po- Given a sample pair from the joint distribution (æa, #1) ~ No,1, a lincar path can be constructed as: Øt (æ) + (1 - ()=o) for E [0, I], which specifies the position time Flow Matching characterizes the motion of æt, which later serves the basis for generating new samples. This motion is described mathematically by time-dependent velocity field u R x [0, - IRd. Taking the time derivative dæ,
of 2, yields the conditional velocity field: (z [o)) = de = æ1 To. However, is unavailable when generaling new samples. To obtain a velocity field that depends only on (),,)), Flow Matching learns to model the marginal velocity field:
(x(x pp mol (x, xo)]
11,
(3)
Conditional Flow Matching loss The marginal velocity field can be learned by minimizing the regression loss (0) p..,) (2), t) un [1)) where wo is the flow model parametrized by 0. However, computing ux,));) requires marginalization over all (wo, æ1); making (FM(O) intractable. To address this
issue, Flow Matching introduces the conditional Flow Matching loss:
LCFM 0 = (0.-22(0.11.coooomm--- [IIvo(x,, t) u,( b,, + 1
(4)
Lipman et al. 20023 Liu
2022 show that (CF and (F) yield identical gradicnts, optimizing (CFM(() effectively learns the marginal velocity field us (xx)).
New sample generation Once the flow model uy (o,,,, t) is trained, new samples can be generated by using it as an approximation of the marginal velocity field un (xx). Starting with an initial sample 3p Po, one simulates the Ordinary Differential Equation (ODE) defined by the learned model: dt = 0g (x,,t), t), from In practice, the ODE solved numerically using mothods such as Euler or Dopri5 [Dormand] & Prince 1980 Two important properties of Flow Matching are worth highlighting: (1) By construction, the marginal velocity field (x,)) transports the source distribution Po exactly to the target distribution P1. Consequently, if the flow model v0(x,,t) perfectly recovers ue (x(x)) and is used for generation, the resulting samples also follow P1. (2) Although the conditional velocity field is derived from linear interpolation between 2n and æT, the trajectories produced by the marginal velocity field during generation are generally curved. These properties are central to our motivation for grounding method in Flow Matching, which we introduce next.
dæ:
0
3 Methodology
Distribution alignment via Flow Matching As introduced earlier, hidden states linked verbose CoTs form the source distribution, while those linked to concise CoTs form the target distribution (Figure
3

---

Published in Transactions on Machine Learning Research (02/2026)
Source Representations
Target Representations
Before Steering
After Steering
Before Steering
After Steering
Linear
Steering
Our FlowSteer
Figure 1: Left: The source distribution corresponds to hidden representations that produce verbose CoTs, while the target distribution corresponds to representations that produce concise CoTs. Better zoom in for clarity. Middle: Linear steering methods apply the same steering vector (the blue bolded arrow) to all source representations, aligning only the means of the two distributions. This ignores higher-order statistics such as covariance, often resulting in a substantial mismatch. Right: Our FlowSteer leverages Flow Matching learn a mapping from the source distribution to the target distribution, naturally aligning the two due to the theoretical properties of Flow Matching.
left). The goal of steering transport the source distribution to the target (Rodriguez et al. 2025). guiding the LRM produce concise CoTIs. Constrained by the linear representation hypothesis, existing steering methods simplify this transport into uniform shift. This approach, however, only aligns the means of the two distributions while ignoring higher-order statistics, often resulting in distributional mismatch (Figure middle). In contrast, our FlowSteer is grounded in Flow Matching, whose marginal velocity field guarantees an exact transport between arbitrary distributions (Figure | tations with the target geometry, minimizing off- af--maiifold excursions that trigger degenerative repetition or reasoning collapse (Huang al. 2025). Furthermore, the ability induce nonlinear steering trajectories
right). This capability align steered represen-
marks a key distinction from linear steering (Chen et al. 2025a Huang et al. 2025 Rodriguez et al. 2025)
Challenges of flowing in LRM activation space Despite the appealing properties of Flow Matching for distribution transport, applying it in the hidden space of LRMs introduces significant challenges. (1) The first arises from massive activations (Sun et al. 2024h: a subset of activations consistently exhibits magnitudes orders larger than the rest, often dominating the global norm of the hidden states. These extreme values can severely destabilize training by inflating the MSE loss. This prevents the flow model from learning useful structure and leads to divergent generation trajectories, pushing the steered representation toward infinity. (2) The second challenge the emergence of low-velocity zones: regions between the source and target manifolds where the learned velocity field has a very small magnitude. If representation 2p lies in such zone, it may move only minimally toward the target distribution and lead to suboptimal performance. Next, we elaborate on these challenges and our solutions.
3.1 Robust training strategy
Median
Massive activations cause divergent steering trajectories In typi- cal application domains of Flow Matching, e.g. image generation, the source is standard Gaussian noise and the target. pixels are bounded in [0, Consequently, the regression target (2, = x1 og in Eq. 4 typ- ically has a moderate scale and limited variance. In contrast, activations in LRMs are unbounded and can contain substantial outliers (Sun et al., 2024), as illustrated for the first four dimensions of the representations in Figure 2 These massive activations inflate the variance of the loss and destabilize training. The flow model then disproportionately allocates pacity to predicting conditional velocities associated with these extremes, underfitting the typical structure of the source and target distributions. At steering time, the poorly fitted flow model makes large prediction errors in certain regions, pushing representations off the target manifold and causing stecring trajectories to diverge toward infinity. To mitigate this problem, we explicitly reduce the influence of outlier activations by introducing robust data normalization and robust loss.
Value
-10
-20
-40
0
2
3
Dimension Index
Activations from layer 20 of DecpSeek-R1- 1isti1l-Qwen-1.BB.
Figure 2:
4

---

Published in Transactions on Machine Learning Research (02/2026)
Robust data normalization The presence of massive activations necessitates a robust normalization of the source and target representations. Conventional dimensionwise z-score scaling (aa") is unsuitable for this landscape, as outliers may skew the estimated mean μ and inflate the standard deviation ø. This effect compresses the majority of typical activations into a narrow range, masking important structural information. Indeed, our ablation study in Section 4.4 confirms that this information loss is fatal: training the flow model with z-score normalization leads to model collapse, yiclding near-zero accuracy across multiple benchmarks. We therefore adopt a more robust normalization using the median and interquartile range (median-IQR normalization), which we apply independently to the source and target representation sets. For given activation value z in single dimension (of æo æ1), its normalized value 7 is computed as
ã - median(X)
(x5(X) - (x)
where median(X), the 75th percentile (x) and the 25th percentile (2s(X) are computed for that dimension across the training set (of either source or target representations). This method is inherently resilient to outliers, preserving meaningful variations within the non-outlier data.
Robust loss function The standard MSE loss [[ (æ) 20)) ll in the conditional Flow Matching loss (Eq. ) is also highly sensitive to outliers. To improve training stability, we replace it with a more
robust, dimension wise Huber loss (Huber 1992). Let Ç = oo t) - (x) xo) be the prediction residual
vector. The Huber loss for its k-th dimension is:
if lsk S 1, otherwise.
Duuber (Ck)
25k [C
(6)
The total loss is obtained by averaging across all d dimensions. This loss replaces the MSE loss in Eq. (4)
and the final optimization objective is the expectation of this total Huber loss over time t ~ [d 1] and data pairs (2o, 21) ~ To,1- The Huber loss behaves quadratically for small residuals (Iss S 1) and lincarly for large ones, reducing the influence of outliers. As training progresses, the residual values Ga typically converge to be smaller than 1. In this regime, the Huber loss becomes equivalent to the squared loss, thereby preserving the key theoretical guarantee of Flow Matching such as the relationship CCFMM(() (O), as introduced in Section 2.2
Better source-target coupling The standard approach in Eq. 4 couples source Do and target æ samples independently (i.e., To,1 (20, æ1) = po po (zo)pi (x1)), which can create unnecessarily complex paths for the flow model learn. To address this, we adopt the minibatch 2- Wasserssn Optimal Transport (OT) coupling strategy (Tong et al. 2024). This strategy finds an optimal pairing of source and target samples within each batch, which simplifies the resulting conditional velocity fields and thus makes the learning objective easier to optimize. In practice, the OT plan OT is computed efficiently using solver such as the Sinkhorn algorithm (Cuturi 2013).
The robust training techniques above successfully resolve the issue of divergent steering trajectorics, climi- nating infinite values in steered representations. The second challenge, the existence of low-velocity zones, becomes the primary obstacle effective steering. In the following section, we analyze the underlying causes of these zones and introduce our probabilistic guidance as the solution.
3.2 Probabilistic guidance avoids stagnation in low-velocity zones
Causes of low-velocity zones We refer low-velocity zone to a region where the velocity vectors of the learned field have small magnitude. The formation of these zones stems from the conditional Flow Matching loss, (0) (Eq. ( where the toound-truth regression target is the conditional velocity (x xx) Zp. Prior studics (Chen et al.) 2025a; Huang et al. 2025) indicate that the source (po) and target (pi) distributions maintain significant spatial proximily in the representation space. Consequently, training pairs (xo. 11) sampled from these proximal regions naturally yield velocity targets with small magnitudes (a) - Zo R 0). Furthermore, the minibatch OT plan exacerbates the formation of low-velocity zones. By design, OT minimizes transport cost by coupling pairs (æo, x1) that are already close. This strategy systematically pairs more points within the proximal regions, which in turn generates more small-magnitun
5

---

Published in Transactions on Machine Learning Research (02/2026)
regression targets and encourages the flow model to learn low-velocity field there. Consequently, at steering time, any source representation Do that starts in this zone will stagnate, leading to suboptimal compression of the reasoning paths.
Probabilistic guidance Inspired by guidance techniques in conditional image generation Dhhrriwll & Nichol 2021 Ho & Salimans, 2021; Karras et al. 2024), we introduce a probabilistic guidance to help representations escape low-velocity zones. Unlike in image generation, where guidance aims to align outputs with text prompts, our goal is to steer representations from the source distribution Po toward the target distribution P1. Intuitively, this process should increase the likelihood p1 (xx) while decreasing (o along the trajectory. A standard approach is classifier guidance (Dhariwal & Nichol 2021), which derives a guidance from the score function v log q(c = 1 of an auxiliary classifier trained to distinguish between the source (class c 0) and target (class c = 1) distributions. However, we avoid this method due to the computational overhead of training and deploying an additional classifier.
Instead, we propose training-free guidance mechanism that eliminates the need for additional learnable parameters. Our approach is motivated by prior work (Hashemi et al.] 2021 Zhang et al.. 2021 showing that activation distributions in the later layers of neural networks are well-approximated by Gaussians, an approximation also adopted in previous LLM steering rescarch (Rodriguez et al. 2025). Since we perform
steering in later LRM layers (see Section A we approximate both the source distribution po and the target distribution P1 with Gaussians: po(-) R N Mo; Σo) and pi(+) (1 E1). This allows us to analytically
compute the difference between their score functions:
9e (xx)) = v log Va log
" xx) En' (HO xz)-
This vector gr (zx) points in the direction that maximally increases the log- logeiikllhood of the target distribution while decrcasing that of the source. Let Te (xx) = gi (z. (z..)//lge( (x)))22 be its normalized version. We incorporate
this guidance into the generation ODE
dms di
up (ar, 1) as follows:
dæ: = vo( (a.) (vo( t) ((())) (x))).
(8)
dt
where 17 R4 is hyperparameter for guidance strength. The final term, (2o(2), ( (2x))) is the projection of the learned velocity vo(x,, onto the guidance direction (xx)). This formulation allows the guidance to operate adoptively depending on the representation' 's location:
(1) When Fe is in a low-vclocity zone, the learned velocity v0 t) has small magnitude. Consequently, its projection is negligible, and the dynamics are dominated by the guidance term (a.) As defined in Eq. 77 this guidance vector is non-zero almost everywhere as long as the source and target distributions are distinct (i.e., have different means or covariances). It thus provides persistent force throughout the low-velocity zones, pushing the representation toward the target and effectively helping it escape stagnation.
(2) When o, is outside low-velocity zone, the magnitude of vo( is larger. Both ro t) and (ax)) generally point toward the target region, making their inner product positive. In this regime, the projection term subtracts a portion of the guidance, reducing its inffuence. This allows the trajectory to be primarily determined by the more nuanced, learned flow model uy (1 1); which captures the finer-grained structure of the target manifold.
Practical considerations Computing the matrix inverse Σ in Eq. 7 is computationally challenging in high-dimennsonnll spaces. To reduce this overhead, we employ a diagonal factorization for Σ, technique consistent with recent research on LLMs that also handles high-dimensional Gaussians (Yang ct al. 2024 Li el al. 2025 Rodriguez et al. 2025). Specifically, we set Σ = diag(on 0 @ (a)) and En diag( @ n where C denotes the Hadamard product. The vectors 01, og E R& contain the per-dimension standard deviations, which we estimate from the training data along with the means #4 and μ1 While this factorization is less expressive than the full covariance structure, our experiments in Sections 4.4 and show that the guidance substantially boosts accuracy and token efficiency, justifying the factorization choice.
6

---

Published in Transactions on Machine Learning Research (02/2020)
4 Experiments
4.1 Implementation
Steering layer and steering tokens Representation steering involves two key components: a. protocol that specifies where to intervene (i.e., at which layers and tokens) and a mechanism that defines how to modify the representations. Focusing on the latter, our primary contribution is FlowSteer, a steering mechanism. To isolate the impact of our approach, we conduct a controlled comparison against one of the state-of-the linear methods, SEAL (Chen et al.) 2025a). We adopt SEAL's intervention protocol by stecring the same layer and intervening at every " "An in" token, which serves as the delimiter for splitting reasoning steps. By retaining this protocol while replacing the linear mechanism with FlowSteer, we ensure that any observed improvements are attributable solely to our proposed steering mechanism. Further implementation details are available in Section
Training dataset To ensure a fair comparison and equivalent data efficiency, we use an identical training dataset for both SEAL and FlowSteer. We extract representations from the MATH/train set (Henddyyks et al. 2021 h. These representations are then used for two purposes: (1) to compute the steering vector for SEAL, and (2) to train our MLP flow model, which includes the estimation of distributional statistics (e.g., percentiles, mean). Notably, the number of question samples used for reprosentation extraction is modest, ranging from 1,000 to 3,600. Even for a 32B LRM, our flow model can be trained on a single GPU within 24 hours. Consequently, compared to RL-based approaches (e.g.. Dai et al. (2025): ; Xiang et al. (2025) ), our method is significantly less demanding in terms of data samples and computational resources. We outline the specific training details in Table
Evaluation benchmarks For math, use: MATH500 (Lightman et al.
2024 Hendrycks et al. 2021
GSM8K (Cobbe et al. 2021), AIME24 |Mathematical Association of America 2024). and AMC23 Math-
ematical Association of America 2023 To test the cross-domain generalization, we evaluate on the coding
task LiveCodeBench (Jain et al. 2025).
LRMs To evaluate the generalizability of our approach across different model families and scales, we con- duct experiments on Ceepseek-R1-diste wewiiillllwee--.... Qwen-1.5B (Guo et al.) (0225) and its 7B variant (denoted with
2025) (denoted with QwQ-32B). To maintain a con- trolled environment, follow Chen et al. (2025a) and use greedy decoding for the vanilla models and all inference-time approaches (listed in Section 1.3 We set the maximal token length of LRMs to 15,000 on AIME24 and 10,000 on all other benchmarks.
R1-1.5B/7B), and Qwen-QwQ-32B (Qwen- Team
Flow model and guidance strength Our flow model to is a lightweight MLP, adding minimal compu- (ational overhead, as detailed Section 4.5 Specifically, we use a 6-layer MLP for the R1-1.5B/7B models and an 8-layer MLP for the QwQ-32B model. During steering, we generate trajectories using the Dopri5 ODE solver. To ensure fair comparison of performance, we conduct hyperparamcter sweep for both the guidance strength 17 of FlowSteer and the linear strength y of SEAL, reporting the best-performing config- uration for each. The detailed hyperparameter values are reported in Section A.4 We note that default = 1 is strong choice across most models and datasets.
Baseline methods We compare FlowSteer against a diverse set of inference-time intervention methods These include the linear stcering method SEAL (Chen et al., (025a), a logit-level intervention method Log- itsPenalty (Wang al.) 2025c two token-level methods, AlphaOne (Zhang et al. 2025) and s1 * (Muen- nighoff et al. 2025), and the prompt-based method CoD (Xu et al. 2025a). The s1* is the version without supervised fine-tuning. In addition, report results from single run, which aligns with the standard evaluation settings established by previous works (Chen et al.] 2025a Zhang et al. 2025 Wang et al. 2025ep. In line with SEAL and AlphaOne, we do not compare against RL-based approaches. These meth- ods represent an orthogonal line of work focused on optimizing LRM weights to improve CoT generation. In contrast, the methods evaluated here are inferenco-time interventions that do not alter the base LRM. Notably, these two approaches are not mutually exclusive; inference-time approaches could potentially be applied to RI-optimized LRMs to further control the reasoning paths.
7

---

Published in Transactions on Machine Learning Research (02/2026)
Table I: Distributional distance between the source/steered representations and the target ones. FlowSteer
achieves a substantially better alignment (lower distance) to the target than both the original source repre- sentations ("Before Steering") and those steered by SEAL.
R1-1.5B
RI- 7B
QuQ-32B
Methods
MMD 4
FID
KID
MMD
FID 4
KID
MMD
FID 4
KID 4
Before Steering
564.6
8227.4
1137.5
577.1
22784.8
1609.5
652.9
67647.1
33951.7
After SEAL
386.2
4639.6
69.8
517.0
17158.1
189.4
539.9
44987.7
766.6
After FlowSteer
98.0
690.2
11.4
105.3
4701.4
25.3
60.4
5658.2
293.1
81-1.58 (Avg. Acc vs. Avg. T.)
81-78 (Avg. Acc Avg. T.)
QwQ-328 (Avg. Acc Avg. T.)
oflowSteer
FlowSteer
FlowSteer TAcC, Tookens
SEAL
1Acc, Tokeens
74
TAcG, ATokens
56
SEAL
86
Avg. Acc (%)
AlphaOne
Avg. Acc (%)
72
AlphaOne
Avg. Acc (%)
CoD
52
84
70
SEAL
Legits
CoD LogitsPenalty
CoD Vanilla LogitsPenalty
48
S1*
68
Vanilla
Vanilla
S1*
AlphaOne
44
66
80
5000
6000
7000 Avg. T.
8000
9000
4500
5000
5500
6000
6500
4000
4500
5000 Avg. T.
5500
Avg. T.
Figure 3: Average accuracy and token count aggregated across all benchmarks.
4.2 Alignment between steered and target distributions
FlowSteer achieves superior distributional alignment To quantify how well steered representations align with the target ones, we measure their distributional distance before and after steering. Both source and larget representations are extracted from the MATH/ /rain set. We first establish a baseline distance between the original source and target distributions ("Before Steering"). Next, we apply SEAL and FlowSteer to the source representations and mcasure the distance from each of the two resulting steered distributions to the target. We use three metrics: Maximum Mean Discrepancy (MMD) (Gretton et al. 2012), Fréchet Inception Distance (FID) (Heusel et al. 2017), and Kernel Inception Distance (KID) (Sutherland et al. 2018) (detailed in Section D As shown in Table FlowSteer consistently reduces distributional distance by large margin across all LRMs, often by more than an order of magnitude compared to the unstecred bascline. Morcover, it outperforms the linear steering method SEAL, achieving distances that are 5.4x lower in average. These results demonstrate that FlowSteer produces representations better aligned with the target manifold than lincar steoring, providing a strong quantitative explanation for its task performance reported in Table which we will analyze in the next subsection.
4.3 Evaluation on mathematical and coding tasks
FlowSteer achieves a competitive accuracy- token count trade-off As summarized by the average columns Table 2 and the scatter plots in Figure 3 FlowSteer consistently lies on the empirical accuracy- token Pareto frontier across all three LRMs. Specifically, FlowSteer achieves the best of both worlds on R1-7B with the highest accuracy and lowest token count; meanwhile, R11-1.BB and QwQ-32B, while there are baselines with lower token usage than FlowSteer, they substantially sacrifice accuracy. That said, there is an inherent tradc-off between accuracy and token usage: deeper reasoning can improve accuracy, but may consume more tokens. On challenging math benchmarks like AIME24 and AMC23, the accuracy gains of FlowSteer are particularly striking. For instance, with R.-11.5B on AMC23, FlowSteer reaches 72.5% accuracy, 6.0% absolute improvement over the strongest baseline (66.5%) while further reducing the token count by 14.5%. Furthermore, this strong performance not limited math; FlowSteer achieves the highest accuracy across all three LRMs the BineChdeBench coding task, demonstrating its cross-domain
8

---

Published in Transactions on Machine Learning Research (02/2026)
Table 2: Performance across various math and coding benchmarks. "Acc." " (1) denotes Pass@1 accuracy (%) "T." " (4) is the average number of generated tokens across all answers, and "T.@C" (L) is the average number of tokens in correct onswers. The best and second-best values are highlighted with bold and underline, respectively. "Vanilla" refers to the vanilla LRM without intervention. " "Average" shows the average performance across all benchmarks.
MATH500
GSMSK
AIME24
AMC23
LiveCodeBench
Average
Methods
Acc.
T.
T.C
Aoe.
T.
T. Acc.
T.
T.C
Ace.
T.
Tac
Aec.
T.
T.0C
Ace.
T.
T.aC
DeepSeck-HR RR---R1---- --siiiill--ee Qwen-1.5B
Vanilla
66.6
4785
2390
73.8
2072
819
6.7
13807
2735
52.5
6269
2998
21.2
7749
2372
44.2
6036
2263
s1*
69.8
7428
6188
69.0
0849
5799
26.7
14334
12498
47.5
9020
7936
19.0
8308
2606
46.4
9188
7005
CoD
73.0
4040
2093
79.5
2044
1004
20.0
12419
4264
47.5
6561
3000
20.5
8061
2394
48.1
6625
2551
Lenils
72.6
3847
1988
77.9
1360
716
10.0
13538
8801
50.0
6454
2709
21.2
7749
2331
46.3
6590
3309
AlphaOne
75.6
3858
3472
78.2
996
946
23.3
7314
6304
62.5
4550
4060
24.3
4927
4040
52.8
4329
3764
SEAL
78.2
3194
2003
81.0
968
732
33.3
10517
4792
66.5
4810
3256
23.3
7217
2380
56.5
5341
2633
FlowSteer
79.6
2915
1948
80.1
961
700
33.3
10211
3884
72.5
4111
2565
24.5
7217
2327
58.0
5083
2285
Deep R1 Distill Queen-
7B
Vanilla
87.0
3341
2605
87.9
1160
867
50.0
9903
5539
72.5
5431
3698
45.3
6799
3304
68.5
5327
3221
s1*
84.0
4846
4013
88.3
2782
2181
43.3
12060
8214
70.0
5900
4270
45.3
6976
3652
66.2
6531
4466
CoD
89.0
2397
2143
87.5
925
867
40.0
10595
4810
80.0
4360
2999
44.8
6431
3331
68.3
4942
2830
LogitsPenalty
88.0
2978
2333
87.4
902
758
40.0
10467
4914
77.5
4764
3244
44.0
6487
3367
67.4
6118
2923
AlphaOue
87.4
4070
3797
90.1
862
851
46.7
7605
6052
82.5
4820
4221
49.5
5256
4769
71.2
4523
3938
SEAL
90.2
2613
2158
88.4
846
754
46.7
9034
5223
90.0
3627
2919
50.0
6005
3183
73.1
4605
2847
FlowSteer
90.2
2549
2010
88.6
797
732
53.3
8453
4132
90.0
3177
2739
50.5
5930
3204
74.5
4181
2563
Qwen- QuQQ99B
Vanilla
90.8
3549
3027
95.6
1157
1069
63.3
10791
8486
80.0
6053
5067
77.5
5680
4499
81.4
5146
4429
s1*
91.4
4180
3744
96.3
1858
1753
70.0
10862
9073
85.0
6275
5618
76.2
5734
4479
83.8
5780
4933
CoD
91.0
3672
3346
96.1
1008
971
70.0
9499
8976
85.0
5169
4316
78.8
5370
4191
$1.2
4943
4360
LogitsPenalty
90.2
3135
2746
95.6
956
906
63.3
9942
8831
85.0
5779
5381
78.8
5993
4070
82.6
5161
4387
AlphaOne
91.6
3067
2908
94.8
866
876
53.3
6544
5165
82.5
4082
3573
78.2
5834
5646
80.1
4079
3634
SEAL
92.8
3102
2732
96.4
976
905
60.0
10795
8065
82.5
5452
4487
80.5
5036
3981
82.4
5072
4154
FlowSteer
91.0
3118
2675
96.5
917
857
76.7
9848
8355
90.0
5698
5220
81.2
5030
3970
87.1
4922
4215
81-1.58 5. (Avg. Acc Avg. T.@C)
R1-78 (Avg, Acc vs. Avg, T.@C)
QwQ-328 (Avg. Acc vs. Avg. T.@C)
FlowSteer
FlowSttee
FlowSteer
1Acc, 4 Tokens
74
1Acc, LoTeens
Acc, Tokens
56
SEAL
Avg. Acc (96)
AlphaOne
Avg. Acc (96)
72
AlphaOne
Avg. Acc (%)
CoD
52-
70-
SEAL
LegitsPenalty
Vanilla LogitsPenalty
48
82-
Pegitst
68
Vanilla
Vanilla a
s1*
AlphaOne
44
66
3000
4000
5000
6000
7000
2500
3000
3500
4000
4500
4000
4500
Avg. T@
Avg. T.@C
Avg. T.@C
Figure 4: Average accuracy as a function of average token count for correct answers.
versatility. To evaluate loken efficiency, we conduct a Wilcoxon signed-rank test in Section B comparing the average token counts of FlowSteer against the most accurate baseline. We restrict this comparison to benchmarks where FlowStcer and the strongest bascline attain comparable accuracy (an absolute difference below 5 percentage points). We introduce this constraint because a direct comparison of token counts can be misleading, attaining higher accuracy may require longer CoTs, a relationship we elaborate on in the
9

---

Published in Transactions on Machine Learning Research (02/2026)
Table 3: Ablation study on R1-1.3B. Results show that: (1) Median-IQR normalization and Huber loss are both essential for flow model training; their omission causes the steered LRM to produce random outputs until the maximum token limit exhausted. (2) Probabilistic guidance provides significant gains accuracy and token efficiency. See Section D.1 for additional LRM results.
MATHE00
GSMSK
AIME21
AMC23
LiveCodeBench
Data normalization Loss
Acc.
T.
T.BC
Acc.
T.
T.OC
Acc.
T.
T.aC
Aec.
T.
T.KC
Ace.
T.
T.0C
Vanilla LRM
66.6
4785
2390
73.8
2072
819
6.7
13807
2735
52.5
6269
2998
21.2
7749
2372
7-score MSE
0.4
9980
28
0.8
9421
2111
0.0
14999
0.0
10000
0.3
9966
4715
7-score + Huher
0.8
9799
2865
0.5
9980
2804
0.0
15000
0.0
10000
0.5
9676
2851
Median-IQU -QR - MSE
1.7
9735
2066
1.0
9557
1411
0.0
15000
0.0
10000
1.0
9519
2754
Median-IQU -Qiian--RR--- Huber
78.6
3168
2026
81.2
1071
782
13.3
11534
2996
67.5
4688
2919
21.0
7613
2660
Median- Huber + (x))))
79.6
2915
1948
80.1
961
700
33.3
10211
3884
72.5
4111
2565
24.5
7217
2327
subsequent paragraph. The one-sided p x 0.032 suggests that, at the 5% significance level, FlowSteer uses fewer tokens than the strongest baseline when achieving comparable accuracy.
FlowSteer prioritizes efficient reasoning over mere brevity A deeper analysis of token usage shows key advantage of our method. On AIME24 and LiveCodeBench, while methods like AlphaOne often produce shorter responses on average (column "T." in Table 2). this brevity does not consistently translate to the most concise reasoning for correct answers ("T.GC"). In contrast, FlowSteer requires fewer tokens to generate correct solutions on these benchmarks, as shown in Table 2 and Figure $ This suggests that FlowSteer does not merely shorten outputs, but more effectively streamlines the underlying reasoning paths required for successful outcome. This efficiency is particularly noteworthy given that FlowSteer successfully solves harder problems. As our study in Section C shows, problems correctly solved by FlowSteer up to 1.5x more difficult than those solved by AlphaOne. These challenging questions naturally demand longer Co'Is, which can increase the average token count. Thus, the superior performance of FlowSteer is rooted in adaptively allocating necessary reasoning to complex problems rather than compressing all reasoning paths.
4.4 Ablation study
Median-IQR normalization and Huber loss are necessary FlowSteer relies on two key components: robust training techniques and probabilistic guidance. The robust training techniques, specifically median- TQR normalization and Huber loss, are prerequisites for stability. Without them, the flow model is poorly fitted, causing the ODE solver to produce divergent steering trajectories during inference. This leads to unusable outputs and the trivial accuracy observed in Table 3
Probabilistic guidance substantially boosts performance As shown in Table 3 even without guid- ance, the base flow model improves accuracy in all benchmarks except LiveCodeBench and reduces token usage in all benchmarks except. AIME24, relative to the vanilla LRM. Adding probabilistic guidance yields a further substantial boost, consistently lowering token counts and increasing accuracy by up to 20% absolute improvement (on AIME24). Therefore, by helping representations escape low-velocity zones, the guidance mechanism enables more elfective compression of CoT's and unlocks higher accuracy. An additional ablation on the guidance strength 1) is presented in Section D.2
4.5 Analysis space and time complexity
Experimental setup We assess the computational efficiency of FlowSteer in Table 4 across all evaluated datasets. Besides the average accuracy ("Ace." and token count ("T.", we measure average tokens per sec- ond ("TPS"), end-to-end latency per answer ("Lat."), along with relative parameter overhead (*+Prms"). All inference benchmarks were conducted using NVIDIA A100 GPUs with the HF transforment library (Wolf
et al. 2020
10

---

Published in Transactions on Machine Learning Research (02/2026)
Table 4: Space and time analysis across LRMs. "Acc.,, "T." are the average accuracy and token count across all benchmarks, "TPS" is the number of tokens generated per second, "Lat." is the average time per answer in seconds, and Prmsss" is the relative parameter overhead.
R1-1.58
RI-7B
QuQ-33B
Methods
Acc. f
4
TPS
Lat. 4 +Prms 1 Acc. f
T.
TPS
Lat.
+ Prims 1 Acc.
T. 4
TPS Lat.
Prms 1
Vanilla
44.2
6936
39.1
177.4
0%
68.5
5327
37.8
140.9
0%
81.4
5446
27.7
196.6
0%
s1*
46.4
9188
39.0
235.6
0%
66.2
6531
37.7
173.2
0%
83.8
5780
27.6
209.4
0%
Col
48.1
6625
39.1
169.4
0%
68.3
4942
37.8
130.7
0%
84.2
4943
27.7
178.4
0%
LogitsPenalty
46.3
6590
39.0
169.0
0%
67.4
5118
37.7
135.8
0%
82.6
5161
27.5
187.7
0%
AlphaOne
52.8
4329
38.8
111.6
0%
71.2
4523
37.6
120.3
0%
80.1
4079
27.5
148.3
0%
SEAL
56.5
5341
38.4
139.1
0.1%
73.1
4605
37.2
123.8
0.1%
82.4
5072
27.4
185.1
0.11%
FlowSteer
58.0
5083
38.0
133.8
3.1%
74.5
4181
36.9
113.3
1.1%
87.1
4922
25.9
190.0
0.6%
Analysis of computational overhead and latency In Table | FlowSteer increases the parameters by only 0.6% 3.1% compared to the vanilla LRM. The introduction of the Flow Matching module results in minor reduction in TPS (e.g., a drop of approximately 1.8 TPS on QwQ-32B), However, despite the minor drop in TPS, FlowSteer achioves a reduction in end-to-end latency compared to the vanilla LRM across all model sizes. On R1-7B, FlowSteer achieves the lowest latency among all methods (113.3s) while simultaneously attaining the highest accuracy (74.5%). On R1-1.5B, FlowSteer ranks as the second-fastes method (133.8s), surpassed only by AlphaOne (111.6s), yet it significantly outperforms AnphaOne in accuracy (58.0% vs. 52.8%). On QwQ-32B, while some baseline methods achieve lower latency, they do so at the cost of performance degradat ion. For example, AlphaOne is faster (148.3<) but drops accuracy to 80.1%, and CoD (178.4s) reaches only 84.2%. In contrast, FlowSteer achieves a dominant 87.1% accuracy while maintaining latency (190.0s) that is still lower than the Vanilla model (196.6s). Finally, emphasize that our primary focus in to compress CoTss to achieve an improved accuracy-token count trade-off. Whereas reductions in token count represent a fundamental algorithmic efficiency, latency and TPS are implementationn-lpeendde metrics. Optimizations such as employing advanced ODE solvers (Lu et al. 2025) or faster Flow Matching models (Geng et al. 2025 Lu & Song 2025 Frans et al. 2025) might further enhance latency and throughput without compromising accuracy. We leave such explorations for future work.
5 Related work
Concise reasoning for LRMs
Two main directions have been explored to promotc conciseness in LRMs.
A first line of work focuses on inference-time interventions, which guide model behavior without modifying
parameters. These approaches operate at different levels, including prompts (Xu et al. 2025a), tokens (Xia
eet al.
2025
Muennighoff et al.] 2025 Zhang al. 2025 Wang et al. 2025a). and logits (Wang et al. 2025c
Yang al.
2025)
Our work falls under the subtype of representation steering (Park et al. 2025 Li et al.
2023
Liu et al.] 2024), which directly manipulates hidden states. While prior steering methods [Chen et al.
2025a
Zhao et al. 2025 Azizi et al.) 2025; Huang et al. 2025 Sheng et al. 2025 Eisenstadt et al.) 2025
have successfully improved reasoning efficiency, they typically apply a uniform steering vector, effectively
modeling a linear translation. FlowSteer extends this by learning a nonlinear velocity field, offering the expressivity needed to capture complex distributional shifts that linear approximations may not fully address. A complementary line of work uses Reinforcement Learning (RL) to fine-tune LRMs for producing shorter
CoTs (Kang et al., 2025 Munkhbat et al.) 2025 Chen al.) 2025b: Hou et al. 2025
Qiao et al. 2025
Dai et al., 2025 Yuan et al.) 2025; Xia et al. 2025 Luo et al. 2025 Xu et al. 2025b Fang et al. 2025
Xiang et al.] 2025p. These two lines are complementary and address different tradc-offs. RL-based methods modily the LRM weights to incentivize concise reasoning without intervening in the inference computation, though this often requires expensive fine-tuning. In contrast, inference- time methods avoid training costs and preserve the original model weights, but necossitate explicit manipulation of inputs, logits, or hidden states during generation. In principle, inference-time time interventions could be applied to RL-optimized models to provide additional control.
11

---

Published in Transactions on Machine Learning Research (02/2026)
Steering as distribution transport A growing body of work interprets representation steering through the lens of distribution transport. Recent approaches, such as LinearAcT (Rodriguez et al. 2025 ) address this by solving for optimal transport using a linear transformation. Another relevant development is Truth- Flow (Wang ct al. 2025b), which grounds steering in Flow Matching to enhance model truthfulness. Our work distinguishes itself from these approaches in both methodology and application. Unlike LinearAcT that adopts close-form linear mapping. we leverage Flow Matching to parameterize a nonlinear velocity field. While TruthFlow shares the Flow Matching foundation, it is tailored for truthfulness; in contrast, FlowSteer is designed to compress LRM reasoning paths. The distinct goals and challenges necessitate specific techni- cal innovations, including different training objectives and specialized inference-time guidance mechanism suited for reasoning efficiency.
Flow Matching Our approach is grounded in Flow Matching (Lipman et al. 2023 Liu 2022 Lipman
et al. 2024), a powerful generative modeling technique successful in domains like image and molecule gen-
eration [Labs 2024 Labs et al.) 2025 Esser al. 2024] Campbell et al. 2024]. Additionally, guidance mechanism often added to such models to align outputs with conditions like text. prompts (Dhariwal &
Nichol 2021
Ho & Salimans
2021
Karras et al. 2024).
6
Conclusion
We introduce FlowSteer, steering framework leveraging Flow Matching to facilitate efficient reasoning paths in LRMs. By learning nonlinear velocity field for distributional alignment, our method overcomes the limitations of linear steering. We solve key challenges in applying flows to LRM activations with ro- bust training and a specialized guidance mechanism. Empirical results actoss various reasoning tasks and model scales support the effectiveness of our approach, demonstrating that FlowSteer effectively reduces the discrepancy between the steered and target representation distributions. This alignment translates into improved accuracy and more concise Co'Is, particularly on challenging reasoning benchmarks.
While FlowSteer demonstrates strong performance, several avenues remain for further refinement. For in- stance, our current guidance mechanism utilizes Gaussian approximation with fixed strength; future itera- tions could explore non-Gaussian or adaptive alternatives to further enhance steering precision. Additionally, while we focused on the SEAL intervention protocol, extending FlowSteer to other intervention settings rep- resents a meaningful direction. Regarding computational overhead, solving the ODE for steering naturally incurs extra evaluation steps than línear operations. However, we anticipate this gap can be bridged by integrating recent advances in accelerating Flow Matching (Geng et al., 2025 Frans et al. 2025).
Looking forward, while linear steering has been widely adopted and proven effective for many applications, our work suggests that probabilistic, distributional alignment perspective offers valuable step forward. By grounding steering in Flow Matching, FlowSteer provides a flexible tool for manipulating LLM representa- tions between distributions associated with contrastive behaviors. This capability opens promising directions beyond efficient reasoning, such as improving model aligument or mitigating hallucination. We hope this work inspires further exploration into nonlinear, theoretically grounded interventions that not only improve efficiency but also ensure finer controllability and greater trustworthiness in large language models.
References
Janice Ahn, Rishu Verma, Renze Lou, Di Liu, Rui Zhangg and Wenpeng Yin. Large language models for mathematical reasoning: Progresses and challenges. In Proceedings of the 18th Conference of the European Chapter of the Association for Computational Linguistics: Student Research Workshop, pp. 225 237, 2024.
Team AlphaProof and Team AlphaGeometry. Ai achieves medver-medal standard solving international 178 mathomatical olympiad problems. DeepMind blog, 179:45, 2024.
Seyedarmin Azizi, Erfan Baghaei Potraghloo, Souvik Kundu, and Massoud Pedram. Activation steering for chain-of-thought compression. In NeurIPS 2025 Workshop Efficient Reasoning, 2025.
12

---

Published in Transactions on Machine Learning Research (02/2026)
Andrew Campbell, Jason Yim, Regina Barzilay, Tom Rainforth, and Tommi Jaakkola. Generative flows discrete state-spaces: Enabling multimodal flows with applications to protein co-design. In TCLR 2024 Workshop on Generative and Experimental Perspectives for Biomolecular Design, 2024.
Runjin Chen, Zhenyu Zhang, Junyuan Hong, Souvik Kundu, and Zhangyang Wang. SEAT: Steerable rea- soning calibration of large language models for free. In Second Conference Language Modeling, 2025a.
URL https://openreviesz wwwp/oorumidd
Xingyu Chen, Jiahao Xu, Tian Liang, Zhiwei He, Jianhui Pang, Dian Yu, Linfeng Song, Qiuzhi Liu, Mengfei Zhou, Zhuosheng Zhang, Rui Wang, Zhaopeng Tu, Haitao Mi, and Dong Yu. Do NOT think that much for 2+3=? on the overthinking of long reasoning models. In Forty-second International Conference on Machine Learning, 2025b.
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 to solve math word problems, 2021. URL htttps://axxiw.rr//aabbba wogp//b//////////o 14168
Marco Cuturi. Sinkhorn distances: Lightspeed computation of optimal transport. Advances in newral information processing systems, 26, 2013.
Mz Dai, Chenxu Yang, and Qingyi Si. S-GRPO: Early exit via reinforcement learning in reasoning models.
In The Thitty-ninth Ansual Conference on Neural Information Processing Systems, 2025.
Nicki Skafte Detlefsen, Jiri Borovec, Justus Schock, Ananya Harsh, Teddy Koker, Luca Di Liello, Daniel Stanel, Changsheng Quan, Maxim Grechkin, and William Falcon. Torchmetrics - measuring reproducibility in pytorch. Journal of Open Source Software, 7(70):4101, 2022.
Prafulla Dhariwal and Alexander Nichol. Diffusion models beat gans on image synthesis. Advances in neural information processing systems, 34:8780- 8794, 2021.
John R Dormand and Peter J Prince. A family of embedded runge-kutta formulae. Journal of computational and applied mathemalics, 6(1):19 26, 1980.
Roy Eisenstadt, Itamar Zimerman, and Lior Wolf. Overelocking Ilm reasoning: Monitoring and controlling thinking path lengths in llms. arXiv preprint SFf::2206.0724400 2025.
Patrick Esser, Sumith Kulal, Andreas Blattmann, Rahim Entezari, Jonas Müller, Harry Saini, Yam Levi, Dominik Lorenz, Axel Sauer, Frederic Boesel, et al. Scaling rectified flow transformers for high-resolution image synthesis. In Forty-first international conference on machine learning, 2024.
Gongfan Fang, Xinyin Ma, and Xinchao Wang. Thinkless: LLM learns when to think. In The Thirty- ninth Annual Conference on Neural Information Processing Systems, 2025.
V. Fomin, J. Anmol, S. Desroziers, J. Kriss, and A. Tejani. High-level library to help with training neural networks in pytorch. https:///ithhbb wtt
2020.
Kevin Frans, Danijar Hafner, Sergey Levine, and Pieter Abbeel. One step diffusion via shorteut models. In
The Thirteenth International Conference on Learning Representations, 2025. URL https:://oponrevierr
Zhengyang Geng, Mingyang Deng, Xingjian Bai, J Zico Kolter, and Kaiming He. Mean flows for one-step generative modeling, In The Thirty-ninth Annual Conference on Neural Information Processing Systems, 2025.
Arthur Gretton, Karsten M Borgwardt, Malte J Rasch, Bernhard Schölkopf, and Alexander Smola. A kernel two-sample test. The journal of machine learning rescarch, 13(1):723-773, 2012.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Poiyi Wang, Qihao Zhu, Runxin Xu, Ruoyu Zhang, Shirong Ma, Xiao Bi, al. Deepseck-r1 incentivizes reasoning in 1lms through reinforcement learning. Nature, 645(8081) :633 638, 2025.
13

---

Published in Transactions on Machine Learning Research (02/2026)
Vahid Hashemi, Jan Kietinský, Stefanic Mohr, and Emmanouil Seferis. canssian-based runtime detection of out-of-distribution inputs for neural networks. In International Conference on Runtime Verificalion. pp. 254 264. Springer, 2021.
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Mcasuring mathematical problem solving with the MATH dataset. In Thirty-fifth Conference on Neural Information Processing Systems Dalasels and Benchmarks Track (Round 2), 2021.
URL htttp:://pperreeeeeeee mett//orummdd=7Byyttttaa
Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. Advances in neural infor- mation processing systems, 30, 2017.
Jonathan Ho and Tim Salimans. Classifier-free diffusion guidance. In NewrIPS 2021 Workshop on Deep Generative Models and Downstream Applications, 2021.
Bairu Hou, Yang Zhang, Jiabao Ji, Yujian Liu, Kaizhi Qian, Jacob Andreas, and Shiyu Chang. Thinkprune: Pruning long chain-of-thought of Ilms via reinforcement learning. arXiv preprint arXiv:2504.01 2025.
Yao Huang, Huanran Chen, Shouwei Ruan, Yichi Zhang, Xingxing Wei, and Yinpeng Dong. Mitigating overthinking in large reasoning models via manifold steering. In Proceedings of the 39th Conference Newral Information Processing Systems (NewrIPS 2025), 2025.
Peter J Huber. Robust estimation of location parameter. In Breakthroughs in statistics: Methodology and distribution, pp. 492-518. Springer, 1992.
Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Armando Solar- Tezama, Koushik Sen, and Ton Stoica. Livecodebench: Holistic and contamination free evaluation of large language models for code. In The Thirteenth International Conference on Learning Representations, 2025. URL https://oponrevierr hwtp:oormm/dd-chattaya
Yu Kang, Xianghui Sun, Liangyu Chen, and Wei Zou. C3ot: Generating shorter chain-of-thought without compromising effectiveness. In Proceedings of the AAAI Conference Artificial Intelligence, volume 39, 2025.
pp.
Tero Karras, Miika Aittala, Tuomas Kynkäänniemi, Jaakko Lehtinen, Timo Aila, and Samuli Laine. Guiding diffusion model with bad version of itself. Advonces in Neural Information Processing Systems, 37: 53021, 2024.
Black Forest Labs. Flux.
2024.
Black Forest Labs, Stephen Batifol, Andreas Blattmann, Frederic Boesel, Saksham Consul, Cyril Diagne, Tim Dockhorn, Jack English, Zion English, Patrick Esser, Sumith Kulal, Kyle Lacey, Yam Levi, Cheng Li, Dominik Lorenz, Jonas Müller, Dustin Podell, Robin Rombach, Harry Saini, Axel Sauer, and Luke Smith. Flux.1 kontext: Flow matching for in-context image generation and editing in latent space, 2025.
URL
2506. 15742
Kenneth Li, Oam Patel, Fernanda Viégas, Hanspeter Pfister, and Martin Wattenberg. Inference-time inter- vention: Eliciting truthful answers from language model. Advances in Neural Information Processing Systems, 2023.
Yawei Li, David Rügamer, Bernd Bischl, and Mina Rezaci. Calibrating 1lms with information--hheorticc evidential deep learning. In The Thirteenth International Conference on Learning Representations, 2025.
Hunter Lightman, Vineet Kosaraju, Yuri Burda, Harrison Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Nya Sutskever, and Karl Cobbe. Let's verify step by step. In The Twelfth International Conference Learning Representations, 2024. URL https://opperreviee wwtt://orrum7ddd-8LLLpp
Yaron Lipman, Ricky TQ Chen, Heli Ben- Ben-Hamu, Maximilian Nickel, and Matthew Le. Flow matching for generative modeling. In The Fleventh International Conference Learning Represendations, 2023.
14

---

Published in Transactions on Machine Learning Research (02/2026)
Yaron Lipman, Marton Havasi, Peter Holderrieth, Neta Shaul, Matt Le, Brian Karrer, Ricky TQ Chen, David Lopez-Paz, Heli Ben-Hami, and Ttai Gat. Flow matching guide and code. or Xix preprint orXim:24 12. 12.06264, 2024.
Qiang Liu. Rectified flow: marginal preserving approach to optimal transport. arXiv preprint arXiv:2209. W1Xi:2209.145777, 2022.
Sheng Liu, Haotian Ye, Lei Xing, and James Y Zou. In-context vectors: Making in context learning more effective and controllable through latent space steering. In International Conference Machine Learning, pp. 32287-32307. PMLR, 2024.
Cheng Lu and Yang Song, Simplifying, stabilizing and scaling continuous-time consistency models. In The Thirteenth International Conference on Learning Representations, 2025. URL httpps://peereevies net/ forum/Sd--yJjibugyyJ>
Cheng Lu, Yuhao Zhou, Fan Bao, Jianfei Chen, Chongxuan Li, and Jun Zhu. + Fast solver for guided sampling of diffusion probabilistic models. Machine Intelligence Reseorch, pp. 1-22, 2025.
Haipeng Luo, Qingfeng Sun, Can Xu, Pu Zhao, Jian-Guang Lou, Chongyang Tao, Xiubo Geng, Qingwei Lin, Shifeng Chen, Yansong Tang, et al. Wizardmath: Empowering matheratical reasoning for large language models via reinforced evol-instruct. In The Thirteenth International Conference on Learning Representations, 2023.
Haotian Luo, Haiying He, Yibo Wang, Jinluan Yang, Rui Liu, Naiqiang Tan, Xiaochun Cao, Dacheng Tao, and Li Shen. Ada-r1: Hybrid-cot via bi-level adaptive reasoning optimization. In The Thirty-ninth Annual Conference Neural Information Processing Systems, 2025.
Mathematical Association of America. American mathematics competitions (amc) 10 and 12: Problems and answer keys, 2023. Accessod: 2025-09-07.
Mathematical Association of America. American invitational mathematics examination aime, 2024. Ac- cessed: 2025-05-15.
Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettle- moyer, Percy Liang, Emmanuel Candès, and Tatsunori B Hashimoto. sl: Simple test-time scaling. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 20286-
20332, 2025.
Tergel Munkhbat, Namgyu Ho, Seo Hyun Kim, Yongjin Yang, Yujin Kim, and Se- Young Yun. Self-training elicits concise reasoning in large language models. In Findings of the Association for Computational Linguisties: ACL 2025. Association for Computational Linguistics, 2025.
OpenAl. Learning to reason with llms. htttte/r/ooaaa.ccoo//eeeeeeeeeer 2024.
Kiho Park, Yo Joong Choe, and Victor Veitch. The linear representation hypothesis and the geometry of large language models. In Forty-first International Conference on Machine Learning, 2024.
Seongheon Park, Xuefeng Du, Min-Hsuan Yeh, Haobo Wang, and Yixuan Li. Steer Ilm latents for halluci- nation detection. In Forty-second International Conference on Machine Learning, 2025.
Ziqing Qiao, Yongheng Deng, Jiali Zeng, Dong Wang, Lai Wei, Guanbo Wang, Fandong Meng, Jie Zhou,
Ju Ren, and Yaoxue Zhang. Concise: ceffdenne-guidder compression in step-by-step efficient reasoning. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 8021-8040, 2025.
Qwen- Qwen-Team. Qwq: Reflect deeply on the boundaries of the unknown. attps:///wenll: github..hu..... 10/ hotthubb.oobog///// auq-32b-preview 2025.
15

---

Published in Transactions on Machine Learning Research (02/2026)
Pau Rodriguez, Arno Blaas, Michal Klein, Luca Zappella, Nicholas Apostoloff, marco cuturi, and Xavier Suau. Controlling language and diffusion models by transporting activations. In The Thirleenth Interna- tional Conference on Learning Representations, 2025.
Lcheng Sheng, An Zhang, Zijian Wu, Weixiang Zhao, Changshuo Shon, Yi Zhang, Xiang Wang, and Tat-Seng Chus. On reasoning strength h planning in large reasoning models. In The Thirly-ninth Annuaal Conference on Neural Information Processing Systems, 2025.
Mingjie Sun, Xinlei Chen, Zico Kolter, and Zhuang Liu. Massive activations in large language models. In First Conference on Language Modeling, 2024.
JD Sutherland, Michael Arbel, and Arthur Gretton. Demystifying mmd gans. In International conference for learning representations, volume 6, 2018.
Alexander Tong, Kilian FATRAS, Nikolay Malkin, Guillaume Huguet, Yanlei Zhang, Jarrid Rector-Brook Guy Wolf, and Yoshua Bengio. Improving and generalizing flow-based generative models with minibatch optimal transport. Transactions on Machine Learning Research, 2024. ISSN 2835-8856.
Chenlong Wang, Yuanning Feng, Dongping Chen, Zhaoyang Chu, Ranjay Krishna, and Tianyi Zhou. Wait, we don't need to "wait"! removing thinking tokens improves reasoning efficiency. In Christos Christodoullppolls,, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng (eds.), Pindings of the Associ- ation for Compulational Linguisties: EMNLP 2025, pp. 7459 7482, Suzhou, China, November 2025a. As- sociation for Computational Linguistics. ISBN 979-8-89176--35-7. doi: 10.18653/v /0t03//vv2222555 findings--eminn emnlp. 394. URL
Hanyu Wang, Bochuan Cao, Yuanpu Cao, and Jinghui Chen. Truthflow: Truthful LLM generation via representation flow correction. In Forty-second International Conference on Machine Learning, 2025b.
Yue Wang, Qiuzhi Liu, Jiahao Xu, Tian Liang, Xingyu Chen, Zhiwei He, Linfeng Song, Dian Yu, Juntao Li, Zhuosheng Zhang, Rui Wang, Zhaopeng Tu, Haitao Mi, and Dong Yu. Thoughts are all over the place: On the underthinking of long reasoning models. In The Thitty-ninth Annual Conference on Newral Information Processing Systems, 2025c.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoe V Le, Denny Zhou, et al. ohain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824 24837, 2022.
Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pier- ric Cistac, Tim Rault, Rémi Louf, Morgan Funtowiez, Joe Davison, Sam Shleifer, Patrick von Platen, Clara Ma, Yacine Jernite, Julien Plu, Canwen Xu, Teven Le Scao, Sylvain Gugger, Mariama Drame, Quentin Lhoest, and Alexander M. Rush. Transformers: Statc-of-the-art natural language processing. In Proceedings of the 2020 Conference on Empirical Methods in Natural Longuage Processing: System Demonstrations, 2020.
Heming Xia, Chak Tou Leong, Wenjie Wang, Yongqi Li, and Wenjie Li. TokenSkip: Controllable chain- of-thought compression LLMs. In Christos Christodonlopoulos, Tanmoy Chakraborty, Carolyn Rose, and Violet Peng (eds.), Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pp. 3351-3363, Suzhou, China, November 2025. Association for Computational Linguistics. URL https://aclanthoology org/
ISBN 979-8-89176-332-6 doi: 20266////112225.mmlppmm//
2025. wwnep-maaaaeeeeeeeeeeeeeeeeeemme 165/
Violet. Xiang, Chase Blagden, Rafael Rafailov, Nathan Lile, Sang T. Truong, Chelsea Finn, and Nick Haber. Just enough thinking: Efficient reasoning with adaptive length penalties reinforcement learning. NewrIPS 2025 Workshop on Efficient Reasoning, 2025.
Silei Xu, Wenhao Xie, Lingxiao Zhao, and Pengcheng He. Chain of draft: Thinking faster by writing less. arXiv preprint ar Xic: 18600, 2025a.
16

---

Published in Transactions on Machine Learning Research (02/2026)
Xiaoang Xu, Shuo Wang, Xu Han, Zhenghao Liu, Huijia Wu, Pei Pei Li, Zhiyuan Liu, Maosong Sun, and Zhaoleng He. A--thought: Elficient reasoning via bidirectional compression for low-resource settings. In The ninth Annual Conference on Newral Information Processing Systems, 2025b.
Adam X Yang, Maxime Robeyns, Xi Wang, and Laurence Aitchison. Bayesian low-rank adaptation for large language models. In The Twelfth International Conference Learning Representations, 2024.
Chenxu Yang, Qingyi Si, Yongjie Duan, Zheliang Zhu, Chenyu Zhu, Qiaowei Li, Zheng Lin, Li Cao, and Weiping Wang. Dynamic carly exit in reasoning models. orXiv preprint Xrxi:25504. 15895, 2025.
Hang Yuan, Bin Yu, Haotian Li, Shijun Yang, Christina Dan Wang, Zhou Yu, Xueyin Xu, Weizhen Qi, and Kai Chen. Not all tokens are what you need in thinking. aive preprinl arXiv:2505. 2025.
Junyu Zhang, Rumpei Dong, Han Wang, Xuying Ning, Haoran Geng, Peihao Li, Xialin Hc, Yutong Bai, Jitendra Malik, Saurabh Gupta, and Huan Zhang. Alphaone: Reasoning models thinking slow and fast at test time, In Proceedings of the 2025 Conference on Empérical Methods in Natural Language Processing (EMNLP), 2025.
Yang Zhang, Ashkan Khakzar, Yawci Li, Azade Farshad, Scong Tae Kim, and Nassir Navab. Fino-grained neural network explanation by identifying input features with predictive information. Advunces in Newral Information Processing Systems, 84:20040-20088 2021.
Weixiang Zhao, Jiahe Guo, Yang Deng, Xingyu Sui, Yulin Hu, Yanyan Zhao, Wanxiang Che, Bing Qin, Tat-Seng Chua, and Ting Liu. Exploring and exploiting the inherent efficiency within large reasoning models for self-guided efficiency enhancement. ar preprint Xrx::22006. 1e000.15644 15647, 2025.
17

---

Published in Transactions on Machine Learning Research (02/2026)
A Implementation details
A.1 Training Data Construction
Intervention protocol alignment with SEAL To ensure a fair and direct comparison, in Section we adopt the intervention protocol from SEAL (Chen et al. 2025a). Furthermore, we use the identical training data for both FlowSteer and SEAL. Specifically, we follow the data extraction procedure outlined by SEAL to create shared dataset of hidden representations from the MATH/trail dataset. This dataset is then used for two distinct purposes: (1) to compute the single, global steering vector for SEAL, and (2) to train the nonlinear flow model for FlowSteer.
A critical aspect the intervention protocol is consistency the intervention layer. The layer from which representations are extracted during training must be the same layer that steered during inference. We adopt the exact same target layers as SFAL:: layer 20 for the R1-1.5B and R1-7B models, and layer 55 for the QwQ-32B model. By keeping all experimental factors consistent except for the steering mechanism itself, we ensure that any observed performance differences can be directly attributed to the design of our nonlinear steering method rather than to confounding variables.
Source and target set construction The extraction process begins by running inference with the vanilla LRMs on the MATH/train dataset. From these outputs, we select balanced set of correctly and incorrectly solved problems. We use 500 correct and 500 incorrect samples for R1-1.5B, 1200 of each for R1-7B, and 1800 of each for QwQ-32B.
Following SEAL's methodology, we then populate the source and target representation sets. This involves categorizing the intermediate reasoning steps, which are demarcated by "\nkn" tokens, using collection of keywords (c.g., "Alternatively", "Wait"). This protocol labels cach step as one of three types: Transition, Reflection (verbose, self-correcting thought), or Excculion (concise, forward-progressingg thought). The hid- den state corresponding to the "I "\n)n" token at the end of each step selected as that step's representative hidden state. Representations from steps labeled as "Reflection" or "Transition" are added to the source set S (representing potentially verbose reasoning), while representations from "Execution" steps are added to the target set T (representing concise reasoning). This process often yields multiple source and target representations from a single problem. The final counts of the source-target representation pairs used for training are provided in Table
A.2 Flow model architecture
We implement the flow model as a Multi-layer Perceptron (MLP) with ReLU as activation function. The MLP accepts & (d + 1)-dimensional input, which is formed by concalenating the d-dimensional hidden representation from an LRM layer with the scalar time step t E [0, 1]. The network's output a d-dimensional vector, matching the dimension of the input representation. Additional architectural details, such as the number of layers and intermediate dimensions, are provided in Table
A.3 Training and inference configurations
Detailed hyperparameters for both training and inference are provided in Table 5 For the training phase, this includes optimizer settings, batch size, and the total number of iterations, etc. We highlight the efficiency of our approach: even the flow model for QwQ-32B can be trained single NVIDIA A100 GPU in under 24 hours.
For inference-time steering, the table specifies the ODE solver, the target LRM layer, and the solver's tolerances. Specifically, rtol and atol denote the relative and absolute tolerances for the adaptive ODE solver, respectively.
A.4 Hyperparameter sweep
To ensure a fair comparison, we perform a hyperparameter sweep for both the probabilistic guidance strength 7 of FlowSteer and the linear strength ? of SFAL over the grid (0.85, 0.90, 1.00, 1.10, 1.15). For each bench-
18

---

Published in Transactions on Machine Learning Research (02/2026)
Table 5: Implementation details of the flow models, including the configurations of the architecture, training and inference. In "Architecture", the "representation dimensions" refer to the hidden representation dimen- sions of the hosting LRM. In "ODE solver", the "rtol" denotes the relative tolerance, and the "atol" denotes the absolute tolerance.
Configuration
R1-1.5B
R1-7B
QwQ-32B
Representation dimensions
1536
3584
5120
Architecture
Intermediate dimensions
3072
3584
5120
Total (linear) layers
6
6
8
Question samples
1000
2400
3600
Source-target representation pairs
54,796
78,980
63,705
Learning rate
0.0001
0.0001
0.0001
Optimizer
Adam (betas= [0.90, 0.95]>
Training
Weight decay
0
Clip gradients
False
False
False
Learning rate decay
False
False
False
Iterations
1.7120
106
2.9616 x 106
2.7860 x 106
Batch size
32
32
32
ODE solver
@opri5(rto1=0.0011, atol=0.00 001)
Inference
Steering LRM layer
20
20
55
mark, 25% of the evaluation samples are held out as a validation set for the hyperparameter search. We then report the best-performing results for both FlowSteer and SEAL, with the optimal values for 1) and y detailed in Table 1 and Table 7 respectively.
As shown in Table the value 1 1.0 is robust choice that performs best in majority of settings. In Section D.2 we provide the ablation study on the guidance strength
Table The chosen values of the guidance strength 1j in FlowStecr.
MATH500
GSMSK
AIME24
AMC23
LiveCodeBench
R1-1.5B
0.9
1.0
0.85
1.0
1.0
R1-7B
1.0
1.0
1.0
1.15
0.9
QwQ-32B
1.0
1.15
1.0
1.0
1.0
Table 7: The chosen values of the linear strength y for SEAL.
MATH500
GSM8K
AIME24
AMC23
LiveCodeBench
R1-1.5B
1.0
1.0
1.0
0.9
1.15
R1-7B
1.0
0.85
1.0
1.10
1.0
QwQ-32B
1.0
1.0
0.85
1.0
1.0
19

---

Published in Transactions on Machine Learning Research (02/2026)
Table 8: Most accurate baseline used for token-usage comparison with FlowSteer in each model dataset set- ting. If the absolute accuracy gap between FlowSteer and the most accurate bascline is least 5 percentage points, the setting is omitted from the paired analysis and marked as |ACc 2
Model
MATH500
GSM8K
AIME24
AMC23
LiveCodeBench
R1-1.5B
SEAL
SEAL
SEAL Vanilla
AAcc| 25
AlphaOne
R1-7B
SEAL
AlphaOne
SEAL
SEAL
QwQ-32B
SEAL
SEAL
AAcc 2
|ACc 25
SEAL
B Statistical test of token usage
In this section, we conduct a statistical test on the token counts ("T." in Table 2 of FlowSteer against other baselines. A direct comparison of token counts can be misleading, as it ignores the entanglement between accuracy and token usage; lackling difficult questions to attain higher accuracy naturally requires longer CoTs, as discussed in Section [.3 and Section [C] Therefore, we narrow our focus test the hypothesis that, under comparable accuracy, FlowSteer generates fewer tokens than the best-performing baseline.
Concretely, for every LRM and benchmark combination in Table 2 first identify the most accurate baseline method. We then retain only those settings where the absolute accuracy difference between the baseline and FlowSteer is within 5 percentage points; otherwise, the setting is omitted, as it does not represent a fair "equaal-accuracy" comparison. This procedure yiclds 12 out of 15 configurations, with the selected strongest baselines outlined Table g For each retained comparison pair (strongest baseline vs. FlowSteer), we compute the average number of generated tokens across all answers, forming per-setting differences d: Thseeline Flowstterr, We then apply a one-sided Wilcoxon signed-rank test with the null hypothesis that the median difference is zero and the alternative hypothesis that FlowSteer uses fewer tokens (median(d:) > 0). Across the 12 settings, FlowSteer uses fewer tokens in 10 cases, and the Wileoxon test yields a one-sided 2 0.032. This result is statistically significant at the 5% level and supports our claim that, when achieving comparable accuracy, FlowSteer consistently improves efficiency by reducing token usage relative to strong baselines.
C A nuanced analysis of question difficulty and token usage on AIME24
In this section, we provide more nuanced analysis of the results in Table 2 to explain why FlowSteer consumess more tokens overall than AlphaOne AIME24 despite achieving higher accuracy. We hypothesize that this is because FlowStecr excels at solving more difficult problems, which inherently require longer solutions.
To investigate this, we first define a difficulty score for each question. Our metric uses the token length in the ground truth (GT) solution as proxy for difficulty. The longer the GT solution, the harder the problem. We normalize this value to derive the score Qi+) for the i-th question as follows:
T 6
Q(0
GT
(9)
Tain
where T(e is the token length of its GT solution, and Timin is the minimum GT token length across all questions in the AIME24 dataset. We then calculate the average difficulty score of all questions model answers correctly.
As shown in Table 9 FlowSteer consistently solves questions with the highest average difficulty score (col- umn "Difficult@CC", The average difficulty score of FlowStecr is 1.1 1.5x higher than that of AlphaOne. Since our difficulty metric is proportional to the GT solution length, these more challenging problems nat- urally demand more tokens to be solved correctly. This evidence suggests that FlowSteer's higher token
20

---

Published in Transactions on Machine Learning Research (02/2026)
Table 9: Performance on the AIME24 benchmark, analyzing accuracy, token efficiency, and the difficulty of solved problems. We report Pass0l accuracy (Acc. t), average generated tokens across all answers (T. 4), average tokens in correct answers (T.@C L), and the average difficulty of correctly answered ques- tions (Difficulty@C 1). The results show that AlphaOne uses the fewest tokens overall the AIME24 benchmark. However, FlowSteer consistently achieves superior accuracy by successfully solving more com- plex problems, as evidenced by its higher average difficulty score in solved problems.
Methods
Acc. 1
T. T.OC y Difficlty@C f
ReepSSukkRRt-Dssiil------eer Ri-iis------s---ll--- 1.5B
Vanilla
6.7
13807
2735
1.47
AlphaOne
23.3
7314
6304
2.16
FlowSteer
33.3
10211
3884
2.48
DeepSeek- R1 -iii----D---i-i---- Qwellll-uueen--- 7B
Vanilla
50.0
9903
5539
2.61
AlphaOne
46.7
7605
6052
2.28
FlowSteer
53.3
8453
4132
2.75
Qwen- QwQ-32B
Vanilla
63.3
10791
8486
3.10
AlphaOne
53.3
6544
5165
2.56
FlowSteer
76.7
9848
8355
3.93
consumption is direct result of its superior ability tackle complex problems that require more elaborate reasoning.
Additional study
D.1 Probabilistic guidance with various model scales
this subsection, we present a comprehensive ablation study to demonstrate the effectiveness of probabilistic guidance, verifying that its benefits generalize to larger models. The results are summarized in Table I0
Having already analyzed the guidance mechanism on the R1-1.5B model in Section here focus larger model scales. First, the R1-7B model, adding probabilistic guidance (compared to the baseline in row "w/o (x)) improves both accuracy (column " "Ace.") and average token usage (column "T.") across all five benchmarks. This is highlighted by a significant. 12.5% absolute accuracy improvement on AMC23. Next, We test if this advantage further gencralizes to QwQ-32B model. The performance gains persist, with accuracy increasing on all five benchmarks and token usage improving on four. Notably, the guidance still achieves substantial 10.1% accuracy improvement on AIME24 compared to the setting without guidance. These results confirm that the enhancements from our probabilistic guidance do not diminish model scale increases from 1.5B to 32B, highlighting the method's broad effectiveness and scalability to different model sizes.
D.2 Ablation study on guidance strength
In this subsoction, we quantitatively analyze the effect of the probabilistic guidance strength, 7). We evaluate the accuracy and average token count on the MATH500 and LiveCodeBench benchmarks across an expanded range of 7) (0.1, 0.85, 0.9, 1.0, 1.1, 1.15, 2.0). The results visualized in Figure 5 which presents
21

---

Published in Transactions on Machine Learning Research (02/2026)
Table 10: Ablation the probabilistic guidance on the R1-1.5B, R1-7B, and QwQ-32B LRMs.
MATH500
GSM8K
AIME24
AMC23
LiveCodeBench
Methods
Acc.
T.
T.aC
Acc.
T.
T.OC Acc.
T.
T.aC Acc.
T.
T.ac
Acc.
T.
T.aC
DeepSeok- R1-Distill Qwen-1..0
1.5B
Vanilla
66.6
4785
2390
73.8
2072
819
6.7
13807
2735
52.5
6269
2998
21.2
7749
2372
w/o (xr))
78.6
3168
2026
81.2
1071
782
13.3
11534
2996
67.5
4688
2919
21.0
7613
2660
w/ ge (e()))
79.6
2915
1948
80.1
961
700
33.3
10211
3884
72.5
4111
2565
24.5
7217
2327
DeepSeck- R1-Distill Seaiill-ween 7B
Vanilla
87.0
3341
2605
87.9
1160
867
50.0
9903
5539
72.5
5431
3698
45.3
6799
3394
w/o (((g))
90.0
2663
2236
88.3
803
734
53.3
8543
3737
77.5
4068
2627
48.3
6145
3128
w/ ge (xx)
90.2
2549
2010
88.6
797
732
53.3
8453
4132
90.0
3177
2739
50.5
5930
3204
Qwen QuQ-32B
Vanilla
90.8
3549
3027
95.6
1157
1069
63.3
10791
8486
80.0
6053
5067
77.5
5680
4494
w/o (xx))
90.2
3189
2655
96.1
968
886
66.6
9932
7398
85.0
5463
4662
79.5
5081
3879
w/ (x
91.0
3118
2675
96.5
917
857
76.7
9848
8355
90.0
5698
5220
81.2
5030
3970
accuracy line plots and average token count bar charts. For reference, the performance of the vanilla LRM baseline is included.
Our analysis yields the following observations:
Our method demonstrates robust performance across wide spectrum of guidance strengths. Substantial improvements in both accuracy and token reduction persist even at the boundaries of 17 = 0.1 and 1.5.
Broad effective range:
At low guidance strengths, the method remains stable but operates with reduced efficiency. While accuracy is generally maintained
Low guidance regime (17 0.1):
peak levels, the token reduction is smaller compared to the optimal range. We hypothesize that this is because the magnitude of the probabilistic guidance is insufficient to effectively push representations out of the "low-velocity zones" described in Section 3 resulting in partial stagnation and longer reasoning paths.
Optimal range (1 E [0.85, 1.15)): This range consistently yields the most favorable trade-off, achieving peak accuracy while simultancously minimizing token usage.
High guidance regime (n 2.0): At the highest strength tested, we observe a degradation in performance. While token counts are still reduced, accuracy often declines towards the vanilla baseline. This aligns with our derivation in Eq. (8) very high 1), the guidance term dominates the ODF dynamics, suppressing the flow model's contribution. This "over-steering" forces the trajectory to ignore the fine-grained structure of the target representation distribution, leading to suboptimal reasoning performance.
In summary, our probabilistic guidance demonstrates clear advantage over the baseline that is robust in the choice of 77. The behavior at the extremes (17 = 0.1 and = 2.0) is consistent with our theoretical expectations regarding the interplay between the learned flow field and the guidance term.
22

---

Published in Transactions on Machine Learning Research (02/2026)
0.84
5000
0.28
8500
FlowSteer Vanilla
FlowSteer
Avg. Tokems Across Samples
-4500
80000
0.80
0.26
4000
75.00
Accuracy
0.76
Across
Accuracy
0.24
3500
7000
0.72
0.22
0.68
2500
Avg.
0.20
6000
0.64
2000
0.18
5500
0.1
0.85
0.9
1.0
1.1
1.15
1.5
2.0
Vanilla
0.1
0.85
0.9
1.0
1.1
1.15
1.5
2.0
Vanilla
Probabilistic Guidance Strength
Probabilistic Guidance Strength
(a) R1-1.5B: MATH500
(b) R1-1.5B: LiveCodeBench
7500
FlowStoor
FlowSteer
Vanilla
Vanilla
Avg. Tokens Across Samples les
4000
7000
3500
All
65000
Accuracy
Accuracy
Avg. Takens
2500
00
2000
5000
Vanilla
Probabilistic Guidance Strength
Probabilistic Guidance Strength
(c) R1-7B: MATH500
(d) R1-7B: LiveCodeBench
Vanilla
All Samples
0.84
Vanilla
Avg. Tokens Across All Samples
4000
6000
0.82
3500
5500
Accuracy
Accuracy
3000
0.80
5000
Tokens
2250
443 00
2000
4000
0.1
0.85
1.5
2.0
Vanilla
0.1
1.15
1.5
2.0
Vanilla
Probabilistic Guidance Strength
Probabilistic Guidance Strength
(e) QuQ-32B: MATH500
(f) QwQ-32B: LiveCodeBench
Figure 5; The line plots report accuracy, while the bar plots show the average token count across all samples. The dashed line and the rightmost bar correspond the vanilla LRM bascline. For visual clarity, the bars are evenly spaced along the z-axis, although the underlying hyperparameter grid is uneven.
23

---

Published in Transactions on Machine Learning Research (02/2026)
E Distributional distance metrics
E.1 A brief introduction to MMD, FID, and KID
To quantitatively evaluate the aligmment between the steered representations and the target representations, we employ three established metrics in Section 4.2 Each provides a different lens through which to measure the distance between two sets of samples.
Maximum Mean Discrepancy (MMD) (Gretton al. 2012 a non-parametric mcasure that compares two distributions by mapping their samples into high-dimensionall Reproducing Kernel Hilbert Space (RKHS). If the distributions are identical, their mean embeddings in this space coincide. MMD computes the distance between these mean embeddings, with larger values indicating greater discrepancy. Its strength lies in its generality and strong theoretical guarantees, as it does not. impose assumptions on the underlying data distributions.
Fréchet Inception Distance (FID) (Heusel et al. 2017 originally proposed for evaluating generative image models, compares distributions of high-level features extracted by pre-trained network. Assuming these feature distributions follow multivariate Gaussians, FID computes the Fréchet distance (i.e., the Wasserstein-2 distance) between them, incorporating both mean and covariance.
Kernel Inception Distance (KID) [Sutherland et al. 2018) combines ideas from MMD and FID to address limitations of the latter. Like FID, relics on features from a neural network, but instead of assuming Gaussianity, KID applies the MMD framework with a polynomial kernel. This yields an unbiased estimator that often more stable than FID, particularly with limited sample sizes. As with FID, lower KID scores indicate smaller discrepancies between the distributions.
E.2 Implementation details the distance metrics
Since FID and KID were originally designed for image generation, they typically rely on a pre-trained network to extract high-level features. In our scenario, however, we apply these metrics directly to the hidden representations from LRMs. These representations already contain rich semantic information, making external feature extractor unnecessary.
Below are the specific implementation details for each metric:
MMD: We use the implementation from pytorch-ignite (Fomin et al. 2020). The performance of MMD is sensitive to its kernel variance hyperparameter, var. Setting it too large or small can make the metric insensitive. We determine this value empirically using a heuristic: we set var to be on the same order of magnitude as the squared norm of SEAL's steering vector, |/w|/2 as this value represents the squared distance between the empirical distribution means. The specific values used are 4,000 (for settings with R1-1.5B), 7,000 (R1-7B), and 26,000 (QwQ-32B). For readability in Table [ all reported MMD scores are scaled by a factor of 1,000.
FID: We also use the implementation provided by pytorch-ignite (Fomin et al. 2020
KID: Our implementation is adapted from torchmetrics (Detlefsen et al. 2022 We employ a polynomial kernel and use its default parameters: a degree (degree) of 3 and coefficient (coef) of 1.0.
F
Examples generated by the steered models
The example below contrasts the output the vanilla model with that of the model steered by FlowSteer. The vanilla model exhibits over-reflection, causing it to get stuck in a repetitive reasoning loop. This behavior ultimately lcads to the model exhausting the context and hitting the maximum token limit of 10,000 before finding solution. In contrast, the steered model produces a clear and efficient reasoning path that arrives at the final correct answer, using only 1,367 tokens.
24

---

Published in Transactions on Machine Learning Research (02/2026)
Example 1 with FlowSteer R11-1.B;; Tokens spent: 1,367
Question Prompt:
Answer the following questions. You should think step-by-step and put your final answer within {boxed(]. Question: For some real numbers and b, the equation
8x
4ax² + 2bx +
has three distinct positive roots. the sum of the baso-2 logarithms of the roots is 5, what is the value of a?
LRM's Answer:
<think> Okay, so have this problem here: there's cubic equation 8x 4ax² 2bx a and it's given that it has three distinct positive roots. Also, the of the base-2 logarithms of the roots is 5. I need to find the value of a. Hmm, let me think about how to approach this. First, I remember that for a cubic equation of the form pr + + + $ 0, the sum of the roots, the sum of the product of the rools two al a time, and the product of the rools can be found using Vieta's formulas. Maybe I can apply that here,
Let me denote the roots as r, 8, and t. Since all roots are positive, that might help later on. According to Victa's formulas for cubic equation pa + gx² + ræ + 0, we have:
1. + - 2. rt st 3. rst
In our case, the equation is 8x.2 + 4ax 2b = O. So, comparing to the general form, p = 8, = 4a, r= 2b, and == a. Applying Vieta's formulas:
1. Sum of roots: r+ ++s+1=-
- Sum of products two at time: rs rl + 3.
Product of roots: rst
We are also given that the sum of the base-2 logarithms of the roots is 5. That is:
log, r + log2 + logg L = 5
Using logarithm properties, this can rewritten as:
(8.))
Which implies:
8 . 25 32
From Vieta's formula, we already have rst = - So:
8 32
Solving for
a = 32
32 x 8 -256
8
So, is a -566? Wait, let me double-check that. Product of roots is rst 32, and from Vieta, rst So:
= 32
-56
Yes, that seems correct. But let me make sure that this is consistent with the other Victa's formulas. We have + 8 +
a Tf a 256, then:
25

---

Published in Transactions on Machine Learning Research (02/2026)
-256 128
r+s+i=
So, the sum of the roots is 128. That's pretty large number, but since all roots positive, that's possible.
Next, the sum of the products two at a time is rs + rl + st = -. But we don't know b, so maybe we don't need it. However, let's see if we can find b or it's not necessary for the answer.
We were given that all roots are distinct and positive. So, the cubic must have three distinct positive roots, which another condition. But since we only need to find a, and we've found a -256, maybe that's s sufficient.
Let me recap:
The product of the roots is 32, which is positive, so that's consistent with all roots being positive. The sum of the roots is 128, which is positive, so that's also consistent. The sum of the products two at a time is b/4, but since we don't have any information about b, we don't need to find it. So, unless there's a mistake in my reasoning, a = - should be the correct answer. Given that, think I'm confident with this result.
Final Answer The value of a is -256 </think>
Given the cubic equation 8x + 4ax² + 2br + a = with three distinct positive roots, we need to find the value a.
Using Vieta's formulas, know: The sum of the roots r+stt==---- 1s - The product of the roots rst
We are also given that the sum of the base-2 logarithms of the roots is 5:
log, r + log, log, t 5
This be rewritten using logarithm properties
log,(r
s. (r. =5
Thus, the product of the roots is:
r. 25 32
From Vieta's formula, we have:
rst a
8
Equating the two expressions for the product of the roots:
a
32
Solving for a:
-256
Thus, the value of a is -256
Ground Truth Answer: -256
26

---

Published in Transactions on Machine Learning Research (02/2026)
Example 1 with vanilla R1-1.5B; Tokens spent: 10,000
Question Prompt:
Answer the following questions. You should think step-by-step and put your final answer within {boxed(]- Question: For some real numbers and b, the equation
8x² + 4aa + 2bx + =
has three distinct positive roots. If the sun of the base-2 logarithms of the roots is 5, what is the value of a?
LRM's Answer:
<think> Okay, so I have this problem here: there's cubic equation 8x.3 + 4ax² + 2hx it's given that it has three distinct positive roots. Also, the sum of the base-2 logarithms of the roots is 5. I need to find the value of a. Hmm, let me think about how to approach this. First, I remember that for a cubic equation of the form pr + +qx² + O, the sum of the roots, the sum the product of the roots two at a time, and the product the roots can be found using Vieta's formulas. Maybe can apply that here.
and
Given the equation 8x 4ax + 2bx a 0, let me denote the roots as r, 8, and Since all roots are positive, that might. help later on. According Vieta's formulas for cubic equation pzd + qx² rx + 0, we have
1. 8 + = 2. 18 + rt + st = - 3. rst
g
In our case, p = 8,
4a, 2b, and = a. So plugging these into Vieta's formulas:
1. - +
4g = - 2. rs +t st 26 = 3. rst = =
Wait, hold on. The product the roots rst is equal to - which this case is - But since all roots are positive, their product should be positive. However, a is positive only if a is negative. So that tells that must be negative. That's important point.
Also, the sum of the roots + + - Since a is negative, this sum becomes positive. So, the sum of the roots is positive, which makes sense because all roots are positive.
The sum of the base-2 logarithms of the roots is given as 5. That is, log2 r + log2 + logg = 5. remember that the sum of logarithms is the logarithm of the product, so this can be rewritten as log2(rst)
Therefore, rst = 2 32.
But from Victa's formula, we also have rst - So, setting these equal:
32
Solving for
Multiply both sides by 8: a 256
Then, multiply both sides by -1: = 256
Wait, that seems straightforward. Let me doublc-chock to make sure didn't make any mistakes.
So, a = 256, then the product of the roots rst = - condition. So that seems correct.
256 32, which matches the given
But just to be thorough, let me check the other Vieta's formulas see if they hold with 256. First, the sum of the roots r + + - 256 128. So, the sum of the roots is 128.
The sum of the product of the roots two a time 4. Hmm, but we don't know b, so maybe we don't need find it. The problem doesn't give us any information about b, so perhaps we don't need to worry about that.
But just to make sure, let's see if the cubic equation with a = - 256 and some b would have three distinct positive roots. Since the problem states that it does, so as long as the cubic equation is constructed correctly, it should have three distinct positive roots.
Wait, but do we need to ensure that the cubic equation actually has three distinct positive roots? Because somctimes, even if the product positive, the roots might not be distinct or might not be positive. But the problem says does have three distinct positive roots, so perhaps we don't need to worry about that.
27

---

Published in Transactions on Machine Learning Research (02/2026)
But just to be safe, let me think about the discriminant of the cubic equation. The discriminant of cubic equation ax + hxz cr + d 0 is given by:
A = 18abed - 46 + 63c² 4ac² - 2f
But in our case, the equation is 8x + 4ax² + 2bx + a = 0. So, lct me write the discriminant for this equation.
Let me denote the equation as 8x + 4ax² + 2br + 0. So, coefficients are:
-p 1p=3 8 q--- 4a -
So, the discriminant A is:
A 18 4a 2b - 4, (4a)3 + (4a)3. (2h)² 8. (26)3 27 8² a²
Wait, that seems complicated. Maybe I can compute each term step by step.
First term: 1 4a 2b.cb
Compute constants: 18 * 8 = 144; 144 * 4 = 576; 576 1152; 1152 1152
Variables: a a² So, first term 1152
Second term: -4 (4a)
Compute constants: 43 64; 64 x 4 256; 256 * (-4) 1024
Variables: a² * a = a²
So, second term is - 1024a
Third term: (4a)² (26)²
Compute constants: 16 4 64
Variables: a² 6² d?6²
So, third term is 22
Fourth term: -4- 8 (26)3
Compute constants: 4 = 32; 32 8 = 256
Variables: 6²
So, fourth term is 25653
Fifth term: -27 82 a²
Compute constants: 27 64 1728
Variables: a²
So, fifth term is 2
Putting it all together:
1=12222- 1024a + 64a26² - 25663 1728a²
Simplify the constants:
1152a² 1728a² -
So, 276a 1024a + 64a 25613
Hmm, that's still complicated. Maybe can factor out some terms:
Factor out -64:
A = -64 + 16a - 2b 4b3)
But don't know if that helps. Maybe can plug in a -226 and see if the discriminant is positive, which would mean three distinct real roots.
Let me compute each term:
First, -256, so a ( (-256)² 65536
Compute each term:
1. 1152a 1152 65536. Tet compute that:
1152 65536: 1152 is 1024 + 128, so 1024 65536 67108864, and 128 65536 8388608. So
total is 67108864 + 8388608 = 75497472.
2. 1 = 10024 (65536) Wait, that's a huge number. Maybe don't need to compute it exactly because it's negative, but can note that it's a large negative number.
3. 64a21 = 64 * 65536 12 41943040"
4. -25663
5. 2 17228 65536 113462400
28

---

Published in Transactions on Machine Learning Research (02/2026)
So, putting it all together:
A = 75497472- 1024a² + 419430462 256 113462400
Simplify constants:
75497472 113462400 = -37964928
So, = -37964928 1024a* + 4194304422 256
Hmm, this is getting too complicated. Maybe I should think differently. Wait, maybe don't need to compute the discriminant because the problem only gives information about the sum of logarithms, which directly gives the product of the roots. So, perhaps I don't need to worry about the discriminant because the problem doesn't it specify anything else about the roots, like their distinctness or whether they are real or complex. It just says three distinct positive roots, so maybe the discriminant is positive, but don't need to compute it.
Alternatively, maybe can use the fact that the equation has three distinct positive roots, so the cubic must cross the x-axis three times, which would roquire that the function has a local maximum and minimum, and the function values those points on opposite sides of the x-axis. But that might be more involved. Alternatively, maybe can use the fact that the equation can be scaled transformed to make it easier.
Wait, another thought: since the product of the roots is 32, and the sum of the roots is 128, maybe can think of the roots as 32 divided by something, but don't 't know. Alternatively, maybe I can use substitution to make the equation simpler. Let me try substituting y = 2x, so that x = 2/2. Let's see if that helps. Substituting x = y/2 into the equation:
8(y/2)3 4a(y/2)² + 2b(y/2) + =
Compute each term:
8* (3² /8) yd
4a (y² /4) = ay²
2b * (y/2)= = by
So, the equation becomes:
y² + ay² + by b +
Hmm, that seems bit simpler. So, the equation is now y² + ay² by 0. Maybe this is casier to handle.
Now, since the original equation had three distinct positive roots, let 's see if the transformed equation also has three distinct positive roots. Since x = y/2, if x is positive, then is positive as well. So, the transformed equation has three distinct positive roots as well. But I don't know that helps me find a. Maybe can use Vieta's formulas on the transformed equation.
For the transformed equation y + ay² + by + O, the sum of the roots yı y22 1/3 -a, the sum of the product of roots two at time y132 y1vs V2u3 b, and the product of the roots /13/2/3 =
Wait, but in the original equation, the product of the roots was 32, so in the transformed equation,
the product is also 32. So, 91323/3 = -a 32. So, -a 32 = = 32. Wait, that's different from what I got earlier.
Wait, hold on. In the transformed equation, the product of the roots is a, which is equal 32. So, -a -a = 32 = -32. But earlier, using the logarithm condition, got 256.. That's contradiction. So, which one is correct?
Wait, perhaps made mistake in the substitution. Let me double-check.
Original equation: 3x + 4az² + 2bx + = 0
Substitute & = 2/2:
* (y/2)3 + 4a * (y/2)² + 26 * (y/2) + +a-
Compute each term:
8 (y /8) y²
4a (v2 /4) ay²
29

---

Published in Transactions on Machine Learning Research (02/2026)
2b (u/2) = by
So, equation becomes:
y² + +a²² + by + = Yes, that's correct. So, the product of the roots in the transformed equation is -a, which equals 32, so a= -32.
But earlier, using the logarithm condition, got a = -26.. So, which correct?
Wait, perhaps made a mistake in the substitution. Let me think again.
Wait, in the original equation, the product of the roots is 32, so rst 32. In the transformed equation, the product of the roots is also 32, y1 = 32. But in the transformed equation, the product is -a, -a 32 = -32
But in the original equation, the sum of the roots is r s + -a/2. So, if a = -32, then r + t 22 = 16. But earlier, from the logarithm condition, I had r + s t = 128. So, that's a contradiction.
Wait, 80 that suggests that a -32 not consistent with the sum of the rools being 128. So, perhaps my substitution is incorrect.
Wait, no, hold on. Let me think again. The original equation is 8x + 4ax + 2bx 0. The transformed equation is yd + ay² + by + O, where y 2x. So, the roots of the transformed equation are /11 2r, 1/2 2s, y3 = 21. So, the sum of the roots in the transformed equation is V1 32 + 2(r + t). From Vieta's formula, the sum of the roots in the transformed equation is aa. So, 2(r s t) = -a. Therefore, r + -a/2.
But in the original equation, the sum of the roots is r + 8 -a/2. So, if a -32, then r+ s ====+=-(32)/+ that's problem.
16. But carlier, from the logarithm condition, we had r + + 128. So,
Wait, if a 32, the sum of the roots is 16, but the problem says the sum is 128. So, that's inconsistent. Therefore, my substitution must be wrong. Wait, no, hold on. Let me think again.
The remaining outputs have been removed to save space. The vanilla model gets stuck in repetitive reasoning loops and reaches the mazimum token length limit before finishing its thinking process.
Ground Truth Answer: -256
30


Reviews:
[{"review_id": "MmeU1HpJ6G", "reviewer": "Reviewer_p3hQ", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "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": "Yes", "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": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper contributes FlowSteer, a nonlinear steering framework that leverages Flow Matching to achieve distributional alignment between verbose and concise reasoning, while introducing robust training strategies and a probabilistic guidance mechanism to resolve stability challenges and improve the accuracy-efficiency trade-off in Large Reasoning Models.\n\nStrengths and Weaknesses:\n\nThis paper presents an interesting and original idea, and the overall presentation is clear and well organized. The integration of Flow Matching into the proposed framework is appealing, and the empirical results suggest that the approach is effective in practice. However, the paper lacks strong theoretical guarantees. While some theoretical intuition is provided to explain why the method works, these insights remain informal and would benefit from more rigorous justification.\n\nIn addition, the method appears to rely on several hyperparameters. In practical applications, tuning such parameters often requires extensive exploration, which may increase computational cost and limit the method’s practicality. It is therefore unclear whether the approach can be considered cost-efficient or robust across different settings.", "claims_and_evidence_yn": "Yes", "claims_explanation": "1. The authors clearly convey the core concepts and procedural steps of their approach, making the general idea easy to understand.\n\n2. The study is supported by comprehensive experiments conducted across 3 LLMs and 5 diverse datasets, demonstrating robust evaluation.\n\n3. While FlowSteer does not show significant improvements in every single task or across all LLMs, it consistently performs either better than or close to state-of-the-art baselines like SEAL. Notably, FlowSteer often achieves comparable accuracy with greater token efficiency.", "audience_yn": "Yes", "audience_explanation": "Reasoning in LLMs is an inherently interesting research topic. Integrating Flow Matching into LLM reasoning tasks yields a new promising research direction.", "requested_changes": "Questions:\n\n1. Section 3.1 (Page 5): Loss Function Choice\n   As I understand it, the final loss used in practice is the Huber loss rather than the mean squared error (MSE). However, Equation (4) defines the MSE in expectation, whereas the Huber loss is presented without an expectation. Is the Huber loss also optimized in expectation, or is there a different interpretation?\n\n2. Section 3.2 (Page 5): Use of the High-Dimensional Hypothesis\n   The paper states: *“This provided evidence … original high-dimensional space.”* It is unclear where exactly this hypothesis is used prior to this statement. Could the authors explicitly indicate where this assumption is introduced and how it is leveraged in the methodology or analysis?\n\n3. Section 3.2 (Page 6): Parameter-Free Guidance\n   The paper claims to derive a *parameter-free guidance*, yet the method requires estimating the mean and variance. This seems contradictory. Could the authors clarify what is meant by “parameter-free” in this context? Does it mean that no additional trainable parameters are introduced, rather than no parameters at all?\n\n4. Appendix A (Page 18): Sensitivity to η\n   The reported values of η lie in a very narrow range (minimum 0.85, maximum 1.15). Does the method fail or become unstable for smaller or larger values of η? This appears to be a tight range, and some discussion of robustness or collapse behaviour would be helpful.\n\nWriting and Presentation Suggestions:\n\n5. Page 2:\n   The term *“Principle”* should be corrected to *“Principal”* when referring to Principal Component Analysis (PCA).\n\n6. Terminology Consistency:\n   The method name appears inconsistently as *Flowsteer*, *FlowSteer*, and *FLOWSTEER* (e.g., Figure 1). Please use a single, consistent naming convention throughout the paper.\n\n7. Text Coloring:\n   The use of blue-colored text (e.g., Pages 7–11) is unnecessary and distracting. Standard black text would improve readability and professionalism.\n\n8. References:\n   Several references are cited only as arXiv preprints. For works that have been published in conferences or journals, please cite the official publication venues instead of the arXiv versions. This is important for maintaining citation quality and formality during the review process.", "broader_impact_concerns": "NA", "additional_comments": "NA", "extra_scores": {}, "extra_text": {}}, {"review_id": "50P893PVdZ", "reviewer": "Reviewer_hX1Q", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "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": "Yes", "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": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper proposes a steering method based on non-linear mapping. The authors present novel contributions regarding data normalization, training objectives, and the steering mechanism itself, with rigorous mathematical reasoning. Experiments demonstrate that this approach can mitigate redundant thinking steps, simplify and accelerate the inference process, and improve overall performance. \n\nHowever, several claims and conclusions in the paper appear to lack sufficient empirical backing. As I am not deeply familiar with this specific topic, I cannot definitively judge whether these statements align with the current consensus in the field. Therefore, while the theoretical analysis is detailed, I have reservations about the reliability of certain statements without further experimental validation or consensus from the broader literature. I have outlined my specific concerns below. If the reviewers can provide supplementary results or citations to substantiate these points, I would consider raising my review result.\n\nStrengths:\n\n1.\tThe proposed method effectively addresses the limitations of existing steering methods that rely solely on linear mapping for hidden layers. By training a non-linear steering MLP, the paper improves the model's mapping capabilities.\n\n2.\tThe method is theoretically sound, with rigorous derivations and proofs provided for each component of the framework.\n\n3.\tThe method demonstrates comprehensive performance improvements over baseline models across multiple datasets.\n\n4.\tThe trained model exhibits strong generalization ability. It proves not only on different datasets within the same domain as training data but also generalizes well to datasets in other domains, indicating a robust improvement in reasoning capabilities.\n\nWeaknesses:\n\n1.\tIn Table 2, some results of FlowSteer show only marginal improvement over the second-best method (less than 1%). The authors do not specify whether these results represent a single run or the average of multiple runs. Without this information (and preferably standard deviations), it is difficult to assess the statistical significance and robustness of the results.\n\n2.\tThe baselines include various steering and prompting methods but exclude any SFT based methods. The \"concise reasoning\" data used to train the steering vector could directly serve as a training objective for SFT. Although the authors discuss the theoretical distinctions between SFT and steering, and highlight potential downsides of SFT like training speed, the absence of a direct empirical comparison makes it impossible to verify if the proposed method actually outperforms a standard SFT approach in terms of inference quality.\n\n3.\tThe efficiency analysis in Table 4 is limited, comparing FlowSteer only against the Vanilla method. The inference speeds of other baselines are not included, making it unclear how FlowSteer compares to other steering methods in terms of latency.", "claims_and_evidence_yn": "Yes", "claims_explanation": "See my strengths of summary.", "audience_yn": "Yes", "audience_explanation": "The proposed method is explained clearly with theoretical analysis and experimental results.", "requested_changes": "1.\tAdditional results are needed to better support the claims.\n\n2.\tIncluding the average performance across datasets in Table 2 would make the comparison clearer.", "broader_impact_concerns": "N/A", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "x8yYMXEtLu", "reviewer": "Reviewer_iiHA", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "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": "Yes", "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": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper introduces FlowSteer a new method for reducing the length of reasoning paths in LLMs. The basic idea is to learn how to move internal representation states of the LLM from states associated with longer reasoning paths (”source states”) to states associated with shorter reasoning paths (”target states”). At inference time, states that are likely to produce long reasoning paths can then be transformed using this learned transformation to reduce the reasoning path length.\n\n Prior work had gone this by identifying a linear transformation between the means of the source and target state distributions. This paper proposes instead to use flow matching to learn a flow that transforms the source distribution into the target distribution. The paper then introduces two tricks needed to make this work in practice: First they find that internal states in LLMs can have large outlier values and propose to address this by using a median-IQR normalization strategy for these states and to use the more robust Huber loss when training the flow model. Second, they find that regions of low velocity exist in the learned velocity field, which they address by adding approximate guidance that pushes samples towards the target distribution in these low velocity areas.\n\nThe experiments compare FlowSteer to various baselines on a set of mathematics and coding tasks. The implementation used here uses the same mechanism as SEAL (one of the baselines) to identify on which tokens to intervene, but uses FlowSteer to make the actual change to the internal states at these tokens. Compared to baselines, FlowSteer achieves equal or better answer accuracy while generally using fewer tokens to reach its answers. Ablation studies show that the median-IQR normalization and the use of the Huber loss in training the flow model are both essential to the performance of FlowSteer, and that the guidance is a smaller but still important factor.", "claims_and_evidence_yn": "Yes", "claims_explanation": "The method is described in sufficient detail in the main paper, and the appendix contains the necessary implementation details that would be needed to reproduce the results. FlowSteer is compared to a wide range of recent baselines, but I am not sufficiently familiar with the literature to judge whether any important baselines are missing. Performance is compared on a number of different tasks. The paper also contains ablation studies measuring the contribution of the different parts of FlowSteer to its performance and measurements of computational cost.", "audience_yn": "Yes", "audience_explanation": "This paper is relevant to people working on LLMs, especially those focused on improving the reasoning efficiency of these models.", "requested_changes": "I generally feel this is a strong paper, but the discussion on FlowSteer’s efficiency in correct reasoning (page 9) left me slightly confused, and I would appreciate if the authors could clarify the point they try to make. You point out here that compared to AlphaOne, FlowSteer uses fewer tokens in generating its correct answers, despite using more tokens across all answers. First, I don’t quite understand the relevance of this comparison, considering that the cost of generating the tokens is incurred irrespective of whether it is correct or not. Furthermore, although these results do indeed imply that FlowSteer streamlines reasoning paths towards successful outcomes and thereby uses fewer tokens for these, considering that FlowSteer still uses more tokens overall, does this not also imply at the same time that it uses more tokens to arrive at wrong answers?", "broader_impact_concerns": "No concerns beyond those inherent to any work in this area.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)