Paper deep dive
ThinkFuse: Trajectory-Aware Test-Time Fusion for Small Reasoning Models
Myunghoon Kang, Jungseob Lee, Jaehyung Seo, Heuiseok Lim
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 10/13/2026, 4:37:21 AM
Summary
The paper introduces ThinkFuse, a training-free test-time fusion framework designed to enhance the reasoning capabilities of Small Reasoning Models (SRMs). ThinkFuse addresses the issue of SRMs failing to recover from erroneous reasoning paths by selectively intervening in unreliable segments. It utilizes an Exponentially Weighted Causal Aggregation (EWCA) metric to calculate segment-level uncertainty and compares this against an adaptive threshold derived from trajectory-level trends. When uncertainty exceeds the threshold, an auxiliary model is invoked to generate alternative reasoning steps, which are then fused into the primary model's trajectory based on perplexity compatibility. Experiments on mathematical and knowledge-intensive benchmarks demonstrate that ThinkFuse outperforms existing baselines like Self-Consistency, Cool-Fusion, and AdaFuse, achieving higher accuracy with fewer fusion triggers and generated tokens.
Entities (12)
Relation Signals (11)
Myunghoon Kang → affiliatedwith → Korea University
confidence 95% · Myunghoon Kang... Affiliation: Department of Computer Science and Engineering, Korea University
Heuiseok Lim → affiliatedwith → Korea University
confidence 95% · Heuiseok Lim... Affiliation: Department of Computer Science and Engineering, Korea University
Jaehyung Seo → affiliatedwith → Konkuk University
confidence 95% · Jaehyung Seo... Affiliation: Department of Computer Science and Engineering, Konkuk University
Jungseob Lee → affiliatedwith → Korea University
confidence 95% · Jungseob Lee... Affiliation: Department of Computer Science and Engineering, Korea University
ThinkFuse → evaluatedon → MATH-500
confidence 95% · We evaluate ThinkFuse on two categories of reasoning benchmarks... MATH-500...
ThinkFuse → evaluatedon → GPQA-Diamond
confidence 95% · To assess knowledge-intensive reasoning capability, we use GPQA-Diamond...
ThinkFuse → improves → Small Reasoning Models
confidence 95% · ThinkFuse... selectively intervenes in unreliable reasoning segments... outperforms baselines... with consistent gains across model-family combinations.
ThinkFuse → uses → EWCA
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Small reasoning models (SRMs) have shown strong performance on complex reasoning tasks by generating extended chain-of-thought trajectories, but they often fail to recover once their reasoning enters an erroneous path. Existing test-time fusion methods rely on local fusion signals to determine when to trigger fusion, which can be misled by transient uncertainty fluctuations and may reinforce unstable reasoning trajectories. We propose ThinkFuse, a training-free test-time fusion framework that selectively intervenes in unreliable reasoning segments. ThinkFuse compares segment-level uncertainty shifts with trajectory-level uncertainty trends to identify unstable reasoning points and fuse auxiliary reasoning paths into the primary model's trajectory. Extensive experiments demonstrate that ThinkFuse outperforms baselines on mathematical and knowledge-intensive reasoning benchmarks, with consistent gains across model-family combinations, and remains robust with a smaller primary model. Our analysis shows that ThinkFuse requires fewer fusion triggers and generates fewer tokens, highlighting the efficiency of selective triggering. Our code is available at this https URL.
Tags
Links
- Source: https://arxiv.org/abs/2610.07803v1
- Canonical: https://arxiv.org/abs/2610.07803v1
Trouble viewing inline? Open PDF directly →
Full Text
71,834 characters extracted from source content.
Expand or collapse full text
ThinkFuse: Trajectory-Aware Test-Time Fusion for Small Reasoning Models Myunghoon Kang †thanks: These authors contributed equally to this work. Affiliation: Department of Computer Science and Engineering, Korea University Affiliation: chaos8527, omanma1928, limhseok@korea.ac.kr Jungseob Lee11footnotemark: 1 Affiliation: Department of Computer Science and Engineering, Korea University Affiliation: chaos8527, omanma1928, limhseok@korea.ac.kr Jaehyung Seo Affiliation: Department of Computer Science and Engineering, Konkuk University Affiliation: seojae777@konkuk.ac.kr Heuiseok Lim †thanks: Corresponding author Affiliation: Department of Computer Science and Engineering, Korea University Affiliation: Human-inspired AI Research Affiliation: chaos8527, omanma1928, limhseok@korea.ac.kr Abstract Small reasoning models (SRMs) have shown strong performance on complex reasoning tasks by generating extended chain-of-thought trajectories, but they often fail to recover once their reasoning enters an erroneous path. Existing test-time fusion methods rely on local fusion signals to determine when to trigger fusion, which can be misled by transient uncertainty fluctuations and may reinforce unstable reasoning trajectories. We propose ThinkFuse, a training-free test-time fusion framework that selectively intervenes in unreliable reasoning segments. ThinkFuse compares segment-level uncertainty shifts with trajectory-level uncertainty trends to identify unstable reasoning points and fuse auxiliary reasoning paths into the primary model’s trajectory. Extensive experiments demonstrate that ThinkFuse outperforms baselines on mathematical and knowledge-intensive reasoning benchmarks, with consistent gains across model-family combinations, and remains robust with a smaller primary model. Our analysis shows that ThinkFuse requires fewer fusion triggers and generates fewer tokens, highlighting the efficiency of selective triggering. Our code is available at https://github.com/js-lee-AI/ThinkFuse. 1 Introduction Figure 1: Overview of ThinkFuse framework. ThinkFuse monitors the segment-level uncertainty of the primary model MpM_p using an adaptive threshold θ. Upon detecting uncertainty spikes, it invokes an auxiliary model MaM_a to generate alternative reasoning steps. Both trajectory candidates are then evaluated for compatibility by MpM_p via perplexity (PPL), fusing the most compatible segment into the context. This procedure iterates until the reasoning reaches a terminal state. Large Reasoning Models (LRMs) have demonstrated strong performance in complex problem-solving tasks due to their extensive chain-of-thought reasoning Yang et al. (2025); DeepSeek-AI (2025); Jiang et al. (2025); Wang et al. (2026). By generating exploratory and self-reflective reasoning traces within thinking blocks (e.g., <think>...</think>), these models make intermediate reasoning explicit, thereby improving their ability to solve tasks that require multi-step inference, planning, and verification Shao et al. (2024); Ding et al. (2025); Yu et al. (2025). While LRMs have established strong baselines across diverse reasoning-intensive domains Xu et al. (2025a), small reasoning models (SRMs) struggle to generalize effectively to mathematical and coding tasks Zhuang et al. (2025); Souza et al. (2025). Scaling down reasoning models while preserving their reasoning capabilities thus remains a critical challenge Tian et al. (2025); Chen et al. (2025); Lee et al. (2026). To mitigate this reasoning gap without additional training, test-time fusion has emerged as a promising direction that combines complementary reasoning traces from multiple models Halim et al. (2025); Guo et al. (2025); Liu et al. (2025); Yao et al. (2025); Xu et al. (2025b); Cui et al. (2026). Previous works have primarily focused on fusion granularity, ranging from post-generation sample-level aggregation Wang et al. (2023); Yao et al. (2025) to token or span-level fusion during generation Liu et al. (2025); Xu et al. (2025b). However, the triggering policy of fusion remains underexplored: when should fusion be initiated, and what evidence should justify the intervention? Existing methods rely on local uncertainty signals at specific decoding steps or predefined fusion points, which fail to capture how uncertainty evolves across the reasoning trajectory. As a result, they may confuse transient uncertainty with reasoning instability, causing premature, delayed, or unnecessary fusion Li and Goyal (2026); Sun et al. (2026). In this paper, we present ThinkFuse, a novel reasoning-path fusion framework for reasoning models. ThinkFuse compares segment-level uncertainty shifts with trajectory-level uncertainty trends to identify unstable reasoning points and fuse auxiliary reasoning paths into the primary model’s trajectory. Specifically, it invokes the auxiliary model only when the current primary model’s reasoning segment exhibits elevated uncertainty relative to the model’s recent uncertainty profile. To this end, we propose the Exponentially Weighted Causal Aggregation (EWCA) metric to aggregate token-level uncertainty, which captures intra-segment uncertainty dynamics. ThinkFuse then compares the resulting segment uncertainty with an adaptive threshold estimated from the primary model’s historical uncertainty statistics and cumulative fusion frequency. This design regularizes fusion behavior by reducing unnecessary intervention while reserving auxiliary reasoning for uncertain segments. In summary, our paper makes the following contributions: • We propose ThinkFuse, a reasoning-model-oriented test-time fusion framework that identifies unreliable reasoning segments using an EWCA-based uncertainty metric and adaptive threshold. • Through extensive experiments on mathematical and knowledge-intensive reasoning benchmarks, we observe that ThinkFuse outperforms test-time scaling and test-time fusion baselines, with consistent gains across model-family combinations, and remains robust with a smaller primary model. • We analyze the behavior of ThinkFuse and show that it achieves these gains with fewer fusion actions and fewer generated tokens, demonstrating the effectiveness and efficiency of selective fusion triggering for reasoning models. 2 Related Work Method Intervention unit Selective trigger Multi-model fusion Trajectory-aware Decision basis Self-consistency (Wang et al., 2023) answer × × × post-hoc majority voting Cool-Fusion (Liu et al., 2025) segment × ✓ × fuses at every segment AdaFuse (Cui et al., 2026) word / span ✓ ✓ × local token confidence MUR (Yan et al., 2026) step ✓ × ✓ single-model momentum uncertainty SpecReason (Pan et al., 2025) step × ✓ × verifies every drafted step ThinkFuse (ours) segment ✓ ✓ ✓ trajectory-calibrated segment uncertainty Table 1: Triggering policies of test-time methods. Intervention unit denotes the granularity at which each method acts on the reasoning process, Selective trigger denotes whether auxiliary computation is invoked only at selected points, Multi-model fusion denotes whether a second model contributes to the trajectory, and Trajectory-aware denotes whether the decision is calibrated against the history of the ongoing trajectory. 2.1 Test-Time Ensembling and Fusion for Large Language Models Test-time ensembling offers a training-free paradigm to enhance the reasoning of Large Language Models (LLMs) by aggregating diverse reasoning candidates from complementary model behaviors. Previous works predominantly optimize fusion granularity, spanning macro-level interventions, such as answer-level consensus Wei et al. (2022); Wang et al. (2023), response-level ranking Jiang et al. (2023), and token-level aggregation Yao et al. (2025), to intermediate structures like segments Liu et al. (2025), spans Xu et al. (2025b), and adaptive units Cui et al. (2026). However, these granularity-centric approaches overlook the temporal dynamics of ongoing reasoning trajectories, specifically when to invoke auxiliary computation. ThinkFuse addresses this gap through a trajectory-aware fusion framework, dynamically triggering auxiliary reasoning by calibrating local segment-level uncertainty against the primary model’s historical uncertainty statistics. 2.2 Large Model Guided Reasoning Correction and Collaboration Previous works leverage LLMs to enhance the reasoning capabilities of smaller models, either through offline chain-of-thought supervision Ranaldi and Freitas (2024) or as external verifiers during online self-correction Zhang et al. (2024). Beyond training-time guidance, recent works explore test-time collaboration via model routing. For instance, Gupta et al. (2024) employ uncertainty-based rules to defer generations to stronger models, and CITER Zheng et al. (2025) utilizes a trainable token-level router to balance generation quality and inference costs. However, these paradigms are primarily designed for passive cost-aware routing mechanisms, rather than active interventions. In contrast, ThinkFuse prioritizes on-the-fly reasoning-path fusion, dynamically invoking auxiliary models only when local segment-level uncertainty indicates a deviation in the primary model’s ongoing trajectory. 2.3 Uncertainty-Guided Test-Time Scaling Recent works leverage model uncertainty to modulate test-time scaling. Certaindex Fu et al. (2024) estimates the certainty of reasoning progress to schedule the inference budget, and DeepConf Fu et al. (2026) filters and weights sampled traces by confidence within parallel scaling. MUR Yan et al. (2026) tracks momentum-smoothed step-level uncertainty within a single trajectory and allocates extra computation to uncertain steps. SpecReason Pan et al. (2025) instead lets a small model draft each step and a larger model verify every draft through prompting-based scoring. Rather than allocating computation within a single model or verifying every step, ThinkFuse employs uncertainty to trigger selective fusion. By calibrating segment-level uncertainty against the primary model’s trajectory history, it delegates only unreliable segments to an auxiliary model and integrates the continuation based on trajectory compatibility. 3 Methodology 3.1 Overview We present ThinkFuse, a novel fusion framework for reasoning models. The overall mechanism of ThinkFuse is shown in Figure 1 and Algorithm 1. Given a complex reasoning task x, ThinkFuse prompts the primary reasoning model MpM_p to generate a reasoning path. Leveraging the Exponentially Weighted Causal Aggregation (EWCA) metric and an adaptive threshold θ, the framework monitors uncertainty at the segment level, capturing both internal transition variance and the overall progress of the cumulative trajectory. Once the segment-level uncertainty exceeds the adaptive threshold, ThinkFuse evaluates the primary and auxiliary segments guided by primary-model perplexity under the current context, and extends the reasoning trajectory with the more compatible segment. Table 1 positions ThinkFuse against existing test-time scaling methods along three axes. Existing methods either fuse at every segment or rely on local token confidence, and uncertainty-guided scaling methods operate within a single model. ThinkFuse is the only method that combines selective triggering, trajectory-aware calibration, and multi-model fusion. 3.2 Segment-level Fusion Monitoring Algorithm 1 ThinkFuse: soft-budget adaptive segment fusion 1: task x, models Mp,MaM_p,M_a, hyperparameters T,α,β,η,μ0,σ0,τ,λT,α,β,η, _0, _0,τ,λ 2: response y 3: cp,ca←Encode(x)c_p,c_a← Encode(x); y←ϵy←ε; n,f,R←0n,f,R← 0 4: (μ,σ)←(μ0,σ0)(μ,σ)←( _0, _0) 5: while not done do 6: sp,ℓp←Mp(cp,T)s_p, _p← M_p(c_p,T); s∗←sps^*← s_p 7: if </think>∉y </think>∉ y then 8: U←EWCA(Entropy(ℓp))U (Entropy( _p)) 9: θ←(μ+τσ)(1+λR2)θ←(μ+τσ)(1+λ R^2); update (μ,σ)(μ,σ) 10: if U≥θU≥θ then 11: sa←Ma(ca,T)s_a← M_a(c_a,T); ←Align(sp,sa)S← Align(s_p,s_a) 12: s∗←argmins∈PPLMp(s∣cp)s^*← _s PPL_M_p(s c_p); f←f+1f← f+1 13: end if 14: n←n+1n← n+1; R←f/nR← f/n 15: end if 16: y←y⊕s∗y← y s^*; (cp,ca)←Sync(s∗)(c_p,c_a)← Sync(s^*) 17: end while 18: return y Recent studies suggest that reasoning trajectories are organized into thought-level segments, where transition markers such as ‘wait’ or ‘alternatively’ often indicate shifts in reasoning state Lu et al. (2025); Wang et al. (2025). Motivated by this view, ThinkFuse monitors uncertainty at the segment level rather than relying directly on isolated token-level signals, which can be sensitive to local lexical or discourse fluctuations. Instead of relying on such transition markers as explicit segmentation cues, ThinkFuse monitors uncertainty fluctuations of the reasoning trajectory over fixed-length segments. Let ckc_k denote the reasoning context before generating the k-th segment, and skp=(yk,1p,…,yk,Tp)s_k^p=(y_k,1^p,…,y_k,T^p) be the segment generated by the primary model MpM_p conditioned on ckc_k, where T is the segment length. For each token yk,ipy_k,i^p, ThinkFuse employs normalized Shannon entropy over the top-r log-probability distribution returned by the primary model: uk,ip=−∑v∈k,ip~k,i(v)logp~k,i(v)log|k,i|u_k,i^p=- _v _k,i p_k,i(v) p_k,i(v) |V_k,i| (1) where k,iV_k,i denotes the set of r highest-probability candidate tokens at position i, and p~k,i p_k,i denotes the corresponding distribution renormalized over k,iV_k,i. Intra segment uncertainty calculation To aggregate token-level uncertainty into a segment-level signal, ThinkFuse applies EWCA by assigning each token uncertainty uk,ipu_k,i^p a weight based on its relative position and the accumulated uncertainty of preceding tokens: wk,i=exp(α⋅i)⋅∏j<i(1+β⋅uk,jp)w_k,i= (α· i)· _j<i(1+β· u_k,j^p) (2) where α controls later-token emphasis and β controls uncertainty accumulation. The segment-level uncertainty UkpU_k^p for the k-th segment is computed as Ukp=∑i=1Tkwk,iuk,ip∑i=1Tkwk,i.U_k^p= _i=1^T_kw_k,iu_k,i^p _i=1^T_kw_k,i. (3) Inter-Segment Adaptive Thresholding The same uncertainty value can have varying implications depending on the model’s recent reasoning trajectory. To this end, ThinkFuse employs a triggering policy with an adaptive threshold θk _k. At each step k, given the primary model’s segment-level uncertainty UkpU_k^p, the historical trajectory’s mean uncertainty μk _k and deviation scale σk _k are iteratively updated via an exponential moving average: μk=(1−η)μk−1+ηUkp _k=(1-η) _k-1+η U_k^p (4) σk=(1−η)σk−1+η|Ukp−μk−1| _k=(1-η) _k-1+η|U_k^p- _k-1| (5) θk=(μk−1+τ⋅σk−1)⋅(1+λ⋅Rk−12) _k=( _k-1+τ· _k-1)·(1+λ· R_k-1^2) (6) where η∈(0,1)η∈(0,1) is the decay factor and τ controls the deviation margin. To budget the overall fusion, we introduce Rk−1R_k-1 as the cumulative fusion ratio scaled by soft budget parameter λ. This quadratic modulation penalizes excessive fusion by increasing the threshold as fusions accumulate. By triggering intervention only when Ukp≥θkU_k^p≥ _k, ThinkFuse effectively isolates and targets localized uncertainty spikes. 3.3 Trajectory compatibility scoring When the fusion trigger activates, ThinkFuse invokes the auxiliary reasoning model MaM_a to generate an alternative segment skas_k^a conditioned on the current context ckc_k. It then treats skps_k^p and skas_k^a as candidate continuations and uses the primary model MpM_p as a trajectory-compatibility scorer: ℓk(s)=PPLMp(s∣ck), _k(s)=PPL_M_p(s c_k), (7) for each candidate segment, the selected segment is then defined as sk⋆=skp,Ukp<θkargmins∈skp,skaℓk(s),Ukp≥θk,s_k = casess_k^p,&U_k^p< _k\\ _s∈\s_k^p,s_k^a\ _k(s),&U_k^p≥ _k, cases (8) Then, ThinkFuse appends the selected segment to update the reasoning context: ck+1=ck⊕sk⋆c_k+1=c_k s_k (9) The primary model then continues generation from the updated context: sk+1p∼Mp(⋅∣ck+1)s_k+1^p M_p(· c_k+1) (10) and this procedure repeats until the reasoning trajectory reaches a terminal state. 4 Experimental Setup 4.1 Models We conduct experiments using six open-weight reasoning language models: Qwen3-4B Yang et al. (2025), Qwen3-1.7B Yang et al. (2025), DeepSeek-R1-Distill-Qwen-1.5B DeepSeek-AI (2025), Ministral-3B-R Liu et al. (2026), EXAONE-Deep-2.4B Bae et al. (2025b), and EXAONE-4.0-1.2B Bae et al. (2025a). These models span multiple model families and cover a practical small-scale regime from 1.2B to 4B parameters, allowing us to evaluate whether ThinkFuse can improve reasoning without relying on larger proprietary models. The model pool includes both reasoning-specialized models, such as Ministral-3B-R and EXAONE-Deep-2.4B, and hybrid or instruction-following models with reasoning-oriented generation capabilities, such as Qwen3-4B, Qwen3-1.7B, and EXAONE-4.0-1.2B. This diversity is important for ThinkFuse, as the framework is designed to exploit complementary reasoning trajectories across models rather than assuming homogeneous decoding behaviors or failure modes. 4.2 Baselines We compare ThinkFuse against three types of baselines. Standalone evaluates each reasoning model independently, allowing us to assess whether ThinkFuse provides gains beyond each model’s original reasoning capability. Test-time fusion methods include Cool-Fusion (Liu et al., 2025), a segment-level fusion method that selects model-generated continuations using perplexity-based scoring, and AdaFuse (Cui et al., 2026), an adaptive ensemble decoding method that dynamically adjusts word/span-level fusion based on model confidence. Test-time compute baselines Self-consistency (Wang et al., 2023) generates K∈3,5K∈\3,5\ sampled reasoning paths with Qwen3-4B. Each final answer is normalized using the same answer parser as the main evaluation, and the prediction is determined by majority voting over normalized answers. If no normalized answer obtains a majority, we use the first generated sample as the final prediction. ThinkFuse evaluates our reasoning-path fusion framework under both cross-family and same-family model pairs, including configurations with either a larger or smaller primary model. Method MATH-500 GSM8K AIME24 GPQA NQ-Open Standalone models Qwen3-4B 89.0 92.0 53.3 54.0 29.5 Qwen3-1.7B‡ 83.0 90.0 33.3 39.4 28.0 Ministral 32.5 67.0 0.0† 25.8 24.0 EXAONE-4.0 57.0 85.0 3.3† 38.9 22.0 Test-time compute baseline: Qwen3-4B Self-consistency (K=3K=3) 89.5 (+0.5) 94.5 (+2.5) 53.3 (+0.0) 51.0 (−-3.0) 39.0 (+9.5) Self-consistency (K=5K=5) 88.0 (−-1.0) 94.5 (+2.5) 53.3 (+0.0) 50.0 (−-4.0) 39.0 (+9.5) Test-time fusion baselines: Qwen3-4B × Ministral Cool-Fusion 31.0 (−-58.0) 66.0 (−-26.0) 0.0† (−-53.3) 11.6 (−-42.4) 0.5 (−-29.0) AdaFuse 45.5 (−-43.5) 72.6 (−-19.4) 33.3 (−-20.0) 28.8 (−-25.2) 38.5 (+9.0) ThinkFuse Qwen3-4B × Ministral 90.0 (+1.0) 96.9 (+4.9) 73.3 (+20.0) 64.6 (+10.6) 39.5 (+10.0) Qwen3-4B × Qwen3-1.7B 91.0 (+2.0) 94.0 (+2.0) 70.0 (+16.7) 55.1 (+1.1) 37.0 (+7.5) Qwen3-4B × Qwen3-4B 75.0 (−-14.0) 90.0 (−-2.0) 40.0 (−-13.3) 28.3 (−-25.7) 38.0 (+8.5) Qwen3-1.7B × EXAONE-4.0 85.0 (+2.0) 90.5 (+0.5) 30.0 (−-3.3) 53.5 (+14.1) 28.0 (+0.0) Table 2: Main benchmark results. Accuracy (%) for standalone models, test-time baselines, and ThinkFuse across five benchmarks under a 16K-token budget. Values in parentheses indicate the signed accuracy difference, in percentage points, relative to the standalone performance of the primary model, with green indicating gains and red indicating degradation. The † symbol marks AIME24 results affected by length-limit or final-answer truncation. The ‡ symbol marks the standalone Qwen3-1.7B evaluated with the Qwen3 recommended top-k of 20, whereas all other rows use the shared decoding setting. Additional experimental details, including the decoding settings and remaining cross-family and same-family configurations, are presented in Appendix A and C. 4.3 Datasets We evaluate ThinkFuse on two categories of reasoning benchmarks. To assess complex mathematical reasoning, we use MATH-500 (Hendrycks et al., 2021), GSM8K (Cobbe et al., 2021), and AIME 202411 1 https://huggingface.co/datasets/Maxwell-Jia/AIME_2024, which respectively evaluate competition-level mathematical problem solving, multi-step grade-school arithmetic reasoning, and advanced high-school competition mathematics. To assess knowledge-intensive reasoning capability, we use GPQA-Diamond (Rein et al., 2024) and NQ-Open (Kwiatkowski et al., 2019). GPQA-Diamond evaluates expert-level scientific reasoning across biology, physics, and chemistry, whereas NQ-Open evaluates open-domain factual question answering from naturally occurring questions. 4.4 Implementation Details All experiments are implemented with vLLM Kwon et al. (2023) on two NVIDIA A100-80GB GPUs. For efficient test-time fusion, ThinkFuse executes auxiliary candidate generation in parallel with primary-model generation whenever applicable. We use publicly available Hugging Face checkpoints Wolf et al. (2020) for all primary and auxiliary models. We report accuracy on all benchmarks, evaluating GPQA and NQ-Open with the LM Evaluation Harness Gao et al. (2024) and MATH-500, GSM8K, and AIME-24 following Qwen2.5-Math Yang et al. (2024). All methods share a 16,384 token generation budget and one decoding configuration, except that the standalone Qwen3-1.7B uses the Qwen3 recommended top-k of 20, and responses without a parseable final answer within the budget are scored as incorrect. We evaluate each method on a fixed random subsample of each benchmark using a consistent sampling protocol across methods. Detailed experimental setups are summarized in Appendix A. 5 Main Results Table 2 reports the accuracy of standalone models, existing test-time compute baselines, test-time fusion baselines, and ThinkFuse across five benchmarks. For brevity throughout the paper, we abbreviate the model names as follows: Ministral (Ministral-3B-R) and EXAONE-4.0 (EXAONE-4.0-1.2B). Among standalone models, Qwen3-4B shows the strongest and most stable performance across benchmarks, providing a strong baseline for test-time fusion. Despite this strong baseline, ThinkFuse with Qwen3-4B as the primary model improves over its standalone performance on every benchmark, whether the auxiliary is a cross-family model or a smaller model from the same family. In particular, Qwen3-4B × Ministral achieves the best result on four out of five benchmarks, with large gains on AIME24 (+20.0), GPQA (+10.6), and NQ-Open (+10.0). The additional cross-family pairs with EXAONE-Deep-2.4B and DeepSeek-R1-Distill as auxiliaries yield the same pattern (Appendix C), suggesting that ThinkFuse can benefit from auxiliary reasoning trajectories even when the auxiliary model is not uniformly stronger than the primary model. Bootstrap confidence intervals in Appendix B confirm this consistency, as all twenty deltas across the four Qwen3-4B pairs are positive and eleven are significant at the 95% level. Conversely, existing test-time fusion baselines show the opposite trend. With the same Qwen3-4B × Ministral pair, Cool-Fusion drops sharply from 89.0 to 31.0 on MATH-500 and from 54.0 to 11.6 on GPQA, while AdaFuse also underperforms the standalone primary on four out of five benchmarks. Test-time compute through self-consistency provides gains on GSM8K and NQ-Open, but does not improve AIME24 and degrades GPQA, indicating that simply increasing test-time sampling is not sufficient for consistent improvement. Moreover, the redundant same-model variant, Qwen3-4B × Qwen3-4B, degrades performance on MATH-500, GSM8K, AIME24, and GPQA. These results suggest that fusion must be selective and trajectory-aware, since locally determined or redundant fusion can disrupt the primary model’s reasoning process. Finally, we examine whether ThinkFuse remains beneficial with a smaller primary model by pairing Qwen3-1.7B with EXAONE-4.0. The standalone Qwen3-1.7B is evaluated with the Qwen3 recommended top-k of 20, while ThinkFuse retains the shared decoding setting, so this comparison favors the standalone baseline. Even so, ThinkFuse raises GPQA from 39.4 to 53.5, exceeding both standalone models. On the remaining benchmarks, where EXAONE-4.0 is substantially weaker than the primary, ThinkFuse gains +2.0 on MATH-500 and +0.5 on GSM8K, ties on NQ-Open, and differs by a single problem on AIME24. Thus, this distribution of gains matches the design principle of ThinkFuse: complementary auxiliary trajectories are exploited where they exist, while the selective trigger and PPL-based compatibility scoring prevent harmful fusion where they do not. Overall, the results suggest that ThinkFuse improves reasoning performance by selectively fusing complementary auxiliary trajectories at uncertain points, yielding more stable and effective test-time fusion than existing baselines. Figure 2: Thinking-stage token statistics. Top: Average fused auxiliary tokens in log scale. Bottom: Average total thinking-stage tokens. All fusion configurations use Qwen3-4B as primary model and Ministral-3B-Reasoning as auxiliary model. 6 Analysis To understand the sources of ThinkFuse’s accuracy gains, we conduct three complementary analyses. First, we examine how fusion behavior relates to downstream performance across methods. Second, we measure the compute efficiency of each test-time fusion method. Third, we test whether ThinkFuse remains effective when the auxiliary model is transformed to instruction-tuned variant. 6.1 Fusion Dynamics and Downstream Performance Figure 2 analyzes how different fusion methods use auxiliary reasoning tokens and how this affects the overall thinking-stage length. Despite fusing the most auxiliary tokens, Cool-Fusion yields the shortest thinking-stage outputs. This suggests that excessive fusion can overwrite or prematurely redirect the primary model’s reasoning trajectory, explaining its large performance drops in Table 2. Meanwhile, AdaFuse uses fewer auxiliary tokens, but still shortens the thinking stage on reasoning-intensive benchmarks such as AIME24 and GPQA, indicating that simply limiting auxiliary usage is insufficient for preserving reasoning quality. In contrast, ThinkFuse uses auxiliary tokens much more sparsely than Cool-Fusion while maintaining a more substantial reasoning process than the baselines. Combined with the consistent accuracy gains in Table 2, this analysis suggests that effective test-time fusion requires selective and trajectory-aware intervention, rather than frequent or locally determined auxiliary fusion. 6.2 Compute Efficiency Table 3 compares the efficiency of the test-time fusion methods on the Qwen3-4B × Ministral pair, with accuracy averaged over the five benchmarks. ThinkFuse achieves the highest accuracy with a TFLOP budget comparable to AdaFuse and lower than that of Cool-Fusion, resulting in the highest accuracy per TFLOP. Meanwhile, ThinkFuse exhibits a longer wall-clock time, yet the comparable TFLOPs indicate that this gap arises from the CPU-GPU data transfer during PPL scoring rather than from additional computation. The lower latency of the baselines, in turn, comes at the cost of severe accuracy degradation, leaving ThinkFuse as the only fusion method that improves over the standalone primary. Method Wall-clock (s) TFLOPs Acc. Acc. / TFLOPs Cool-Fusion 39.4 86 21.8 0.25 AdaFuse 33.9 74 43.7 0.60 ThinkFuse 68.7 77 72.9 0.95 Table 3: Efficiency comparison of ThinkFuse and comparable test-time fusion methods. Wall-clock time and TFLOPs are averaged per example, and accuracy is averaged over the five benchmarks, with the Qwen3-4B × Ministral pair. 6.3 Auxiliary Compatibility Beyond Reasoning Models We explore ThinkFuse’s extensibility to instruction-tuned and non-thinking auxiliary models. As shown in Table 4, these models yield limited, task-dependent gains. On MATH-500, models like Llama-3.2-3B-IT and Qwen3-1.7B (no-think) marginally improve the Qwen3-4B baseline, while others slightly degrade performance. Consequently, while these findings provide partial evidence of extensibility, reasoning-specialized auxiliaries remain fundamentally aligned with ThinkFuse’s core trajectory-fusion mechanism. Furthermore, on GPQA, all non-reasoning auxiliaries uniformly degrade performance, contrasting sharply with the consistent gains from cross-family reasoning models shown in Table 2 and Appendix C. This confirms that effective fusion relies not on mere auxiliary diversity, but on the auxiliary’s capacity to generate reasoning segments that coherently complement the primary model’s ongoing trajectory. Thus, while non-reasoning models demonstrate partial extensibility, reasoning-specialized auxiliaries remain essential to fully leverage ThinkFuse’s trajectory-aware mechanism. Auxiliary MATH-500 GPQA Llama-3.2-3B-IT 89.5 (+0.5) 50.5 (−-3.5) Gemma-2-2B-it 87.5 (−-1.5) 51.0 (−-3.0) Mistral-7B-Inst-v0.3 84.5 (−-4.5) 44.9 (−-9.1) Qwen2.5-3B-Inst 88.0 (−-1.0) 52.5 (−-1.5) Qwen3-1.7B (no-think) 89.5 (+0.5) 50.0 (−-4.0) Table 4: Experimental results of pairing Qwen3-4B as a primary model with instruction-tuned or non-thinking auxiliaries. The general performance drop indicates that ThinkFuse strictly requires reasoning-specialized models to ensure trajectory compatibility. Values in parentheses show the difference from the standalone baseline. Setting MATH-500 GSM8K Fusion budget penalty Soft budget (ours, λ=50λ=50) 90.0 (+1.0) 96.9 (+4.9) No budget penalty (λ=0λ=0) 88.5 (−-0.5) 90.5 (−-1.5) Segment length T T=4T=4 87.0 (−-2.0) 93.5 (+1.5) T=8T=8 (ours) 90.0 (+1.0) 96.9 (+4.9) T=16T=16 88.0 (−-1.0) 93.5 (+1.5) T=32T=32 88.5 (−-0.5) 93.5 (+1.5) Trajectory compatibility scoring Primary PPL (ours) 90.0 (+1.0) 96.9 (+4.9) Average PPL 80.5 (−-8.5) 92.0 (+0.0) Token-level uncertainty estimation Entropy (ours) 90.0 (+1.0) 96.9 (+4.9) Confidence gap 87.5 (−-1.5) 98.6 (+6.6) Table 5: Impact of individual ThinkFuse components on downstream performance. Values in parentheses denote the accuracy delta relative to the standalone baseline. All experiments are conducted with Qwen3-4B as the primary model and Ministral-3B-Reasoning as the auxiliary model. Shared prefix. For AIME-2022 I #11, both traces begin with the same coordinate setup: A=(0,0)A=(0,0), B=(2,0)B=(2,0), D=(p,q)D=(p,q), C=(r,s)C=(r,s), and M=((2+r)/2,s/2)M=((2+r)/2,s/2) is the midpoint of BCBC. Both traces then try to use the two angle-bisector conditions at M. Standalone ThinkFuse Generated trace near the divergence. ⋯·s I place the quadrilateral in coordinates and write the distance equations. Since M is the midpoint of BCBC, it should lie on the two angle bisectors. ⋯·s the valid solution is b = -7/sqrt(2), a = 7/sqrt(2) So, D is at ((7*sqrt(2))/2, -7*sqrt(2)/2). ⋯·s I plug this coordinate for D back into the remaining constraints and solve for C. ⋯·s (2+sqrt(2))*yˆ2 + 9*(sqrt(2)+1)*y + (22+7*sqrt(2)) = 0 // Comment: this fixes D as if ∠DAB=45∘ DAB=45 . The second angle-bisector condition has not been used, so the trace enters a dead-end quadratic. Generated trace near the fusion point. ⋯·s I keep D=(p,q)D=(p,q) and C=(r,s)C=(r,s) symbolic, then express the two angle-bisector conditions as distance-to-line equations. ⋯·s [Two angle-bisector distance equations from M = (B+C)/2] -8 - 2p + 3r = 0 => r = (8 + 2p)/3 => s = 2q/3 Substituting these relations keeps both angle-bisector constraints active while the remaining equations are solved. // Comment: the auxiliary segment keeps D=(p,q)D=(p,q) symbolic. It uses both angle-bisector conditions before solving. Answer: 0× 0\ × Answer: 180✓ 180\ Table 6: Qualitative comparison on AIME 2022. Standalone denotes Qwen3-4B. ThinkFuse uses Qwen3-4B as the primary model and Ministral-3B-Reasoning as the auxiliary model. Both traces start from the same coordinate formulation; the highlighted text marks the standalone step that enters a dead-end quadratic and the auxiliary symbolic step selected by ThinkFuse. 7 Ablation Study Table 5 details the contribution of each algorithmic component within ThinkFuse to the overall performance. Throughout these ablations, Qwen3-4B and Ministral-3B-Reasoning are employed as the primary and auxiliary models, respectively, with color-coded values in parentheses denoting the accuracy delta relative to the Qwen3-4B baseline. Fusion budget penalty ablation As shown in Table 5, the soft budget penalty (λ=50λ=50) outperforms the no-budget variant (λ=0λ=0), which removes the cumulative fusion ratio penalty from the adaptive threshold θk _k. Yielding accuracies of 88.5% on MATH-500 and 90.5% on GSM8K, the no-budget variant degrades performance even below the standalone primary model’s baseline. These results indicate that the proposed soft budget stabilizes ThinkFuse by actively discouraging excessive fusion interventions. Effects of segment length The segment length T dictates a crucial trade-off in ThinkFuse. Our default setting of T=8T=8 yields the best results, achieving 90.0% on MATH-500 and 96.9% on GSM8K. When the segment is too short (T=4T=4), it fails to encapsulate a meaningful reasoning step, causing MATH-500 accuracy to fall below the standalone baseline (87.0%). Conversely, expanding the segment length (T=16T=16 and T=32T=32) substantially diminishes the gains on GSM8K and similarly hurts MATH-500. This suggests that excessively long segments delay necessary interventions, allowing incorrect reasoning paths to propagate before fusion occurs. Effects of compatibility selection rule We investigate PPL scoring rules as a proxy for trajectory compatibility. As shown in Table 5, relying solely on the Primary PPL yields optimal results (90.0% on MATH-500, 96.9% on GSM8K). In contrast, the Average PPL scoring rule drops MATH-500 performance to 80.5% and limits GSM8K to the standalone Qwen3-4B baseline (92.0%). These results indicate that blending the auxiliary model’s distribution into the primary model’s score misaligns the compatibility metric, causing the selected segments to diverge from the primary model’s ongoing reasoning path. Token-level uncertainty estimation We compare entropy against a margin-based confidence-gap signal (see Appendix A.2). Although the confidence gap achieves 98.6% on GSM8K, it degrades on MATH-500 (87.5%), falling below the standalone baseline. As entropy consistently preserves performance gains on both datasets, we employ it as our default token-level uncertainty metric. 8 Case Study Table 6 illustrates how ThinkFuse corrects intermediate reasoning trajectories using an AIME 2022 example. Despite sharing the initial coordinate setup, the standalone baseline prematurely grounds the coordinates of D, failing to satisfy the second angle-bisector condition and trapping the reasoning in a dead-end quadratic, resulting in an incorrect answer. In contrast, ThinkFuse triggers an intervention and selects an auxiliary segment that keeps D and C symbolic and successfully enforces both distance-to-line constraints before solving. This case demonstrates that injecting an appropriate symbolic segment preserves the shared mathematical context while effectively redirecting the model from an erroneous path toward the correct solution. 9 Conclusion We presented ThinkFuse, a trajectory-aware test-time fusion framework that selectively intervenes in model reasoning trajectories. By calibrating segment-level uncertainty with historical statistics and applying trajectory compatibility scoring, ThinkFuse integrates auxiliary reasoning only when the primary trajectory is likely to benefit. Across five benchmarks, ThinkFuse consistently outperforms standalone models and existing test-time fusion baselines, showing that its gains come from complementary auxiliary trajectories rather than additional computation alone. These results suggest that effective collaborative reasoning depends on deciding when to intervene and what to retain, offering a practical, training-free approach for scaling small reasoning models at test time. Limitations Test-time resource requirements. Unlike single-model decoding, ThinkFuse requires an execution environment that can serve an auxiliary model together with the primary model. This can increase memory usage and latency. However, ThinkFuse intervenes only on selected segments in the explicit thinking stage, and its PPL-based segment selection reuses the current KV cache to avoid an additional full forward pass over the entire context. Quantization, parallel serving, and cache-aware deployment may further reduce practical overhead. Evaluation scope. Our main experiments focus on open-weight reasoning models in the 1.2B–4B range. This setting matches our goal of improving reasoning under limited resources, but additional evaluation is needed to determine whether the same behavior holds for larger models, closed models, and broader model families. We also focus on mathematical, scientific, and knowledge-based reasoning benchmarks; code generation, multilingual reasoning, and long-context tasks remain outside the scope of this study. Dependence on primary-model quality. ThinkFuse is designed for settings where the primary model can produce coherent reasoning segments but may enter an incorrect reasoning path at uncertain points. If the primary model generates highly unstable or repetitive segments, uncertainty-based triggering may fail to identify useful intervention points. Such cases may require alternative decoding policies or stronger criteria for selecting the primary model. Auxiliary-model complementarity. The benefit of ThinkFuse depends on whether the auxiliary model provides reasoning segments that complement the primary model. If the auxiliary model shares similar failure modes with the primary model, or if its strengths do not match the target task, fusion may not always improve performance. Future work can reduce this dependence through task-specific auxiliary selection or model-pool routing. Explicit reasoning spans and tokenizer alignment. Because ThinkFuse intervenes at the segment level inside the reasoning stage, it requires identifying the explicit reasoning span and aligning text segments generated under different tokenizers. Our implementation uses <think> tag normalization and shared-prefix text alignment, but additional engineering may be needed for broader chat templates and tokenizer combinations. Fixed fusion settings. We use a fixed segment length and PPL scoring rule in the main experiments and analyze representative alternatives in ablations. More extensive searches over threshold and budget hyperparameters may yield additional gains. Our focus is instead to test whether uncertainty-guided fusion is effective without heavy task-specific tuning. Ethical Statements In this section, we discuss the ethical considerations of our work. (1) Privacy and Languages. All benchmarks used in our experiments are publicly available academic datasets in English. MATH-500 (Hendrycks et al., 2021), GSM8K (Cobbe et al., 2021), and AIME 2024 consist of competition-level mathematical problems, multi-step grade-school arithmetic, and advanced high-school competition mathematics, respectively. GPQA-Diamond (Rein et al., 2024) provides graduate-level scientific reasoning questions in biology, physics, and chemistry written by domain experts, and NQ-Open (Kwiatkowski et al., 2019) contains open-domain factual questions derived from naturally occurring Google search queries with Wikipedia-grounded answers. Since each benchmark is built from curated academic problems or factual question answering, there is minimal risk of including personally identifiable information or offensive content. (2) Licenses and terms. The reasoning models we evaluate are released under open-weight licenses that permit research use: Qwen3-4B, Qwen3-1.7B Yang et al. (2025), and Ministral-3B-Reasoning Liu et al. (2026) are distributed under the Apache 2.0 license, DeepSeek-R1-Distill DeepSeek-AI (2025) under the MIT license, and EXAONE-Deep-2.4B Bae et al. (2025b) / EXAONE-4.0-1.2B Bae et al. (2025a) under their respective model licenses for research purposes. We primarily employ vLLM Kwon et al. (2023) (Apache 2.0), Hugging Face Transformers Wolf et al. (2020) (Apache 2.0), and the LM Evaluation Harness Gao et al. (2024) (MIT) for model serving and evaluation, all of which are available under permissive open-source licenses. (3) Intended use. Our proposed ThinkFuse framework is intended for research on test-time fusion of small reasoning models, with the goal of improving the reliability of their reasoning trajectories without additional training. By selectively invoking auxiliary reasoning only at uncertain segments, ThinkFuse can serve as a basis for studying when and what to fuse during multi-model reasoning collaboration; we will release our code and evaluation scripts to support reproducibility and follow-up research on trajectory-aware fusion for resource-constrained reasoning. (4) Use of AI assistants. During the preparation of this manuscript, we used AI assistants for grammar correction and minor language polishing of text originally drafted by the authors. All AI-assisted edits were subsequently reviewed and verified by the authors, who take full responsibility for the final content of the paper. Acknowledgements This research was supported by Basic Science Research Program through the National Research Foundation of Korea(NRF) funded by the Ministry of Education(NRF-2021R1A6A1A03045425). This work was supported by Institute for Information & communications Technology Promotion(IITP) grant funded by the Korea government(MSIT) (RS-2024-00398115, Research on the reliability and coherence of outcomes produced by Generative AI). This work was supported by the Commercialization Promotion Agency for R&D Outcomes(COMPA) grant funded by the Korea government(Ministry of Science and ICT)(2710096072). References Bae et al. (2025a) K. Bae, E. Choi, K. Choi, S. J. Choi, Y. Choi, K. Han, S. Hong, J. Hwang, T. Hwang, J. Jang, et al. Exaone 4.0: unified large language models integrating non-reasoning and reasoning modes. arXiv preprint arXiv:2507.11407. Cited by: §4.1, (2) Licenses and terms.. Bae et al. (2025b) K. Bae, E. Choi, K. Choi, S. J. Choi, Y. Choi, S. Hong, J. Hwang, H. Jeon, K. Jeon, G. J. Jo, et al. EXAONE deep: reasoning enhanced language models. arXiv preprint arXiv:2503.12524. Cited by: §4.1, (2) Licenses and terms.. Chen et al. (2025) X. Chen, Z. Sun, G. Wenjin, M. Zhang, Y. Chen, Y. Sun, H. Su, Y. Pan, D. Klakow, W. Li, and X. Shen Unveiling the key factors for distilling chain-of-thought reasoning. In Findings of the Association for Computational Linguistics: ACL 2025, W. Che, J. Nabende, E. Shutova, and M. T. Pilehvar (Eds.), Vienna, Austria, p. 15094–15119. External Links: Link, Document, ISBN 979-8-89176-256-5 Cited by: §1. Cobbe et al. (2021) K. Cobbe, V. Kosaraju, M. Bavarian, M. Chen, H. Jun, L. Kaiser, M. Plappert, J. Tworek, J. Hilton, R. Nakano, C. Hesse, and J. Schulman Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168. Cited by: §4.3, (1) Privacy and Languages.. Cui et al. (2026) C. Cui, T. Wei, Z. Chen, R. Qiu, Z. Zeng, Z. Liu, X. Ning, D. Zhou, and J. He AdaFuse: adaptive ensemble decoding for large language models. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), M. Liakata, V. P. Moreira, J. Zhang, and D. Jurgens (Eds.), San Diego, California, United States, p. 42644–42657. External Links: Link, Document, ISBN 979-8-89176-390-6 Cited by: §1, §2.1, Table 1, §4.2. DeepSeek-AI (2025) DeepSeek-AI DeepSeek-R1: incentivizing reasoning capability in llms via reinforcement learning. arXiv preprint arXiv:2501.12948. Cited by: §1, §4.1, (2) Licenses and terms.. Ding et al. (2025) F. Ding, B. Wang, Z. Zeng, and Y. Wang Multi-layer grpo: enhancing reasoning and self-correction in large language models. arXiv preprint arXiv:2506.04746. Cited by: §1. Fu et al. (2024) Y. Fu, J. Chen, S. Zhu, Z. Fu, Z. Dai, Y. Zhuang, Y. Ma, A. Qiao, T. Rosing, I. Stoica, et al. Efficiently scaling llm reasoning with certaindex. arXiv preprint arXiv:2412.20993. Cited by: §2.3. Fu et al. (2026) Y. Fu, X. Wang, H. Zhang, Y. Tian, and J. Zhao Deep think with confidence. In International Conference on Learning Representations, C. Vondrick, B. Hariharan, C. Raffel, L. Pinto, D. Yang, and A. Faust (Eds.), Vol. 2026, p. 94355–94377. External Links: Link Cited by: §2.3. Gao et al. (2024) L. Gao, J. Tow, B. Abbasi, S. Biderman, S. Black, A. DiPofi, C. Foster, L. Golding, J. Hsu, A. Le Noac’h, H. Li, K. McDonell, N. Muennighoff, C. Ociepa, J. Phang, L. Reynolds, H. Schoelkopf, A. Skowron, L. Sutawika, E. Tang, A. Thite, B. Wang, K. Wang, and A. Zou The language model evaluation harness. Zenodo. External Links: Document, Link Cited by: §4.4, (2) Licenses and terms.. Guo et al. (2025) J. Guo, S. Gu, M. Jin, C. Spanos, and J. Lavaei StyleBench: evaluating thinking styles in large language models. arXiv preprint arXiv:2509.20868. Cited by: §1. Gupta et al. (2024) N. Gupta, H. Narasimhan, W. Jitkrittum, A. S. Rawat, A. K. Menon, and S. Kumar Language model cascades: token-level uncertainty and beyond. In The Twelfth International Conference on Learning Representations, External Links: Link Cited by: §2.2. Halim et al. (2025) K. Halim, S. G. Teo, R. Feng, Z. Chen, Y. Gu, C. Wang, and Y. Liu A study on thinking patterns of large reasoning models in code generation. arXiv preprint arXiv:2509.13758. Cited by: §1. Hendrycks et al. (2021) D. Hendrycks, C. Burns, S. Kadavath, A. Arora, S. Basart, E. Tang, D. Song, and J. Steinhardt Measuring mathematical problem solving with the MATH dataset. In Advances in Neural Information Processing Systems, Cited by: §4.3, (1) Privacy and Languages.. Jiang et al. (2023) D. Jiang, X. Ren, and B. Y. Lin LLM-blender: ensembling large language models with pairwise ranking and generative fusion. In Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), A. Rogers, J. Boyd-Graber, and N. Okazaki (Eds.), Toronto, Canada, p. 14165–14178. External Links: Link, Document Cited by: §2.1. Jiang et al. (2025) J. Jiang, J. Wang, Y. Yan, Y. Liu, J. Zhu, M. Zhang, and L. Gao Do large language models excel in complex logical reasoning with formal language?. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, p. 16889–16914. Cited by: §1. Kwiatkowski et al. (2019) T. Kwiatkowski, J. Palomaki, O. Redfield, M. Collins, A. Parikh, C. Alberti, D. Epstein, I. Polosukhin, J. Devlin, K. Lee, K. Toutanova, L. Jones, M. Kelcey, M. Chang, A. M. Dai, J. Uszkoreit, Q. Le, and S. Petrov Natural questions: a benchmark for question answering research. Transactions of the Association for Computational Linguistics 7, p. 453–466. Cited by: §4.3, (1) Privacy and Languages.. Kwon et al. (2023) W. Kwon, Z. Li, S. Zhuang, Y. Sheng, L. Zheng, C. H. Yu, J. E. Gonzalez, H. Zhang, and I. Stoica Efficient memory management for large language model serving with PagedAttention. In Proceedings of SOSP, Cited by: §4.4, (2) Licenses and terms.. Lee et al. (2026) J. Lee, S. Lee, S. Son, D. J. Lee, S. Han, S. Eo, and H. Lim Answer-conditioned chains of thought degrade verifiable-reasoning distillation in large language models. arXiv preprint arXiv:2607.14552. Cited by: §1. Li and Goyal (2026) A. O. Li and T. Goyal Off-trajectory reasoning: can LLMs collaborate on reasoning trajectories?. In The Fourteenth International Conference on Learning Representations, External Links: Link Cited by: §1. Liu et al. (2026) A. H. Liu, K. Khandelwal, S. Subramanian, V. Jouault, A. Rastogi, A. Sadé, A. Jeffares, A. Jiang, A. Cahill, A. Gavaudan, et al. Ministral 3. arXiv preprint arXiv:2601.08584. Cited by: §4.1, (2) Licenses and terms.. Liu et al. (2025) C. Liu, X. Quan, Y. Pan, L. Lin, W. Wu, and X. Chen Cool-fusion: fuse large language models without training. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (ACL), Cited by: §1, §2.1, Table 1, §4.2. Lu et al. (2025) X. Lu, S. Han, D. Acuna, H. Kim, J. Jung, S. Prabhumoye, N. Muennighoff, M. Patwary, M. Shoeybi, B. Catanzaro, et al. Retro-search: exploring untaken paths for deeper and efficient reasoning. arXiv preprint arXiv:2504.04383. Cited by: §3.2. Pan et al. (2025) R. Pan, Y. Dai, Z. Zhang, G. Oliaro, Z. Jia, and R. Netravali SpecReason: fast and accurate inference-time compute via speculative reasoning. In Advances in Neural Information Processing Systems, D. Belgrave, C. Zhang, H. Lin, R. Pascanu, P. Koniusz, M. Ghassemi, and N. Chen (Eds.), Vol. 38, Main Conference, p. 12730–12749. External Links: Document, Link Cited by: Appendix G, §2.3, Table 1. Ranaldi and Freitas (2024) L. Ranaldi and A. Freitas Aligning large and small language models via chain-of-thought reasoning. In Proceedings of the 18th Conference of the European Chapter of the Association for Computational Linguistics (Volume 1: Long Papers), Y. Graham and M. Purver (Eds.), St. Julian’s, Malta, p. 1812–1827. External Links: Link, Document Cited by: §2.2. Rein et al. (2024) D. Rein, B. L. Hou, A. C. Stickland, J. Petty, R. Y. Pang, J. Dirani, J. Michael, and S. R. Bowman GPQA: a graduate-level google-proof q&a benchmark. arXiv preprint arXiv:2311.12022. Cited by: §4.3, (1) Privacy and Languages.. Shao et al. (2024) Z. Shao, P. Wang, Q. Zhu, R. Xu, J. Song, X. Bi, H. Zhang, M. Zhang, Y. Li, Y. Wu, et al. Deepseekmath: pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.03300. Cited by: §1. Souza et al. (2025) D. Souza, R. Gheyi, L. Albuquerque, G. Soares, and M. Ribeiro Code generation with small language models: a codeforces-based study. 2025 International Conference on Machine Learning and Applications (ICMLA), p. 582–587. External Links: Link Cited by: §1. Sun et al. (2026) L. Sun, H. Dong, B. Qiao, Q. Lin, D. Zhang, and S. Rajmohan LLM reasoning as trajectories: step-specific representation geometry and correctness signals. External Links: 2604.05655, Link Cited by: §1. Tian et al. (2025) Y. Tian, Y. Han, X. Chen, W. Wang, and N. V. Chawla Beyond answers: transferring reasoning capabilities to smaller llms using multi-teacher knowledge distillation. In Proceedings of the eighteenth acm international conference on web search and data mining, p. 251–260. Cited by: §1. Wang et al. (2026) P. Wang, T. Liu, C. Wang, Z. Li, Y. Wang, S. Yan, C. Jia, X. Liu, X. Chen, J. Xu, and Y. Yu A survey on large language models for mathematical reasoning. ACM Comput. Surv. 58 (8). External Links: ISSN 0360-0300, Link, Document Cited by: §1. Wang et al. (2023) X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou Self-consistency improves chain of thought reasoning in language models. In Proceedings of ICLR, Cited by: §1, §2.1, Table 1, §4.2. Wang et al. (2025) Y. Wang, Q. Liu, J. Xu, T. Liang, X. Chen, Z. He, L. Song, D. Yu, J. Li, Z. Zhang, et al. Thoughts are all over the place: on the underthinking of o1-like llms. arXiv preprint arXiv:2501.18585. Cited by: §3.2. Wei et al. (2022) J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. Chi, Q. V. Le, D. Zhou, et al. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems 35, p. 24824–24837. Cited by: §2.1. Wolf et al. (2020) T. Wolf, L. Debut, V. Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowicz, J. Davison, S. Shleifer, P. von Platen, C. Ma, Y. Jernite, J. Plu, C. Xu, T. L. Scao, S. Gugger, M. Drame, Q. Lhoest, and A. M. Rush Transformers: state-of-the-art natural language processing. In Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, Online, p. 38–45. External Links: Link Cited by: §4.4, (2) Licenses and terms.. Xu et al. (2025a) F. Xu, Q. Hao, C. Shao, Z. Zong, Y. Li, J. Wang, Y. Zhang, J. Wang, X. Lan, J. Gong, T. Ouyang, F. Meng, Y. Yan, Q. Yang, Y. Song, S. Ren, X. Hu, J. Feng, C. Gao, and Y. Li Toward large reasoning models: a survey of reinforced reasoning with large language models. Patterns 6 (10), p. 101370. External Links: Document, ISSN 2666-3899, Link Cited by: §1. Xu et al. (2025b) Y. Xu, J. Chen, J. Wu, and J. Zhang Hit the sweet spot! span-level ensemble for large language models. In Proceedings of the 31st International Conference on Computational Linguistics, O. Rambow, L. Wanner, M. Apidianaki, H. Al-Khalifa, B. D. Eugenio, and S. Schockaert (Eds.), Abu Dhabi, UAE, p. 8314–8325. External Links: Link Cited by: §1, §2.1. Yan et al. (2026) H. Yan, F. Xu, R. Xu, Y. Li, J. Zhang, H. Luo, X. Wu, A. T. Luu, H. Zhao, Q. Lin, and J. Liu MUR: momentum uncertainty guided reasoning for large language models. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), M. Liakata, V. P. Moreira, J. Zhang, and D. Jurgens (Eds.), San Diego, California, United States, p. 23078–23103. External Links: Link, Document, ISBN 979-8-89176-390-6 Cited by: Appendix G, §2.3, Table 1. Yang et al. (2025) A. Yang, A. Li, B. Yang, B. Zhang, B. Hui, B. Zheng, B. Yu, C. Gao, C. Huang, C. Lv, et al. Qwen3 technical report. arXiv preprint arXiv:2505.09388. Cited by: §1, §4.1, (2) Licenses and terms.. Yang et al. (2024) A. Yang, B. Zhang, B. Hui, B. Gao, B. Yu, C. Li, D. Liu, J. Tu, J. Zhou, J. Lin, et al. Qwen2.5-math technical report: toward mathematical expert model via self-improvement. arXiv preprint arXiv:2409.12122. Cited by: §4.4. Yao et al. (2025) Y. Yao, H. Wu, M. LIU, S. Luo, X. Han, J. Liu, Z. Guo, and L. Song Determine-then-ensemble: necessity of top-k union for large language model ensembling. In The Thirteenth International Conference on Learning Representations, External Links: Link Cited by: §1, §2.1. Yu et al. (2025) Q. Yu, Z. Zhang, R. Zhu, Y. Yuan, X. Zuo, YuYue, W. Dai, T. Fan, G. Liu, J. Liu, L. Liu, X. Liu, H. Lin, Z. Lin, B. Ma, G. Sheng, Y. Tong, C. Zhang, M. Zhang, R. Zhang, W. Zhang, H. Zhu, J. Zhu, J. Chen, J. Chen, C. Wang, H. Yu, Y. Song, X. Wei, H. Zhou, J. Liu, W. Ma, Y. Zhang, L. Yan, Y. Wu, and M. Wang DAPO: an open-source LLM reinforcement learning system at scale. In The Thirty-ninth Annual Conference on Neural Information Processing Systems, External Links: Link Cited by: §1. Zhang et al. (2024) Y. Zhang, M. Khalifa, L. Logeswaran, J. Kim, M. Lee, H. Lee, and L. Wang Small language models need strong verifiers to self-correct reasoning. In Findings of the Association for Computational Linguistics: ACL 2024, L. Ku, A. Martins, and V. Srikumar (Eds.), Bangkok, Thailand, p. 15637–15653. External Links: Link, Document Cited by: §2.2. Zheng et al. (2025) W. Zheng, Y. Chen, W. Zhang, S. Kundu, Y. Li, Z. Liu, E. P. Xing, H. Wang, and H. Yao CITER: collaborative inference for efficient large language model decoding with token-level routing. In Second Conference on Language Modeling, External Links: Link Cited by: §2.2. Zhuang et al. (2025) X. Zhuang, P. Ma, Z. Jia, Z. Cao, and S. Liu Effective learning for small reasoning models: an empirical study on 0.5 b reasoning llms. arXiv preprint arXiv:2506.13404. Cited by: §1. Scope Setting Implementation details Shared Engine / hardware All generation and PPL computation use vLLM v0.8.5 with bfloat16 precision. Each model pair is served on two NVIDIA A100-80GB GPUs. Generation budget / sampling Standard decoding uses max_model_len=16384, max_new_tokens=16384, temperature=0.6, top-p=0.95, top-k=-1, and min-p=0.0. The standalone Qwen3-1.7B alone uses top-k=20 following the Qwen3 recommendation. Within this budget, explicit thinking-stage generation uses an additional 2K-token cap. Self-consistency uses separate sampling settings. ThinkFuse Trigger signal Every time the primary model generates T=8T=8 tokens, we compute top-5 token entropy and aggregate token-level uncertainty into segment-level uncertainty using EWCA with (α,β)=(0.1,0.5)(α,β)=(0.1,0.5). Adaptive threshold The EMA update rate is η=0.05η=0.05, the uncertainty tolerance is τ=1.0τ=1.0, and the initial statistics are (μ0,σ0)=(0.5,0.1)( _0, _0)=(0.5,0.1). The soft-budget coefficient is λ=50λ=50; the trigger uses both recent uncertainty history and the cumulative fusion ratio. Segment selection When fusion is triggered, primary and auxiliary candidate segments are compared under the current context using primary-model PPL. Segment boundaries from different tokenizers are aligned by the shared prefix that decodes identically under both tokenizers, and each segment is restored to the reasoning-tag format of the model used for PPL scoring. Baselines Cool-Fusion Each participating LLM generates a candidate segment; all generated candidates are scored by the PPL of all participating LLMs, and the candidate with the lowest average PPL is selected. AdaFuse The confidence threshold is τΔ=0.7 _ =0.7, the EMA decay is 0.99, and token confidence is computed from top-5 log probabilities. When the uncertain-token ratio exceeds 0.5, AdaFuse compares B=2B=2 candidates. Self-consistency We generate K∈3,5K∈\3,5\ sampled reasoning paths from Qwen3-4B with temperature=0.7 and top-p=0.95. Final answers are normalized with the same answer-normalization procedure as the main evaluation and selected by strict majority. If no normalized answer obtains a strict majority, we use the first generated sample. Post-hoc critique This appendix-only comparison uses a 16K-token budget. When the primary and auxiliary answers disagree, the auxiliary model critiques the primary output, and the primary model generates a revised answer conditioned on that critique. Table 7: Implementation hyperparameters. Shared implementation settings and method-specific settings used in the main and appendix experiments. Appendix A Detailed Experimental Setup A.1 Hyperparameter settings Table 7 summarizes the main implementation settings fixed across the main and appendix experiments. Shared rows report settings used across methods, while method-specific rows report the additional settings required by each baseline or comparison method. A.2 Uncertainty Signals and Budget-Penalty Details We also consider a confidence-gap variant in ablations: uk,igap=1−(pk,i(1)−pk,i(2)),u_k,i^gap=1- (p_k,i^(1)-p_k,i^(2) ), (11) where pk,i(1)p_k,i^(1) and pk,i(2)p_k,i^(2) denote the largest and second-largest probabilities among the top-5 candidate tokens at position i. This variant assigns higher uncertainty when the two leading candidates have similar probabilities. The no-budget penalty variant keeps the default entropy-based uncertainty signal, T=8T=8, and primary-model PPL scoring, but sets only the soft-budget coefficient in the adaptive threshold to λ=0λ=0. Thus, the threshold becomes θk=μk−1+τσk−1 _k= _k-1+τ _k-1, and fusion is triggered only when Ukp≥θkU_k^p≥ _k. As the cumulative fusion ratio Rk−1R_k-1 increases, the threshold no longer receives the additional penalty term. This ablation does not fuse every segment; it preserves the EMA-based uncertainty trigger and removes only the soft-budget penalty. A.3 Cross-Tokenizer Alignment When the primary and auxiliary models use different tokenizers, we apply shared-prefix text alignment to candidate segment boundaries. We first decode the T-token candidate segment into text, re-encode it with both tokenizers, find the longest prefix whose decoded text is identical under both tokenizers, and use this aligned prefix for segment comparison. In practice, this alignment reduces the effective segment length by 1–2 tokens on average. Reasoning-tag normalization. Different models use different reasoning tags; for example, Qwen3 uses <think>, whereas EXAONE-Deep uses <thought>. We normalize tags to <think> for fusion and restore them to each model’s native reasoning-tag format before PPL computation. A.4 Benchmark sampling protocol Due to computational cost constraints, we report all main, analysis, and ablation results on a fixed random subsample of each benchmark rather than the full evaluation split. Evaluating ThinkFuse and the baselines across multiple primary-auxiliary model-pair configurations, fusion variants, and ablations on every full benchmark would incur prohibitive compute cost, especially given that the framework involves repeated PPL scoring and parallel auxiliary generation. To keep the evaluation tractable while maintaining a consistent comparison across methods, we evaluate each method on a fixed random subsample of 200 examples per benchmark. The subsample is drawn once per benchmark using Python’s default random library generator with seed 42, and the same 200 examples are used across all methods, model pairs, and ablations. For MATH-500, GSM8K, and NQ-Open, this corresponds to a strict subsample of the full evaluation split. AIME 2024 (30 problems) and GPQA-Diamond (198 problems) are evaluated in full. All accuracy values reported in the main results, analysis, and ablation tables are computed over the same fixed subsample for each benchmark, ensuring that absolute and relative comparisons between methods are not affected by between-sample variance. Appendix B Bootstrap Confidence Intervals Table 8 reports 95% bootstrap confidence intervals for the accuracy delta of ThinkFuse over the standalone Qwen3-4B on each benchmark. The deltas are computed from re-executed runs, so point estimates may differ slightly from Table 2. All twenty pair-benchmark deltas are positive, eleven intervals exclude zero, and no interval indicates significant degradation. The wide AIME24 intervals reflect its small sample size of 30 problems. Auxiliary MATH-500 GSM8K AIME24 GPQA NQ-Open Ministral +0.5 [−-1.5, +2.5] +3.1 [+1.0, +5.6]* +20.0 [+6.7, +36.7]* +10.6 [+1.0, +20.2]* +10.0 [+5.5, +15.0]* EXAONE-Deep +2.0 [+0.5, +4.0]* +3.1 [+1.0, +5.8]* +20.0 [+6.7, +33.3]* +1.0 [−-8.1, +10.1] +9.0 [+4.5, +14.0]* DeepSeek-R1 +1.5 [−-0.5, +4.0] +3.0 [+0.0, +6.5] +3.3 [−-10.0, +16.7] +8.7 [−-0.5, +17.9] +8.0 [+3.5, +13.1]* Qwen3-1.7B +2.0 [+0.5, +4.0]* +2.0 [−-0.5, +5.0] +16.7 [−-3.3, +36.7] +1.0 [−-8.6, +10.1] +7.5 [+3.5, +12.0]* Table 8: 95% bootstrap confidence intervals for the accuracy delta of ThinkFuse over the standalone Qwen3-4B with each auxiliary. * marks intervals excluding zero. Deltas are from re-executed runs and may differ slightly from Table 2. Method MATH-500 GSM8K AIME24 GPQA NQ-Open Standalone models Qwen3-4B 89.0 92.0 53.3 54.0 29.5 EXAONE-Deep 83.5 90.5 43.3 57.1 17.5 DeepSeek-R1 13.0 30.5 0.0† 21.2 14.5 ThinkFuse cross-family pairs Qwen3-4B × EXAONE-Deep 91.0 (+2.0) 99.0 (+7.0) 73.3 (+20.0) 55.1 (+1.1) 38.5 (+9.0) Qwen3-4B × DeepSeek-R1 90.5 (+1.5) 95.0 (+3.0) 56.7 (+3.4) 63.3 (+9.3) 37.7 (+8.2) Table 9: Additional ThinkFuse model pairs. Accuracy (%) for the cross-family pairs with EXAONE-Deep and DeepSeek-R1 as auxiliary models under the same 16K-token budget and evaluation protocol as Table 2. Values in parentheses indicate the signed accuracy difference relative to the standalone Qwen3-4B. The † symbol marks AIME24 results affected by length-limit or final-answer truncation. Appendix C Additional Model-Pair Results of ThinkFuse Table 9 reports the ThinkFuse configurations that are not included in Table 2, namely the cross-family pairs with EXAONE-Deep (EXAONE-Deep-2.4B) and DeepSeek-R1 (DeepSeek-R1-Distill-Qwen-1.5B) as auxiliary models. Both pairs follow the same evaluation protocol as the main experiments and improve over the standalone Qwen3-4B on every benchmark, matching the pattern of the pairs reported in the main text. Appendix D Additional Sampling Diagnostic Table 10 reports the oracle pass@5 upper bound obtained by independently sampling Qwen3-4B five times. Unlike self-consistency, this diagnostic counts an instance as correct if any of the five sampled responses contains the correct answer. We therefore use it only as an auxiliary diagnostic of the potential upper bound from repeated sampling, not as a main baseline. Benchmark Qwen3-4B pass@5 MATH-500 90.5 (+1.5) GSM8K 95.5 (+3.5) AIME24 70.0 (+16.7) GPQA 71.2 (+17.2) NQ-Open 48.5 (+19.0) Table 10: Qwen3-4B pass@5 oracle sampling upper bound. pass@5 counts an instance as correct if at least one of five independently sampled Qwen3-4B responses contains the correct answer. Values are accuracy (%); colored values in parentheses denote the difference from Qwen3-4B standalone accuracy. This table reports only the sampling upper-bound diagnostic, which is not included in the main results table. Appendix E Fusion position distribution by correctness Figure 3 shows the normalized positions of thinking-stage segments where fusion is triggered in ThinkFuse, separating examples by final-answer correctness. The primary model is Qwen3-4B and the auxiliary model is Ministral-3B-Reasoning. Position 0 denotes the point immediately after <think>, and position 1 denotes the point immediately before </think>. In MATH-500, fusion for incorrectly answered examples is more dispersed across early and middle parts of the thinking stage, whereas GPQA shows a smaller difference by final-answer correctness. Figure 3: ThinkFuse fusion-position distribution. Normalized positions of thinking-stage segments where fusion is triggered, separated by final-answer correctness. The primary model is Qwen3-4B and the auxiliary model is Ministral-3B-Reasoning. Appendix F Comparison with Post-Hoc Critique ThinkFuse selects between primary and auxiliary candidate segments at uncertain segment boundaries during the thinking stage using primary-model PPL. For comparison, we also evaluate a post-hoc critique baseline. In this baseline, the primary and auxiliary models first generate complete reasoning trajectories and answers independently. If the two answers agree, we keep the primary output; otherwise, the auxiliary model critiques the primary output, and the primary model produces a revised answer conditioned on the critique. Table 11 compares the two approaches with the same Qwen3-4B × EXAONE-Deep-2.4B model pair and the same evaluation protocol as the main experiments. Benchmark ThinkFuse Post-hoc critique MATH-500 91.0 (+2.0) 86.3 (−-2.7) GSM8K 99.0 (+7.0) 92.0 (+0.0) AIME24 73.3 (+20.0) 30.0 (−-23.3) GPQA 55.1 (+1.1) 27.8 (−-26.2) NQ-Open 38.5 (+9.0) 40.0 (+10.5) Table 11: ThinkFuse vs. post-hoc critique. Accuracy (%) with the same Qwen3-4B × EXAONE-Deep-2.4B model pair and the same evaluation protocol as the main experiments. Colored values in parentheses denote the difference from Qwen3-4B standalone accuracy. Limitations of Post-Hoc Critique. Post-hoc critique intervenes only after the primary model has completed its reasoning trajectory. It therefore re-evaluates and revises a completed solution rather than replacing an incorrect intermediate branch when it first appears. In contrast, ThinkFuse intervenes locally at segment boundaries during the thinking stage, preserving reusable reasoning context while replacing only the uncertain segment. Appendix G Supplementary Comparisons with Uncertainty-Guided Test-Time Scaling Methods MUR Yan et al. (2026) and SpecReason Pan et al. (2025) guide test-time scaling with uncertainty, as ThinkFuse does, but pursue different objectives. MUR scales computation within a single model, and SpecReason accelerates a large model through speculative step drafting. We examine how these uncertainty-based intervention policies behave compared to ThinkFuse to further isolate the effect of trajectory-calibrated fusion triggering. G.1 Comparison with MUR MUR tracks momentum-smoothed step-level uncertainty and allocates additional computation to uncertain steps within a single model. We re-implement MUR from the official repository with Qwen3-4B under the 16K-token budget and evaluate two variants, the default ϕφ-decoding and a MUR-style variant that employs Ministral-3B-R as a critic. As shown in Table 13, both variants fall below the standalone Qwen3-4B, whereas ThinkFuse improves it on both benchmarks. We attribute this gap in part to MUR’s prompted step segmentation, which inserts explicit step markers into the trace and alters the natural reasoning flow over which uncertainty is measured. ThinkFuse instead monitors fixed-length segments without modifying the generation format. Method AIME24 GPQA Qwen3-4B standalone 53.3 54.0 MUR (ϕφ-decoding) 16.7 (−-36.6) 37.9 (−-16.1) MUR (Ministral critic) 53.3 (+0.0) 48.0 (−-6.0) ThinkFuse 73.3 (+20.0) 64.6 (+10.6) Table 12: Comparison with MUR. Accuracy (%) with Qwen3-4B as the reasoning model under the 16K-token budget and the same evaluation protocol as the main experiments. ThinkFuse pairs Qwen3-4B with Ministral-3B-R. Values in parentheses denote the difference from Qwen3-4B standalone accuracy. Method AIME24 GPQA Qwen3-4B standalone 53.3 54.0 DeepSeek-R1 standalone 0.0† 21.2 SpecReason 0.0 (−-53.3) 44.4 (−-9.6) ThinkFuse 56.7 (+3.4) 63.3 (+9.3) Table 13: Comparison with SpecReason. Accuracy (%) under the 16K-token budget and the same evaluation protocol as the main experiments. SpecReason uses DeepSeek-R1-Distill-Qwen-1.5B as the generator and Qwen3-4B as the verifier, and ThinkFuse uses the same two models as primary and auxiliary. Values in parentheses denote the difference from Qwen3-4B standalone accuracy. The † symbol marks AIME24 results affected by length-limit or final-answer truncation. G.2 Comparison with SpecReason SpecReason lets a small model draft each reasoning step and a larger base model score every draft through prompting-based critique, accepting the draft or regenerating the step itself. We run the public implementation with DeepSeek-R1-Distill-Qwen-1.5B as the generator and Qwen3-4B as the verifier, keeping the acceptance threshold of 7, greedy verifier scoring, and the 16K-token budget. As shown in Table 13, SpecReason improves over its standalone generator but remains below both the standalone Qwen3-4B and ThinkFuse. The verifier fallback operates as intended, accepting only 15.6% of the proposed steps on GPQA, and most AIME24 failures end in repetitive reasoning without a valid answer rather than in budget truncation. These results reflect the different goals of the two methods. SpecReason approximates the quality of its base model at lower cost by verifying every step, whereas ThinkFuse calibrates intervention against the trajectory history and targets accuracy beyond the stronger model.