Hawkeye: Model Collaboration for Efficient Reasoning
Authors: Jianshu She
Zhuohao Li
Zhemin Huang
Qi Li
Peiran Xu
Haonan Li
Qirong Ho
Venue: COLM 2025 (2025)
Keywords: reinforcement learning (with human feedback)
fine-tuning
compression
decoding algorithms
reasoning algorithms
TL;DR: We provide an efficient inference pipeline that optimizes Chain-of-Thought (CoT) reasoning by instructing a Large Language Model (LLM) to generate concise yet effective CoTs for a Small Language Model (SLM) to decode through reinforcement learning.

Abstract: Chain-of-Thought (CoT) reasoning has demonstrated remarkable effectiveness in enhancing the reasoning abilities of large language models (LLMs). However, its efficiency remains a challenge due to excessive intermediate reasoning tokens, which introduce both semantic redundancy and unnecessarily detailed reasoning steps. Moreover, the computational expense and latency remain high, as the cost is determined by the number of output tokens, which encompasses these intermediate steps. In this work, we observe that most CoT tokens are unnecessary, and retaining only a small portion of them is sufficient for high-quality responses. Inspired by this, we propose Hawkeye, a novel post-training and inference framework where a large model produce concise CoT instructions to guide a smaller model in response generation. Hawkeye quantifies redundancy in CoT reasoning and distills high-density information via reinforcement learning. By leveraging these concise CoTs, Hawkeye is able to expand responses while reducing token usage and computational cost significantly. Our evaluation results show that Hawkeye can achieve comparable response quality using only 35\% of the complete CoTs while improving clarity, coherence, and conciseness by approximately 10\%. Furthermore, Hawkeye can accelerate end-to-end reasoning by up to 3.4× on complex math tasks while saving up tp 60\% inference cost. Hawkeye will be open-sourced and the models will be available soon.

Published as a conference paper at COLM 2025
Hawkeye: Model Collaboration for Efficient Reasoning
Jianshu She"", Zhuohao Li"", Zhemin Huang?, Qi Li*, Peiran Xu², Haonan Lit, Qirong Ho!
Mohamedd bin Zayed University of Artificial Intelligence (MBZUAT)
Uniiersityy of California, Los Angeles *Stanford University
*Independent Researcher
Abstract
Chain-of-Thougte (CoT) reasoning has demonstrated remarkable effective- ness in enhancing the reasoning abilities of large language models (LLMs). However, its efficiency remains a challenge due to the generation of exces- sive intermediate reasoning tokens, which introduce semantic redundancy and overly detailed reasoning steps. Moreover, computational expense and latency are significant concerns, as the cost scales with the number of output tokens, including those intermediate steps. In this work, we observe that most CoT tokens are unnecessary, and retaining only small portion of them is sufficient for producing high-quality responses. Inspired by this, we propose HAWKEYE 1, a novel post-training and inference framework where large model produces concise CoT instructions to guide smaller model in response generation. HAWKEYE quantifies redundancy in CoT rea- soning and distills high-density information via reinforcement learning. By leveraging these concise CoTs, HAWKEYE is able to expand responses while reducing token usage and computational cost significantly. Our evaluation shows that HAWKEYF can achieve comparable response quality using only 35% of the full CoTT, while improving clarity, coherence, and conciseness by approximately 10%. Furthermore, HAWKEYE can accelerate end-to-end reasoning by up to 3.4x on complex math tasks while reducing inference cost by up to 60%+
1 Introduction
The emergence of reasoning-capable large language models (LLMs) (OpenAI et al., 2024; DeepMind, 2024; Guo et al., 2025) has recently made headlines. Equipped with Chain- of-Thought (CoT) reasoning(Wei
al., 2023), these models "think" by producing lengthy internal reasoning traces before generating a final response. This reasoning paradigm decomposes complex questions and applies multiple strategies to verify and refine answers, mimicking human-like problem solving. It has proven particularly effective for tasks that require fine-grained, step-by-step logical synthesis, such as mathematics and code generation (Zhang et al., 2022; Sprague et al., 2024).
However, such test-time compute scaling is inefficient, as a large portion of the generated "thinking" tokens is redundant. While long CoTs can improve reasoning quality, generat- ing them during inference introduces significant overhead. For example, the ÓpenAl ol model (OpenAl al., 2024) uses up to 40K tokens, whereas GPT-4o averages around 4K tokens for the same query (Patel, 2024), leading to a 10x increase in KV cache memory usage. Moreover, post-training and deployment of reasoning models are extremely costly.
Equal contribution.
Project website: link
t HaWKEYE has been open-sourced at GitHub and models are available at Huggingface. she@mbzuai.
8 Correspond to <jianshu.she@mbzuuui ac,
1

---

Published as a conference paper at COLM 2025
Question
Thinking
Redundant
Responses
Slow thinking and responses Frequent interruption by faults
CoTs
LLM
SLM
GRPO
Thinking
Responses
Question
Howkeye Thinking Responses
Reward
Length penalty
match
Fast thinking and accurate responses Low serving and less token usage
Figure 1: Overview of HAWKEYE and Comparison with Existing Reasoning Models. HAWK- EYE restructures the reasoning pipeline through model collaboration: a large model gen- erates critical Chain-of- instructions into complete responses to improve readability. The small model is fine-tuned using reinforcement learning high-density CoTs. HAWKFYE enables fast, efficient, and cost-effective reasoning by reducing token usage without sacrificing response quality.
(Co'T) instructions, while small model expands these
Knowledge distillation often necessary to improve accessibility in reinforcement learn- ing (RL)-based post-training. For example, the API cost of OpenAl ol is approximately 6x higher than that of GPT-4o. As reasoning models continue scale at inference time, improving their efficiency has become an increasingly urgent challenge.
Although prior work has explored improving the test-time compute efficiency of reasoning, many approaches remain limited to self-reflection or multi-turn CoT tuning. For instance, Cheng & Durme (2024) reduce computational overhead by streamlining intermediate rea- soning steps, while Wu et al. (2025) systematically examine the trade-off between efficiency and precision in large-scale reasoning. Additionally, Fu et al. (2024) introduce request tracking and scheduling based model certainty, enabling early stopping to meet service- level objectives (SLOs) for latency-sensitive users. However, these methods do not address the fundamental challenge of overthinking in reasoning models: How reasoning redundancy and effectively exploit to enable more efficient thinking and generation?
measure
In this work, we propose HAWKEYE, a fast, efficient, and cost-effective CoT reasoning pipeline that is adaptable wide range of reasoning models. Our key insight spans both the inference and post-training stages. At inference time, we find that only the crit- ical 20% of tokens meaningfully contribute the final answer, while the remaining 80% introduce redundancy and can be safely removed. We provide a comprehensive assessment of this phenomenon across several popular reasoning models and diverse datasets. Dur- ing post-training, we leverage reinforcement learning to guide models in identifying and retaining only the most informative tokens, enabling high-density reasoning. HAWKEYE introduces model collaboration, wherein a powerful model generates concise reasoning instructions, and small models expand them into human-readable responses. By retaining only critical CoTs and discarding redundant tokens during inference, HAWKEY' signifi- cantly reduces CoT reasoning complexity and cost, while maintaining even improv- ing- res-res quality across datasets of varying difficulty levels (e-g., GSM8K (Cobbe et al., 2021), MATH (Hendrycks et al., 2021), MATH500 (Lightman et al., 2023), AIME), In our evaluation, HAWKE achieves up 67.6% reduction in reasoning tokens, a 62% reduction in serving cost, and a 3.4x speedup in end-to-end reasoning compared to state-of-the-art reasoning models.
Our contributions can be summarized as follows:
1.
We propose a novel reasoning paradigm, HAWKEYE, which utilizes model collabora- tion for efficient reasoning. In this setup, large model generates concise reasoning instructions, which a small model then expands into full responses. HAWKEYE significantly reduces both computational and financial costs while preserving the re-
2

---

Published as a conference paper at COLM 2025
Origital Rosssieg
Qucitice
Haaskye Thinking
Saapsnet-Rl-2iatie (wweeddd-------aaaaeeee (LLI
the spacton 22v03 oosoorr
tpll
salke
The saad vtsc sqaaties dh bas razta ean 15
wattlaly ce Uitraace teat
Thinking Ropeno
Beopseelc-k--aieet led- quee-
arrww loue 120) Vittracte iizi 10 lape ottehtarrev Seuad in 2811 Acting
(kay, bawe rais ai lan beens uobrr Inn, ase to fand Vie e asl. alright, leets sse fow
colonns
Hawkeye Instruction
Horker Exparnkes
Quee2.5-8.11 5-b.58 (SLN)
Foret iff, resetter cometaing called Vieraae farms las frme
Sell of post Vi-ara -1at22 auSt,. Froduct of roots
the qyan oor ierieet tras prrgertie of rooe a boo
pracienti
But watt, the aroblen ecateeenty in,
the
the opation uarr sn
qutratic
glas the and I Vrrae (ontte (00
that plons cenatioon::
1l 2 4.2 Sarauus veracted int a Lieelles a 28 53 dlso, siecs
2723 Prodact: Mn/2 e 3811
the ve at S15
taves So, value sor est Ui
More than colana
Only 110 takens
Figure 2: An example of HAWKEYE reasoning. The red highlights marks critical tokens that cannot be removed. HAWKEYE generates a high density of critical tokens and reduces token usage by over 70% (600 -> 182 tokens). More examples can be found in Appendix C.
sponse quality. We provide both empirical and theoretical evidence demonstrating the effectiveness of this collaborative reasoning framework.
2. We present the first systematic study of Co'I' redundancy, showing that excessive reasoning tokens are a widespread phenomenon across various tasks. Our analysis reveals that substantial portion of these tokens can be removed using principled compression strategy without degrading output quality.
3. We curate a high-quality CoT dataset and fine-tune a reasoning model using rein- forcement learning to optimize CoT generation. This approach reduces CoT length by over 75% compared to the original large model while maintaining performance, with only a 4% drop in accuracy on the evaluated dataset.
2 Related Work
Chain of Thought Chain-of-Thought (CoT) reasoning has become a dominant approach in recent reasoning models such as OpenAl ol (OpenAl et al., 2024) and DeepSeek-RI (Guo et al., 2025). It generates rationales for questions and encourages models think before responding. The quality of CoTs is critical, as errors can propagate due to the auto-regressive nature of generation. Several approaches have been proposed to optimize CoT reasoning, including self-consistency (Wang et al., 2023), least-to-most prompting (Zhou et al., 2022), Graph of Thoughts (Yao et al., 2023a), and ReAct (Yao et al., 2023b).
Inefficiency in Reasoning Models Despite the success of reasoning models, step-by-step thinking is often lengthy and incurs substantial computational overhead. To address this issue, recent studies have focused on improving reasoning efficiency. For example, Han et al. (2024) propose generating token budget-aware prompts for CoT reasoning. Building on this idea, Xu et al. (2025); Luo et al. (2025); Arora Zanette (2025) introduce token limit hints to encourage more informative reasoning steps. Beyond token budget methods, Ma et al. (2025) identify a direction in the model parameter space that effectively controls the length of CoTs Other research (Liu et al., 2024) explores reasoning shortcuts to further reduce unnecessary steps. However, these methods often rely on manually tuned hyperparameters and lack the capacity to automatically balance reasoning efficiency and answer accuracy.
Reinforcement Learning in LLMs Reinforcement learning (RL) has shown strong results in post-training reasoning models. Early work (Rafailov et al., 2023) aligned models with human feedback (RLHF) using classic algorithms like PPO (Schulman et al., 2017) and TRPO (Schulman et al., 2015). To improve scalability, methods such as DPO (Rafailov et al., 2023) and GRPO (Shao et al., 2024) reformulated alignment over human preferences. Modern RL approaches avoid explicit value function estimation while preserving preference-alignedd learning. DeepSeek-RR R1 (Guo et al., 2025)) demonstrated
a ranked contrastive loss
3

---

Published as a conference paper at COLM 2025
GPT-4o
Cluuse 3.5 Sonet instructs
Grot Instruts
63
50
52-
Accuracy
10
33
Qwa12.3 2w..2.5.0.281111 5.2.Btamma
0was2.5 i.....ratuuu
100
Compression Rate
Figure 3: To examine redundancy in Chain-of-Thougghe (CoT) reasoning, smaller models (LLaMA3.1-1B3 Qwen2.5-0.5B) were guided by larger models (GPT-4o, Claude 3.5 Sonnet, Grok 3) to generate Co'Is for GSM8K. The Colls were refined via LLM-assisted feedback by removing (1) repeated, (2) filler-like, and (3) overly fine-grained tokens. Compression rate is defined the ratio of remaining to original token count. Results indicate that 60%-80% of CoT tokens are redundant across most models. See Appendix A for experimental details.
that large-scale RL post-training notably boosts reasoning performance over supervised fine-tuning (SFT).
3 HAWKEYE
In this section, we present the design details of HAWKEYE, our framework for efficient post-training and reasoning inference. The core idea behind HAWKEYE's post-training to minimize redundancy in intermediate reasoning tokens and accelerate reasoning, thereby reducing cost while enhancing CoT quality. During inference, HAWKEYE introduces a novel paradigm in which large language model (LLM) guides smaller language models (SLMs) to generate answers based on distilled CoTs. HAWKEYE achieves nearly a 50% reduction in cost and significantly faster inference without sacrificing response quality.
3.1 CoT Redundancy
Reasoning models such as DeepSeek-RI and OpenAl ol leverage intermediate Chain-of- Thoughts (CoTs) to decompose problems and produce more accurate responses on chal- lenging tasks. However, the quality of these CoTs is critical, as errors can propagate due to the auto-regressive nature of generation. While techniques such self-consistency (Wang et al., 2022), Tree-of-Thoughe (Yao et al., 2023a), Graph-of-Thouu Safeeton-of-Thuugee (Ning et al., 2023) enhance CoT reasoning through various optimiza- tions, they largely overlook CoT token efficiency factor that can significantly affect
(Besta et al., 2024), and
overall performance.
We observe that CoT reasoning often contains substantial redundancy due to (1) repeated hints, (2) filler phrases (e.g., "Well," " "Let me double-check"), and (3) overly fine-grained steps. Prior work (Han et al., 2024; Ma et al., 2025; Liu et al., 2024) has reported similar findings. To further investigate this, we designed an experiment to visualize the redundancy, as shown in Figure 3. We selected several small models that lack strong reasoning capabili- ties and instructed them using CoTs generated by reasoning models. This setup ensures that the models themselves do not introduce bias into the experiment. We compressed the CoTs by selectively removing intermediate steps (note: the final answer is not provided in this experiment). Accuracy remains stable until the compression rate approaches 70% (highlighted in Figure 3). This indicates that nearly 70% of intermediate CoT tokens can be safely removed without significantly affecting accuracy. We further conducted experi- ments on various benchmarks and reasoning models, and observed consistent results (see Appendix A). By refining positive samples and removing redundant tokens, we are able to reduce token usage by nearly 70% while still producing high-quality responses. We refer to the retained tokens as legic-bearing tokens, as they typically convey logical or mathematical reasoning (Figure?) 2).
4

---

Published as a conference paper at COLM 2025
Our preliminary results demonstrate the significant redundancy present in CoT reasoning. However, leveraging this redundancy remains challenging due to two key issues: (1) identifying critical CoTs is difficult, as there is lack of efficient metrics to quantify their importance; and (2) existing methods (Ma et al., 2025) are difficult to adapt for online serving, rendering real-time reasoning infeasible. To address these challenges, we fine-tuned a PrepSeek-RI-distllle
Qwen-7B HAWKEYE model offline via reinforcement learning. We found that the model effectively streamlines its reasoning process by focusing on a minimal set of critical steps, and it exhibits strong generalization capabilities. A detailed discussion provided in Section 3.2.
3.2 HAWKEYE: post-training
Guo al. (2025) employs rule-based GRPO approach for post-training, thereby endowing the R1 model with state-of-the-ard reasoning capabilities. Inspired by this post-training paradigm, we employ GRPO to fine-tune 7B model, enabling generate more concise and accurate CoT instructions.
As shown in Figure 3, we observe that CoT density achieves an optimal trade-off between compression rate and performance when the compression rate ranges from 0.6 to 0.8 rel- ative to the original. This allows for a reduction in length while preserving the original information. Based on this observation, we set the starting point of the length penalty to 0.3 in our experiments and apply a quadratic penalty proportional to the number of tokens exceeding this threshold.
Algorithm 1 GRPO fine-tuning of Model A for compressed Chain-of-Thoughh generation
Require: Policy model πia (Model A), frozen response model (Model B), training dataset D = {qi a; c; orig) instruction prompt length penalty weight A, target compression ratio (set to 0.3)
1: while Model A not converged do | C D do
2: for each mini-batch/ { for each aq crig) in mini-batch do
3:
4:
c + ModelA(q)
5:
a < ModelB(q,ce,
6:
P < A mamx (0, len(c) a (or())))))
7:
R + (M(ā,a) -
8:
0 0 + 1 V log ae(c q) R
9:
end for
end for end while
11:
12: return Fine-tuned parameters 0
DeepSeek-RI reward model evaluates only the exact match between the generated output and the ground-trume answer, along with the length of the CoTs, without imposing explicit constraints on the generation process. Accordingly, HAWKEYE's fine-tuning framework incorporates a small model as the answer generator, with the exact match reward computed based its final output.
We fine-tune Model A (policy ni) using GRPO to generate CoT instructions. For each training pair (q, a, Corig), Model A generates CoT c, and weaker, frozen Model B produces response based (q, s),, where is fixed instruction prompt. The reward computed as
R = aM) A max (0, Len))( - 0.3 len((orig)))
where EM is the exact match score and len(.) denotes token count. The model is updated via policy gradient:
x- a+ log (c 9) R.

---

Published as a conference paper at COLM 2025
This design choice encourages the large model to generate CoIs that are not only truncated but also more coherent and interpretable, thereby enhancing the small model's ability to follow the reasoning and produce correct answers. As result, this approach mitigates reward hacking, where the large model might otherwise bypass reasoning and directly output the answer. Empirical results, as shown in Figure 4, indicate that omitting the small model leads to an abrupt reduction in CoTT length in pursuit of higher rewards, whereas incorporating the small model results in more gradual and controlled decrease, aligning more closely with the intended reward structure.
Without small model
100
With small model
400
Reward scores
-100
Length
300
My Mh Map
-300
200
-400
100
-500
Without small madel
600
With small model
0-
-700
50
100
50
150
200
train/global_ss _step
train/global_ster
(a) CoT length across training steps. Without a small model, the policy collapses to extremely short CoTs in pursuit of higher rewards.
(b) Reward trajectory during training. Both converge to similar reward scores, but a small model can help avoiding reward hacking.
Figure 4: Effects of incorporating a small model during CoT generation. Including a small model stabilizes CoT length and mitigates reward hacking while achieving comparable reward scores.
3.3 HAWKEYE: inference
Drawing upon the findings presented in Section 3.1, we decompose the reasoning workflow of HAWKEYE into two phases. In the first phase, a large language model (LLM) constructs the core logical framework, thereby establishing a foundational structure for reasoning. In the second phase, a smaller language model (SLM) leverages this structured outline to generate comprehensive final responses. As illustrated in Figure 1, the SLM effectively elaborates on the distilled and logically rigorous reasoning traces (CoTTs derived from the LLM, ultimately producing complete and coherent answers.
Figure provides a comparative analysis of two representative instances from HAWKEYE. The tokens explicitly highlighted in red represent essential components that encapsulate key reasoning steps, whose retention is critical to preserve reasoning fidelity. Empirical evaluations demonstrate that, through our reinforcement leaming-ennhanee instruction methodology, HAWKEYE achieves superior knowledge distillation compared to existing reasoning-base based models.
Formally, our inference procedure can be articulated as follows:
x SLM (xge prompt [q;c])
In this formulation, denotes validated hhin-offthhoughe recognized explicitly as reliable reasoning trajectory. Consequently, the SLM is strategically guided to elaborate c into fully developed response.
Notably, the concept of two-step decoding using the same model was proposed as early as 2023 and has been demonstrated to be effective (Kojima et al., 2023; Lightman et al., 2023; Li et al., 2024). However, the question of how to obtain high-quality instructions for the second-step decoding remains underexplored. Existing studies predominantly rely self-prompting strategies. In contrast, explicitly introduce dual-model decoding process during fine-tuning. As we demonstrate in the next section, our method improves both response quality (Figure 6) and throughput (Figure 7).

---

Published as a conference paper at COLM 2025
3.4 Experimental Setup
We build HAWKEYE based on PyTorch and perform evaluations on 8 NVIDIA H100 GPUs. Our baseline includes Reepsee-RR-Distillet 1ediileeeddd reasoning model capable of both reasoning and answering. We select MATH, MATH500, GSM8K, and AIME as our eval- uation benchmarks. These benchmarks encompass complex reasoning tasks that span mathematics and commonsense reasoning.
4 Evaluation
4.1 Response Quality
HAWKEYE inference requires collaborative decoding between large model and a small model. We evaluated the accuracy of various math datasets. As shown in Figure 5, HAWKEYE exhibits an accuracy drop ranging from 3% to 6% on MATH500, MATH, and GSM8K. However, once the large model generates the corresponding reasoning chain as an instruction rather than directly providing com- plete answer- the decoding process of the small model becomes more flexible, allowing the use of different system prompts or fine-tuning with specific datasets. This flexibility en- ables various enhancements, such as employing a safety-focused SLM to ensure responsible outputs or leveraging an RLHF-tuned model to better align with human preferences. In our experiments, we used Qwen2. 5-0. SB-Instruct generate the final response, optimizing for decoding efficiency.
and HAWKEYE across
100
DeepSeek R1 Distil Qwer 78 hawkeys Reasenng Qwer2255 0.58
80
Accuracy (%)
40
20
MATH500
MATH
Datasets
Figure 5: Exact match accuracy on MATH500, MATH, GSM8K, and AIME. HAWKEYF achieves comparable accuracy to the baseline while significantly reducing computational cost and token usage.
To assess whether the decoding process remains aligned with the original question and to assess the quality of responses generated by the 0.5B model, we conducted comparative analysis using GPT-4o, Grok-3, and C1 3.5. Specifically, we employed the L.M--ss- Judge to compare the original outputs and those of the 0.5B model across five dimensions: Coherence, Completeness, Clarity, Correctness, and Conciseness. Results are presented in Figure 6, and detailed evaluation procedures are provided in Appendix B.
The results demonstrate that a more concise CoT strategy, combined with the 0.5B model, achieves performance comparable to that of the original model. Moreover, this approach exhibits superior performance in Clarity, Conciseness, and Coherence, highlighting its potential to enhance the suer-friendliness of the decoding process.
4.2 System Latency
To rigorously assess the inference acceleration capabilities of HAWKEYE, conduct an end- to-end latency evaluation, measuring the time span from initial user prompt processing to final token generation. Our benchmarking is implemented using SGLang (Zheng et al., 2024),
7

---

Published as a conference paper at COLM 2025
Completeness
Completeness
Completeness
Clarts
Clarty
Clarity
Cohfrence
Coherence
Coherence
Correctapss
Corracthess
Correcheess
Cbiciseness
Conciseness
Canciseness
Deep5eak-R1
Hawkeye
Hawkeye 178 SLM)
Figure 6: Response quality evaluated using LLM-as-Judge benchmarks (GPT-40, Claude 3.5 Sonnet, Grok 3), scored across five aspects. Model collaboration is shown to improve response quality. Notably, increasing the size of the SLM (from 0.5B to 7B in our evaluation) offers limited additional benefit. See Appendix B for experimental settings.
Performance Comparison (10ce)
Performance Comparison (100cc)
45
45
Original Thinking Response
Original Thinking Response
40
Original Thinking
64.3%
Original Thinking
35
Hawkeye Thinking
Hawkeye Thinking
Hawkeye Response
Hawkeye Response
30
58.2%
20
.4.5%%
20
10
10-
20.5%
18.2%
Math500
Math
GSMBK
0
Math500
Math
GSM8K
(a) Time to Last Token Concurrency = 10
(b) Time to Last Token Concurrency 100
Figure 7: Time last token under two concurrency levels (10 and 100) across different reasoning pipelines. Original Thinking refers to CoT generation by the DeepSeek-R1- Distill-Qwen-7B model, while Hawkeye Thinking utilizes compressed CoTs to improve token efficiency. Percentage labels indicate the latency reduction achieved by HAWKEYE. As concurrency increases, HAWKEYE's advantage becomes more pronounced (e.g,, from 45.5% to 64.3% on MATH500), demonstrating better scalability by mitigating unnecessary reasoning.
which facilitates concurrent handling of multiple requests and enables precise recording of processing times for individual queries. Table 1 systematically presents the inference acceleration achieved by HAWKEYE across the complete reasoning pipeline. In the Hawkeye framework, the generated output can be decomposed into two components: the thinking tokens, which are enclosed within the special markers [Think] and [/Think], and the response tokens. The "HAWKEYE (Full)" setting denotes the complete reasoning process, encompassing both the CoT reasoning sequence produced by the large model (i.e., the [Think] ... [/Think] segment) and the final response generated by the small model. In contrast, the "HAWKEYE (CoT-only)" setting considers only the large-model CoT reasoning tokens, excluding the subsequent response tokens.
Under a concurrency level of 10, HAWKEYE demonstrates inference speedups of up to 1.6x, 2.1x, and 2.5x relative to the baseline GSM8K, MATH500, and MATH, respectively, while utilizing only 55.7%, 41.1%, and 38.3% of the original total token counts. When the concurrency increased to 100, the speedup factors further improve to 1.8x, 3.4x, and 2.8x,
8

---

Published as a conference paper at COLM 2025
Dataset
Method
Concurrency
Time per Req (6)
Avg TBT
Tokens
Baseline (Full)
10
3.69
0.013
297.0
HAWKEYE (CoT only)
10
2.37
0.014
163.7
(Full)
0.009
GSMBK
Baseline (Full)
100
5.13
0.016
331.0
HAWKEYE (CoT only)
100
2.93
0.017
171.0
HAWKEYE (Full)
100
3.75
0.011
332.0
Baseline (Full)
10
14.95
0.013
1136.54
HAWKEYR (CoT only)
10
7.11
0.015
471.0
HAWKEVE (Full)
10
8.31
0.011
771.4
Math500
Baseline (Full)
100
96.20
0.021
1463.80
HAWKEYE (CoT only)
100
10.74
0.022
474.9
(Full)
100
13.34
0.017
Baseline (Full)
10
13.09
0.014
942.06
HAWKEYE (CoT only)
10
5.14
0,014
361.23
HAWKEYE (Full)
10
6.23
0,011
565.33
Math
Baseline (Full)
HAWKEYE (CoT only)
100
7,48
0.022
332.50
HAWKEYE (Full)
100
9.58
0.016
582.10
Baseline (Full)
93.48
0.016
5943.90
AIME
(CoT only)
HAWKEYF (Full)
10
68.90
0.015
4722.50
Table 1: Overall performance comparison across various datasets. Time per Reg denotes average latency per request and Tokens denotes the average token count per request.
Dalaset
Method
Acc
Tokens
Compression Rate (%)
GSMSK
CoT-Valve (OwO-32B-Preview)
95.1% + 94.0%
741.1 - 352.8
Hawkeye (DeepSSec-----DDiill--ee-eeee
90.7%
3510
O1-Pruner (QwQ-330-Previeew)
90.6% - 91.0%
2191.0 + 1385.0
36.7
MATH
Hawkeye RDeeslSec--l--iisillll (Deen)))lil Qwenn7B))
92.3% - 89.4%
942.0
361.0
61.7
MATH500
Hawkeye DDssi
80.1% 75.5%
1463.0
474.9
67.5
Table 2: Performance comparison between CoT-Valve, O1-Pruner, and Hawkeye GSM8K, MATH, and MATH500 datasets. Compression Ratio calculated as the percentage reduction in CoT tokens.
with corresponding token utilization reductions to 36.6%, 32.4%, and 36.6% the baseline total tokens. See Figure 7 for detailed latency comparisons.
4.3
Cost Estimation and Saving
100
10a
Concurrent Requests
100 Concurrent Requests
Serving Cost (%))
10a
Cost ($)
10a
20
DrepSookR1
10
Hawkeye
GSM8k
MATH500
MATH
AIME
GSMBK
MATH500
MATH
AIME
Dataset
Dataset
(a) Comparison of serving cost between HAWK- EYE and DeepSeek-R1, presented as percentage scale.
(b) Average serving cost under concurrency lev- els of 10 and 100 across various datasets. The y-axis is shown on a logarithmic scale.
Figure 8: Serving cost for HAWKEYE

---

Published as a conference paper at COLM 2025
Let Creq denote the cost per request, Tin the number of input tokens, Pin the price per input token, Tout the number of output tokens, Pout the price per output token, and the total number of requests. The serving cost is calculated follows:
The cost per request is given by:
Creq (Tin Pmn) + (Tout x Pout)
The total cost Cotal is then:
Ciota = Creq x R
For the baseline comparison, we assume fixed average input token count Tin per dataset, with all requests being cache hits. Current API prices vary by model capability; for instance, OpenAl ol has Pout $60/ M tokens, while DeepSeek-RI has Pout = $2.19 / tokens. We similarly compute the serving cost of HAWKEYE and compare it with the baseline.
As the Figure shows, due to the output token count saving, HAWKEYE costs less up to 98.40% and 59.09% than OpenAl-ol and DeepSeek-R1. Notably, the AIME dataset only appears in the 10 concurrent requests since doesn't have sufficient data for higher concurrency.
Conclusion
In this work, we introduce HAWKEYE, novel paradigm for efficient reasoning via model collaboration. HAWKEYE enables a large model to generate concise and informative Chain- of-Thought (CoT) instructions, which are subsequently expanded by a smaller model to produce coherent and accurate responses. This collaborative reasoning framework significantly reduces redundancy in intermediate reasoning steps.
Extensive evaluations across multiple reasoning benchmarks (e.g., GSM8K, MATH500, AIME) demonstrate that HAWKEYE achieves comparable or even improved response quality, while reducing reasoning token usage by 50%-70% and accelerating inference by up to 3x. These results suggest that combining instruction distillation with small-mode generation offers a promising pathway toward scalable and cost-effective reasoning systems without sacrificing performance.
10

---

Published as a conference paper at COLM 2025
References
Daman Arora and Andrea Zanette. Training language models to reason efficiently, 2025.
04463.
Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Michal Podstawski, Lukas Gianinazzi, Joanna Gajda, Tomasz Lehmann, Hubert Niewiadomski, Piotr Nyczyk, et al. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial Infelligence, volume 38, pp. 17682-17690, 2024.
Jeffrey Cheng and Benjamin Van Durme. Compressed chain of thought: Efficient reasoning through dense representations, 2024. URL http:s///arr....ogr/////////// 13171.
Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. Training verifiers to solve math word problems. Xro preprint arXio:2110.144 1111:2110,,,68,,, 2021.
Google DeepMind. Gemini 2.0 flash thinking, 2024. URL https://deepming / technoologies/geminnnn watmmiiiiiaasaiinniiila
Yichao Fu, Junda Chen, Siqi Zhu, Zheyu Fu, Zhongdongming Dai, Aurick Qiao, and Hao Zhang. Efficiently serving Ilm reasoning programs with certaindex. arXiv preprint ar arXt::4412.00993, 2024.
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al. Deepseek-rl: Incentivizing reasoning capability in Ilms via reinforcement learning. arXito preprint ar1n:22001.12945 2025.
Tingxu Han, Zhenting Wang, Chunrong Fang, Shiyu Zhao, Shiqing Ma, and Zhenyu Chen. Token-budget-awaree Ilm reasoning. arXiv preprint urXio:24122.8547,220 2024.
Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset. ar arXiv preprint ar Xi:::21033003874 2021.
Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa. Large language models are zero-shot reasoners, 2023. URL https://arxiw.org/bbb// 11916.
Liunian Harold Li, Jack Hessel, Youngjae Yu, Xiang Ren, Kai-Wei Chang, and Yejin Choi. Symbolic chain-of-thouggh distillation: Small models can also "think" step-by-step, 2024. URL http:::///axxi.or///bb/bb
14050.
Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. Let's verify step by step, 2023. URL htttp:://rxiv..og/aab////// 29050.
Tengxiao Liu, Qipeng Guo, Xiangkun Hu, Cheng Jiayang, Yue Zhang, Xipeng Qiu, and Zheng Zhang. Can language models learn to skip steps? In The Thirty- Annual Conference on Neural Information Processing Systems, 2024.
Haotian Luo, Li Shen, Haiying He, Yibo Wang, Shiwei Liu, Wei Li, Naiqiang Tan, Xiaochun Cao, and Dacheng Tao. Ó1-pruner: Length-harmonizing fine-tuning for ol-like reasoning pruning, 2025. URL pattps://arxiln http://or////////////e abs/2501. 12570.
Xinyin Ma, Guangnian Wan, Runpeng Yu, Gongfan Fang, and Xinchao Wang. Cot-valve: Length-compressible chain-of-thought tuning, 2025. URL https: https://arxxlvorrraa////// 09601.
Xuefei Ning, Zinan Lin, Zixuan Zhou, Zifu Wang, Huazhong Yang, and Yu Wang. Skeleton-of-thougght Prompting llms for efficient parallel generation. arXiv preprint arXin:2307.15337, 2023.
11

---

Published as a conference paper at COLM 2025
OpenAI, Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, and Alec Helyar et. al. Openai ol system card, 2024. URL wttpt:://aaaaaa org/abs/2412.16 16720.
Dylan Patel. Inference math, simulation, and ai megaclusters, 2024. URL httpp::://///thub.. com//Scallinggnneeligeeeeee
Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly reward model. Advances in Neural Information Processing Systems, 36:53728-5377 2023.
John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International conference machine learning, pp. 1889-1897.
PMLR, 2015.
John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. ar arv preprint ar feee:177.003477 2017.
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Xiao Bi, Haowei Zhang, Mingchuan Zhang, YK Li, Y Wu, et al. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arviv preprint arXiv:2402.03300, 2024.
Zayne Sprague, Fangcong Yin, Juan Diego Rodriguez, Dongwei Jiang, Manya Wadhwa, Prasann Singhal, Xinyu Zhao, Xi Ye, Kyle Mahowald, and Greg Durrett. To cot or not to cot? thain-of-thought helps mainly on math and symbolic reasoning. arXie preprint arXio:2409.12163 2024.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. Xrv preprint ar Xix::2208.1117 2022.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoc Le, Ed Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models, 2023. URL https://arxiv.orr/abss
11171.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoe Le, and Denny Zhou. Chain-of-thoought prompting elicits reasoning in large lan- 11983.
guage models, 2023. URL https::/arxxiv.org/abs//////
Zongqian Wu, Baoduo Xu, Ruochen Cui, Mengmeng Zhan, Xiaofeng Zhu, and Lei Feng. Rethinking chain-of of-thought from the perspective of self-training, 2025. URL https: 2412 10827.
Silei Xu, Wenhao Xie, Lingxiao Zhao, and Pengcheng He. Chain of draft: Thinking faster by writing less. Xrv preprint drXiv:2502.18600, 2025.
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. Advances in neural information processing systems, 36:11809-11822, 2023a.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and
Yuan Cao. React: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR), 2023b.
Zhuosheng Zhang, Aston Zhang, Mu Li, and Alex Smola. Automatic chain of thought prompting in large language models. arv preprint ar arXiv:2210.03493 2022.
Lianmin Zheng, Liangsheng Yin, Zhiqiang Xie, Chuyue Livia Sun, Jeff Huang, Cody Hao Yu, Shiyi Cao, Christos Kozyrakis, Ion Stoica, Joseph E Gonzalez, et al. Sglang: Efficient exe- cution of structured language model programs. Advances in Neural Information Processing Systems, 37:62557-62583, 2024.
Denny Zhou, Nathanael Schärli, Le Hou, Jason Wei, Nathan Scales, Xuezhi Wang, Dale Schuurmans, Claire Cui, Olivier Bousquet, Quoc Le, et al. Least-to-most prompting enables complex reasoning in large language models. ar arviv preprint XrXiv22205.00625 2022.
12

---

Published as a conference paper at COLM 2025
A
Appendix A
We use the following prompt to generate a CoT towards GSM8K dataset:
Problem Prompt
You are helpful and thoughtful math tutor. Carefully work through the following problem step by step using clear reasoning and intermediate calculations. Explain your logic thoroughly, but do not give the final answer.
Problem:
jInsert the problem heres Let's think step by step.
A.1
Case Study
We first request the model to generate full Chain of Thought:
Problem and CoT
Problem: Rory orders subs for $7.50 each, bags of chips for $1.50 each, and cookies for $1.00 each for delivery. There's 20% delivery fee added at checkout, and she wants to add a $5.00 tip. What will her delivery order cost?
CoT:
To find the total cost of Rory's delivery order, we will break it down step by step. First, we calculate the cost of the subs. Rory orders subs $7 .0 each, so the cost of the subs is:
Cost of subs 7.50 15.00
Next, we calculate the cost of the chips. Rory orders 2 bags of chips at $1.50 each, so the cost of the chips is:
Cost of chips = 2 x 1.50 = 3.00
Then, we calculate the cost of the cookies. Rory orders 2 cookies at $1.00 each, so the cost of the cookies is:
Cost cookies x 1.00 = 2.00
Now, we calculate the subtotal. The subtotal is the sum of the costs the subs, chips, and cookies:
Subtotal 15.00 + 3.00 + 2.00 = 20.00
Next, we calculate the delivery fee. There is 20% delivery fee added at checkout, so the delivery fee is:
Delivery fee 0.20 20.00 4.00
Finally, Rory wants to add $5.00 tip. Therefore, the total cost including the tip is:
Total cost with tip 20.00 4.00 + 5.00
At this point, the total cost of Rory's delivery order can be calculated.
Then we ask the model to preserve only some important tokens in CoT and compress the CoT to certain level compared to the full CoT (80%, 60%, 40%, 30%, 20%, 10%).
13

---

Published as a conference paper at COLM 2025
Prompt for Chain-of-Tie -hooghh Revision
You are given a detailed step-by-step reasoning (Chain-of-Thoughh for solving a problem. Your task is to revise the explanation while keeping approximately (compression ratio)% of the original tokens unchanged. Make light edits for clarity or style if needed, but preserve the overall structure, meaning, and majority of the wording. Do not shorten or skip steps.
The key requirement is to retain the most important information in the original reasoning, ensuring that the core logic and steps are preserved. Original CoT:
<Insert the original Chain-of-Thoughh here>
Revised CoT:
The compressed CoT should be:
CoT Compressed to 80%
Rory orders 2 subs at $7.50 each, totaling:
2 x 7.50 = 15.00
2 chips at $1.50 each:
x 1.50 3.00
2 cookies at $1.00 each:
1.00 2.00
Subtotal:
15.00 + 3.00 + 2.00 = 20.00
Delivery fee (20% of subtotal):
0.20 20.00 4.00
Add $5.00 tip:
20.00 + 4.00 + 5.00
Total cost can now be computed.
CoT Compressed to 60%
2 subs: $15.00
2 chips: $3.00
cookies: $2.00 Subtotal:
15+342 = 20
Delivery fee:
0.2 20 4
Tip: $5.00 Total is:
20 4445
CoT Compressed to 40%
Calculate item costs: subs $15, chips $3, cookies $2. Subtotal = $20.
Add delivery fee (20%) = $4. Add tip = $5.
14

---

Published as a conference paper at COLM 2025
CoT Compressed to 30%
Get subtotal from items: 15 + 3 + 2 = 20. Calculate 20% delivery fee = 4. Add tip 5.
CoT Compressed to 20%
Item total = 20. Fee = 4. Tip = 5.
CoT Compressed to 10%
Items add up to 20.
Add delivery and tip.
15

---

Published as a conference paper at COLM 2025
B Appendix B
In evaluation of response quality, we use LLM-as-a-Judge to rate the response from clarity, completeness, coherence, correctness, and conciseness. We used the following prompt to rate the response:
Prompt for Evaluating Math Response
You are given response to specific math problem. Your task is to evaluate the response based on the following five criteria: clarity, completeness, coherence, correctness, and conciseness. Provide score for each dimension based on the standards outlined below:
1. Clarity (1-5): Does the response clearly explain each step of the reasoning? Is the language used straightforward and easy to understand? A score of 5 means the explanation is exceptionally clear with no ambiguity, while means it is very difficult to follow.
2. Completeness (1-5): Does the response address all parts of the question? Does include all necessary calculations and intermediate steps? A score of 5 means the response covers all required steps and details, while means critical parts of the problem are missing.
3. Coherence (1-5): Are the steps and reasoning logically connected? Does the response flow smoothly from one step to the next without any sudden jumps or gaps in logic? score of 5 means the response is well-structured and the reasoning is seamlessly connected, while means the explanation is disjointed and hard to follow.
4. Correctness (1-5): Does the reasoning lead to the correct result? Are the intermediate steps logically sound and consistent with the problem statement? A score of means the solution is correct and matches the question exactly, while means there are significant errors in reasoning or calculation.
5. Conciseness (1-5): Does the response avoid unnecessary information or repe- tition? it efficient without sacrificing important details? A score of 5 means the response is brief yet thorough, while means it includes excessive irrelevant information.
Provide your evaluation below, giving a score from 1 5 for each criterion and explaining your reasoning behind the scores.
16

---

Published as a conference paper at COLM 2025
C
Appendix C
As Figure shows an example of the CoT comparison between model and HAWKEYE model, we show more examples in this sections.
Question
Question: Find the common ratio of the infinite geometric series:
3
125
5 3 27
DeepSeek-KI--istill--eee-- Output (Full)
To find the common ratio of an infinite geometric series, know that each term is multiplied by constant ratio, r, to get the next term.
So, let's denote the first term as dj and the second term as a2- Then, the common ratio can be found by dividing the second term by the first term: /2 02/aj. Given the series: d1 = -3/5 and 022 = 5/3..
Calculating
Dividing fractions involves multiplying by the reciprocal, so (-5/3) ) (5/ - -3 = 25/9. But wait, 25/9 is greater than 1, which might be problem because for infinite geometric series to converge, the absolute value of the common ratio must be less than 1. Since [25/9] 1, the series might not converge. However, the problem asks for the common ratio regardless of convergence, so / 25/9. But let me double- check my calculations. First term: -3/5 Second term: -5/3 Third term: -125/27 Let
me check the ratio between the second and third term:
== (1-12/227/ = (125/27) * (3/5) = (125 x (27 = 375/135 25/9
Yes, it's consistent. So the common ratio is 25/9. But wait, the common ratio is 25/9, which is approximately 2.777..., that's large ratio. Typically, in such problems, the ratio is a simple fraction like 2 or Maybe made mistake somewhere. Let me recalculate: First term: -3/5 Second term: -5/3 So, #2/a1 = (-5/3)/ (3/3)/(33/// (3/5) (-5/3) (-5/3) = 25/9. Wait, is that right? Let me verify: (-5/3) divided by (-3/5) is equal to (-5/3) multiplied by (5/-3). Wait, no, the reciprocal of (-3/5) is (-5/3). So, it's (-5/3)* (-5/3) = 25/9. Yes, that seems correct. So, the common ratio is indeed 25/9. But let me check the third term to if it follows the same ratio. Third term should be 43 = a2 * (-5/3) (25/9) = (-125) /27. Which matches the given third term. So, it is consistent. Therefore, despite the ratio being greater than 1, the common ratio is 25/9. But just to be thorough, let me consider if there might be different interpretation. Alternatively, maybe the series written with a typo or something, but as given, it's 33/5, -5/3, -125/2 /7, So, each term is being multiplied by (25/9) to get the next term. Therefore, the common ratio is 25/9. But I'm a bit surprised because 25/9 is large ratio. Maybe I should express it as a mixed number, but 25/9 is already in simplest terms. Alternatively, maybe the problem expects the absolute value something, but the question just asks for the common ratio. So, I think the answer is 25/9. But let me check once more: First term: -3/5 Multiply by 25/9: (-3/5)((25/9 (-75) /45 (-5)/3, which is the second term.
Then, second term: (-5)/3 25/9 = (-125)/27, which the third term. Yes, so it's consistent.
Final Answer
25
The common ratio of the infinite geometric series is
9
17

---

Published as a conference paper at COLM 2025
HAWKEYE Output
To find the common ratio of the infinite geometric series:
-3 5
125
5
3
27
Step 1: Identify the first term (a1) and the second term (a2).
-3
-5
#1 = 5
02
Step 2: Use the formula for the common ratio (r):
== 42
3
-
5
25
21
3
3
x
-3
=
9
Final Answer:
25
18

---

Published as a conference paper at COLM 2025
Question
Question:
The graph of the parabola defined by the equation 2) +3
is rotated 180 degrees about its vertex, then shifted 3 units to the left, then shifted units down. The resulting parabola has zeros at x a and b. What is a b?
DeepSeek DeepSeek-Rl-Distill www.DDittll-wee---ee Output (Full)
Question: A parabola given by the equation y = (x - 2) + undergoes the follow- ing transformations:
Rotated 180 degrees about its vertex, Shifted 3 units left, Shifted 2 units down. What is the sum + b of the zeros x a and b of the resulting parabola? Alright, so I need to figure out this problem where a parabola is transformed in a few steps, and then have find the sum of its zeros. Let me try to break down step by step. First, the original parabola is given by the equation = (x - 2)² + +3. 3. I know that this a standard parabola vertex form, which is = a(x - h12 + k, where (h, k) is the vertex. So in this case, the vertex is at (2,3). Since the coefficient is positive, opens upwards, which is the standard shape. Now, the first transformation is rotating the parabola 180 degrees about its vertex. Hmm, rotating 180 degrees about the vertex... I think that would flip the parabola upside down. So, if was opening upwards before, it will now open downwards after the rotation. How does that affect the equation?
I remember that rotating a graph 180 degrees around a point changes the direction of the parabola. So, in terms of the equation, that would mean changing the sign of
the coefficient. The original equation is y =(x 2) 3. If we rotate it 180 degrees about its vertex, the coefficient of the squared term will change from positive to negative. So, the new equation should be = - (x 2) +
Wait, let make sure. Tf rotate 180 degrees, it's like reflecting over the vertex point, which in this case is (2, 3). So, yes, that would flip the parabola. So, the equation becomes y = -x (x 2)² + 3. Got that.
Next transformation is shifting the parabola 3 units to the left. Shifting left or right affects the x-coordinate of the vertex. Since it's 3 units to the left, we need to subtract from the x-coordinate
the vertex. The original vertex was at (2,3). So, shifting left 3 units would bring it to (2 - 3,3) (-1,3).
How does this affect the equation? In the vertex form, shifting left by units means replacing x with x + 3. So, starting from = -(x - 2x2 + 3, replacing x with x + 3 gives:
y ( +( -
(x +
+3
So now the equation = - 1)2 +3.
Next transformation is shifting 2 units down. Shifting down affects the y-coordinate of the vertex. The current vertex at (-1,3). Shifting down 2 units would bring it to (-1,1).
In the equation, shifting down 2 units means subtracting from the entire function:
(x 1)2 +3 3 2 = - + 1) +1
Now, need to find the zeros of this resulting parabola. Set y = 0:
1 - 0 - - 1)2 (x 2 Therefore, 0, 2, and a + b- -2. Final Answer:
or x -2
19

---

Published as a conference paper at COLM 2025
HAWKEYE Output
To determine a + b for the resulting parabola, follow these steps:
1. Original Parabola: Equation: y (x 2)2 + 3 - Vertex: (2,3)
Rotation: Rotating 180 about the vertex changes the equation to y -(x
2)² +3
Shift 3 Units to the Left: - Replace x with x + 3: y = (x+
Shift 2 Units Down: Subtract from the equation: y -
Find Zeros: Set y = 0: -(x ===+))+1=00+00 (==1"==1x000
6. Sum of Zeros: a + 0 (-2) 2
20


Reviews:
[{"review_id": "I3qQME1gkA", "reviewer": "Reviewer_rwTc", "summary": "This paper proposes HAWKEYE, a post-training and inference framework designed to improve the efficiency of Chain-of-Thought (CoT) reasoning in large language models (LLMs). HAWKEYE introduces a collaborative model architecture, where a large model generates concise CoT instructions, which are then expanded into full answers by a smaller model. The goal is to reduce token usage and inference latency while maintaining answer quality. To achieve this, the authors first analyze redundancy in CoTs and show that a large portion of tokens can be removed without significantly affecting performance. They use reinforcement learning (specifically GRPO) to fine-tune a generator model that outputs compressed but informative CoTs. During inference, these instructions guide a smaller model to produce coherent and accurate responses. The method is evaluated on multiple benchmarks (GSM8K, MATH, MATH500, AIME) and compared to existing models such as DeepSeek-R1.", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "- The paper provides comprehensive experimental evaluations of the proposed framework, covering efficiency, accuracy, and the quality of CoT reasoning.\n- The core idea of the paper is easy to follow.", "reasons_to_reject": "- The writing quality of the paper requires further improvement. There are many pieces shown in the paper that lack any explanation. For instance, the contribution summary (Line 81) contains incomplete paragraphs. Additionally, the caption of Figure 2 does not align with the figure content, there is no example with 182 tokens as described. \n- The proposed framework appears to cause a considerable performance drop (more than 2%) after compressing the CoTs, which raises concerns about its practical effectiveness. It would be helpful if the paper could showcase the actual accuracy numbers of the proposed framework to further clarify.\n- The paper lacks comparison with other efficient reasoning baselines, such as CoT-Valve [1] (a supervised fine-tuning-based method) and O1-pruner [2] (a reinforcement learning-based method). Including these baselines would strengthen the evaluation and contextualize the effectiveness of the proposed approach.\n- The distinction between HAWKEYE (Full) and HAWKEYE (CoT-only) is unclear. The paper presents both results in Table 1 but does not explain the differences between the two settings. If they represent different configurations, I am particularly interested in understanding the respective accuracy drops of HAWKEYE (Full) and HAWKEYE (CoT-only).\n\n[1] Ma, Xinyin, et al. \"CoT-Valve: Length-Compressible Chain-of-Thought Tuning.\" arXiv preprint arXiv:2502.09601 (2025).\n[2] Luo, Haotian, et al. \"O1-Pruner: Length-Harmonizing Fine-Tuning for O1-Like Reasoning Pruning.\" arXiv preprint arXiv:2501.12570 (2025).", "questions_to_authors": "Please refer to the section \"Reason to reject.\"", "extra_scores": {}}, {"review_id": "hGbfYcWB1y", "reviewer": "Reviewer_kmZC", "summary": "This paper proposes Hawkeye, a novel approach where a large, expensive model is trained to generate succinct CoT chains that a smaller, cheaper model can then expand out to arrive at an answer. It shows that this approach (mostly) retains the solution quality while reducing the last LLM cost to about a half. Along with conciseness, the authors also find the clarity and coherence of CoTs is increased in this process. I found the approach interesting, the experiments well-thought-out, and the results quite convincing, and am generally inclined positively despite some weaknesses and points that need clarification.", "questions": "", "limitations": "", "rating": 7, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "* Novel (to my knowledge) approach of using a small model to expand a succinct CoT generated by a large model.\n\n* Systematic experiments motivating the approach by (a) showing that there is significant redundancy in CoT chains and (b) training a large LLM to generate concise CoTs usable by itself (as opposed to by a smaller model) doesn't work well due to reward hacking.\n\n* Clear illustration of substantial reduction in inference cost while retaining performance (relative to the large model).\n\n* Well-thought-out experiments to understand the proposed system.", "reasons_to_reject": "* One could argue that cutting the cost in half is meaningful but not enough. E.g., half the cost of a large model is still very large compared to the cost of a small model. So, for deployed applications, training a smaller model if possible will remain more cost efficient.\n\n* Some parts of the paper can use more clarity. E.g., to me, conciseness of the CoTs generated by the proposed method is the main selling point; coherence, clarity, etc., are secondary benefits. Yet, they are discussed on equal terms in section 4.1, especially around Fig 6. Similarly, in the experimental setup / method setup, it would be better to clearly state exactly what's the large LLM used and the small LLM used. From the first paragraph of sections 3.4 and 4.1, I *think* the large model is DeepSeek-R1-Distilled-Qwen-7B and the small model is Qwen2.5-0.5B-Instruct. If so, it would be good to state this clearly.\n\n* Figure 7 leaves it unclear what happens if we use Hawkeye thinking + Original response. I think this would correspond to training the large model to generate a concise LLM (using the current setup), but then using the large model itself to process the concise LLM and derive an answer.\n\n* Some design choices are unclear. E.g., see question below about reward computation.", "questions_to_authors": "* In line 6 of the algorithm (also on text line 172), the reward is penalized with a term that is $\\max(0, len(c) - 0.3 len(a))^2$. If I am interpreting correctly, this penalty term is non-zero only when $len(c)$, the CoT length, is at least 0.3 times $len(a)$, the response length. This choice is confusing, as I can't imagine a practical case where the CoT length is anywhere close to 0.3 times the response length. Isn't CoT length usually much larger than response length, i.e., $len(c) \\gg len(a)$?\n\n* Do you have a sense of why the plots in Fig 3 are so strikingly similar across 3 very different large LLMs producing the CoT? I can imagine these trends being similar across large LLMs, but these plots look really strongly close to each other, point by point, almost within minor fluctuations.", "extra_scores": {}}, {"review_id": "9JCTb03Bpj", "reviewer": "Reviewer_fxiX", "summary": "The paper proposes $\\texttt{HAWKEYE}$, a 2-model framework designed to boost the throughput at inference time. The authors first highlight that existing CoT-based models are very redundant, and that the CoTs can be reduced by ~70\\% in length without significantly impacting the performance. The authors propose a novel post-training technique, where the first model is trained to generate Concise CoTs, with length penalty is used to enforce conciseness. To enforce correctness, the resulting CoT is fed to a smaller model, which must then output the correct answer based on the initial model's concise CoT. The authors argue that this 2 model setup is less prone to collapse, where the model (due to the length penalty) ends up generating very short CoTs. \n\nThe authors evaluate on standard mathematical reasoning benchmarks, and also evaluate qualitatively (with LLM-as-a-judge) the generated CoT. Lastly, they present a detailed evaluation on model throughput, showcasing that their approach performs similarly as standard post trained models, but are much more efficient at inference time.", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "1. The proposed method is original, flexible, and addresses a substantial bottleneck with reasoning based models\n2. A novel analysis on the usefulness of long CoTs, and highlight the redundancy in standard CoT\n3. The empirical analysis on model quality and throughput is well presented and well executed", "reasons_to_reject": "1. While I agree that a reasonable amount of tokens can be removed from CoTs without impacting performance, I am sceptical about the 70% number. Looking at appendix A, we have \n```\nCoT Compressed to 20%\nItem total = 20.\nFee = 4.\nTip = 5.\n```\nWhile the model could potentially get the right answer from this CoT, this does not mean that the model would have generated this CoT using the same token budget; in other words, to get to `item total = 20` for example, some computation had to be performed, and it's unclear whether the model would have gotten this right without first generating a longer version of the CoT. \n\n2. It is still unclear to me whether the initial Hawkeye Thinking phase produces or not the answer. The text would suggest that it does not, however the example in Figure 2 suggests that it does. Therefore, it's unclear what role the 2nd LM serves. The authors mention that this 2 LM setup is flexible and could enable e.g. the SLM to be more safety aligned, but the paper does not showcase an example of this directly. \n\nOverall, the paper would be stronger if the authors quantify how many times the first step generates the answer, and report performance for just the first step. Assuming it does generate the answer, the paper would be stronger if a) Figure 6 could be redone with and without the SLM, to show the qualitative impact of the SLM rephrasing.", "questions_to_authors": "1. It's unclear in Figure 3 what exactly the interplay between smaller and larger models. The CoT is generated by the smaller model, and then refined by the larger one ? or vice-versa ?\n2. In In Figure 2, what is the purpose of the expansion step exactly, since it gives the same output as the initial instruction reasoning process \n3. Regarding why Hawkeye's design mitigates reward hacking, \"where the large model might otherwise bypass reasoning and directly output the answer\", what is stopping the output of model A (c) to be just the answer (so c == solution). Wouldn't that achieve the optimal loss ?\n4. In Figure 5, can you confirm that Deepseek-R1-Distill-Qwen-7B is used for Hawkeye's initial instruction as well ?\n5. Minor typo : Line 81 is incomplete", "extra_scores": {}}, {"review_id": "r08Ga4GV5Z", "reviewer": "Reviewer_zrRu", "summary": "This paper proposes a CoT compression method based on GRPO and model collaborative optimization. During the model training phase, this approach encourages LLMs to generate concise and coherent CoTs, effectively mitigating the \"reward hacking\" phenomenon and improving reasoning reliability. In the inference phase, the LLM first constructs a core logical framework as the foundational structure for reasoning, which the SLM then utilizes to produce more comprehensive and refined final responses.", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "1. The authors conduct a quantitative analysis of the CoT redundancy problem, revealing that redundant reasoning tokens are a widespread and significant issue across various task scenarios.\n\n2. The proposed method significantly reduces the length of CoT while effectively decreasing the model's inference latency, with only minimal performance degradation across multiple mathematical reasoning datasets.", "reasons_to_reject": "1. It is commendable that the authors further investigate how different length penalty factors and dataset sizes affect the final experimental results to thoroughly evaluate the robustness and generalizability of their proposed method.\n\n2. The current selection of baseline experiments seems somewhat limited. Conducting a more thorough comparison with existing reinforcement learning-based COT compression methods, such as [1][2], would help better demonstrate the relative advantages of the proposed approach.\n\n[1] O1-Pruner: Length-Harmonizing Fine-Tuning for O1-Like Reasoning Pruning\n\n[2] Training Language Models to Reason Efficiently", "questions_to_authors": "1. Since the main datasets are centered on mathematical reasoning tasks, it is advisable to validate the proposed method's generalizability across a wider variety of tasks to confirm its effectiveness in more varied application scenarios.\n\n2. Line 81 contains an incomplete sentence, which should be revised for clarity and completeness.", "extra_scores": {}}, {"review_id": "qgXYIqHOa2", "reviewer": "Reviewer_9sDf", "summary": "The authors introduce HAWKEYE, a novel framework that improves the efficiency of Chain-of-Thought (CoT) reasoning in large language models (LLMs) by leveraging a collaborative paradigm between a large model (which generates concise reasoning instructions) and a small model (which expands these into full responses). The key insight is that most CoT tokens are redundant, and retaining only a fraction (about 20–40%) of the tokens can preserve answer quality while reducing computational cost. The framework uses reinforcement learning to fine-tune the large model to produce compact CoTs. Extensive evaluations show substantial reductions in latency (up to 3.4× speedup), token usage (50–70% fewer tokens), and serving cost, while maintaining or slightly improving response quality across multiple reasoning benchmarks.", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "1. The dual-model setup, where a large model generates compressed instructions and a small model completes the response, is novel and well-justified.\n\n2. The use of GRPO with length penalties to produce dense, high-utility CoTs is methodologically sound and addresses reward hacking risks.\n\n3. HAWKEYE is evaluated across four benchmarks (MATH500, MATH, GSM8K, AIME), demonstrating strong cost and latency improvements while maintaining accuracy.", "reasons_to_reject": "1. While the small model reduces token costs, running two models' forward passes (one for instruction, one for response) might offset efficiency gains. This overhead is not explicitly measured or discussed.\n\n2. The evaluation focuses heavily on math benchmarks. It would strengthen the paper to include more diverse reasoning tasks such as commonsense, multi-hop QA, or real-world decision-making scenarios.", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Meta-review: The paper introduces a novel model-collaboration scheme to first train the large models to generate concise instructions, then a small model completes the response in a more human-readable way. The proposed approach can achieve very high token efficiency while almost maintaining the accuracy over a wide set of reasoning benchmarks.

Pros:
- The overall proposed framework is novel, and the results are comprehensive over a wide set of benchmarks.
- The set up is reasonable and is an interesting way to utilize large and small models' advantages respectively.

Cons:
- Some reviewers point out issues with clarity of the paper (e.g., clarify thinking / response). The authors should take these points into consideration for the final version to make the paper easier to understand.
- Some reviewers point out a lack of comparisons to other token efficiency baselines like CoT-Valve and O1-Pruner. The authors added results in the rebuttal and are encouraged to include those results in the final version.

Overall I would recommend acceptance based on the novel insights and comprehensive results.
Decision: Accept