ConciseHint: Boosting Efficient Reasoning via Continuous Concise Hints during Generation

## Abstract

Abstract Recent advancements in large reasoning models (LRMs) like DeepSeek-R1 and OpenAI o1 series have achieved notable performance enhancements on complex reasoning tasks by scaling up the generation length by Chain-of-Thought (CoT). However, a critical issue is their tendency to produce excessively verbose reasoning processes, leading to the inefficiency problem. Existing literature on improving efficiency mainly adheres to the before-reasoning paradigms such as prompting and reasoning or fine-tuning and reasoning, but ignores the promising direction of directly encouraging the model to speak concisely by intervening during the generation of reasoning. In order to fill the blank, we propose a framework dubbed ConciseHint, which continuously encourages the reasoning model to speak concisely by injecting learnable hints (manually designed or learned on concise data) during the generation of the reasoning. Besides, ConciseHint is adaptive to the complexity of the query by adaptively adjusting the hint intensity, which ensures it will not undermine model performance. Experiments on the state-of-the-art LRMs, including DeepSeek-R1 and Qwen-3 series, demonstrate that our method can effectively produce concise reasoning while maintaining the performance well. Moreover, we show that ConciseHint is flexible and can be seamlessly integrated with existing methods to further push the upper bound of the efficiency.

## 1 Introduction

Reasoning ability is significant for large language models (LLMs) (Liu et al., 2024; Yang et al., 2024; Grattafiori et al., 2024; Hurst et al., 2024; Ouyang et al., 2022) to execute effectively across a wide range of complex tasks (Zhao et al., 2023; Chang et al., 2024; Qu et al., 2025; Hao et al., 2023; Wei et al., 2022), including arithmetic reasoning, commonsense reasoning, etc. Chain of thought (Wei et al., 2022; Kojima et al., 2022) (CoT) is the most popular manner to enhance the reasoning ability for LLMs by explicitly generating intermediate reasoning steps. Recently, state-of-the-art reasoning models (e.g., Gemini-2.5 (Deepmind, 2025), OpenAI-o1 (Jaech et al., 2024) and DeepSeek-R1 (Guo et al., 2025)) have internalized the chain-of-thought paradigm instead of few-shot (Wei et al., 2022) or zero-shot prompting (Kojima et al., 2022).

Although large reasoning models (LRMs) with CoT demonstrate remarkable performance, a critical limitation lies in the inefficiency of their reasoning process (Qu et al., 2025; Liu et al., 2025; Sui et al., 2025; Feng et al., 2025; Han et al., 2024). Typically, the output of reasoning models consists of far more tokens compared to common LLMs, due to the detailed and usually verbose intermediate reasoning steps, leading to substantial computational costs and high inference latency. For example, LRMs usually present unnecessary coherence tokens (Su et al., 2025) or perform redundant self-checks (Qu et al., 2025; Fu et al., 2025).

To improve the efficiency by making the reasoning model speak more concisely, mainstream methods follow the two paradigms: (i) Prompting in the input stage: Adding extra control prompts (Renze & Guven, 2024; Han et al., 2024; Lee et al., 2025; Aytes et al., 2025) like “Be concise.” to the model at the input stage, and then perform the reasoning. (2) Finetune-and-use: Internalizing the conciseness by optimizing the model with supervised fine-tuning (SFT) (Xia et al., 2025; Munkhbat et al., 2025; Ma et al., 2025) or reinforcement learning (RL) (Shen et al., 2025; Luo et al., 2025), and then perform the reasoning. They don’t directly intervene during the reasoning stage when the model generates tokens one by one. Therefore, an orthogonal and largely unexplored question arises: Is it possible to guide the reasoning model to speak more concisely by intervening during the generation of the intermediate reasoning steps? We point out two key points needed to answer this question: one is to design an approach to enable effective intervention during reasoning, and the other is to select an optimal intensity of intervention adaptively to the complexity of a given query.

To fill the blank, we propose ConciseHint, which performs intervention during the generation of reasoning, encouraging the model to speak concisely by injecting hints, as illustrated in [Figure 1](https://arxiv.org/html/2506.18810v3#S1.F1). Specifically, ConciseHint continuously influences the reasoning by injecting the hint that can either be a manually designed text (e.g., “make answer concise!”) or continuous embeddings learned on a concise dataset. Both types of hints can encourage the subsequent token generation to be more concise. Trained on concise data, the learned hint can capture concise patterns inherent in the data, thereby further enhancing the efficiency over the manual hint. Besides, the controllability of the reasoning length can be easily achieved by interpolating in the embedding space. Additionally, ConciseHint adaptively adjust the injection intensity according to the complexity of the query, as easy queries can usually tolerate a larger compression ratio of reasoning than complex ones. This complexity-adaptive strategy facilitates a good efficiency-accuracy balance by employing a lower hint intensity for complex queries and a higher intensity for easy ones. Moreover, ConciseHint dynamically adjusts the position of the injection to ensure a good computing-accuracy balance.

Figure: Figure 1: Previous works mainly enhance conciseness before the actual reasoning (i.e., adding the control prompt or optimizing the model via SFT/RL), while we focus on intervening during the reasoning process to encourage conciseness, i.e., in-reasoning intervention. ConciseHint achieves this goal by continuously injecting learnable hints during the generation.
Refer to caption: x1.png

To evaluate ConciseHint, we conduct experiments on the state-of-the-art large reasoning models (DeepSeek-R1 (Guo et al., 2025) and Qwen-3 (Alibaba, 2025) series) with a range of benchmarks (AIME24, GSM8K, and GPQA-Diamond) with varying complexity levels. Experimental results indicate that our in-reasoning intervention framework can effectively improve the reasoning efficiency while maintaining the model performance well. Moreover, they also demonstrate that ConciseHint can serve as a flexible plugin that can be seamlessly integrated with existing methods to further enhance the efficiency, effectively pushing the upper bound of the efficiency.

## 2 Related Works

### 2.1 Reasoning models and the inefficiency issue

The emergence of chain-of-thought (Wei et al., 2022; Kojima et al., 2022) endowed LLMs with powerful reasoning ability through explicitly generating intermediate reasoning steps. Initially, vanilla LLMs such as GPT-4o (Hurst et al., 2024) and PaLM (Chowdhery et al., 2023) can obtain the enhanced reasoning ability by few-shot (Wei et al., 2022) or zero-shot (Kojima et al., 2022) prompting.
Recently, large reasoning models such as Gemini-2.5 (Deepmind, 2025), OpenAI-o1 (Jaech et al., 2024) and DeepSeek-R1 (Guo et al., 2025) have internalized the reasoning ability by supervised fine-tuning (SFT) and reinforcement learning (RL), no longer needing manual prompting. While demonstrating superior performance compared to common LLMs, reasoning models incur high computational costs due to the detailed and usually verbose reasoning process (Qu et al., 2025; Zhao et al., 2023; Chang et al., 2024), leading to inefficiency in reasoning. For example, substantial works point out that reasoning models usually overthink simple queries (Qu et al., 2025; Chen et al., 2024; Shen et al., 2025), generate verbose multiple rounds of self-check (Qu et al., 2025; Fu et al., 2025), and allocate a substantial proportion of tokens to support textual coherence (Su et al., 2025) rather than the core reasoning advancement. These sorts of inefficiency issues result in the waste of computational resources and energy.

### 2.2 Efficient methods for reasoning models

Recently, researchers have paid attention to alleviating the inefficiency of large reasoning models.
Existing methods can be roughly divided into three groups (Qu et al., 2025), i.e., training-free methods, SFT-based methods, and RL-based methods. SFT-based methods either fine-tune the reasoning model to internalize the concise reasoning patterns on the curated concise datasets (Xia et al., 2025; Munkhbat et al., 2025), or replace explicit token generation in the reasoning process by predicting answers based on internal latent representations (Deng et al., 2024; Hao et al., 2024). RL-based methods usually incorporate the length constraint into the reward function to encourage conciseness (Shen et al., 2025; Luo et al., 2025), or teach the model “when to think” (Huang et al., 2025; Fang et al., 2025; Zhang et al., 2025). In contrast, training-free methods do not involve training, which is easy to use and can serve as a plug-in. For example, prompt-based methods (Renze & Guven, 2024; Han et al., 2024; Aytes et al., 2025) add control prompts to the user input to encourage answering concisely. Early exit methods (Fu et al., 2025; Yang et al., 2025) terminate the thinking in advance when meeting certain confidence conditions.

The previous literature mainly conforms to the paradigm of prompting or optimizing the model before using it to perform reasoning generation, and does not dynamically intervene in the model during the token generation for reasoning to make it speak more concisely. In this work, we aim to explore whether we can enhance the conciseness by continuously exerting influence during the reasoning.

## 3 The Proposed ConciseHint Framework

In this section, we elaborate on our proposed ConciseHint that encourages models to speak concisely by continuously and adaptively exerting influence on the reasoning process. ConciseHint injects learnable hints into the reasoning process to enhance efficiency. To avoid excessive intervention in complex queries while maintaining intensive intervention for easy queries, ConciseHint adaptively controls the injection intensity, ensuring it is negatively correlated with the complexity. To avoid compromising accuracy and achieve computational savings, ConciseHint dynamically determines the injection position, from head to tail progressively. Both manual and learned hints can encourage the subsequent reasoning to be more concise. Even though the manual hint (denoted as ConciseHint) can already achieve significant efficiency improvement in a training-free way, the learned hint trained on concise data (denoted as ConciseHint-T) can further enhance the efficiency by capturing concise patterns inherent in the data. Controllability of the reasoning length can be easily achieved by interpolating in the embedding space. The overall framework is presented in [Figure 2](https://arxiv.org/html/2506.18810v3#S3.F2).

Figure: Figure 2: The illustration of ConciseHint(-T) framework. Upon obtaining $\tau_{k}$, the LRM generates the next $\tau_{k}$ tokens, injects the hint, and updates $l_{k}$ and $\tau_{k}$ in sequence, repeating this cycle until the reasoning is finished. The corresponding pseudo-code is shown in [Algorithm 1](https://arxiv.org/html/2506.18810v3#alg1). There are two ways of obtaining the hint. Firstly, we can manually design the text with expertise and prior knowledge. Secondly, we can train the hint embeddings on concise reasoning data with SFT in a Next-token Prediction (NTP) way, which can further enhance the efficiency and acquire the controllability.
Refer to caption: x2.png

ConciseHint continuously injects the hint in a complexity-adaptive way. Specifically, ConciseHint continuously injects the hint like “make answer concise!” in the reasoning process. For instance, if the original text is “Okay, let me try to figure out this problem. The problem says a robe takes 2 bolts of blue fiber and half that much white fiber” will be modified to “Okay, make answer concise! let me try to figure out this problem. The problem says a robe takes 2 bolts of blue fiber and half that much white fiber”. Injecting the hint can encourage the following reasoning to be more concise. However, a critical problem is how to select an optimal injection intensity for a given query. An excessively high injection intensity will harm the accuracy, particularly for complex queries, while a low intensity will decrease the efficiency improvement (see [Table 3](https://arxiv.org/html/2506.18810v3#S4.T3) in the ablation study). We propose to tackle this problem from a complexity-adaptive perspective. We model the control of the injection intensity as the selection of the injection interval, i.e., the number of tokens between two adjacent injections. We propose a complexity-adaptive and dynamic interval control mechanism, formulated as follows:

$$ $\displaystyle\tau_{k}=\alpha+\beta\cdot l_{k},\ \ \alpha>0,\ \beta>0,$ (1) $$

where $\tau_{k}$ is the current injection interval. $l_{k}$ denotes the current length of the reasoning process, i.e., the number of current output tokens, which serves as a complexity indicator herein. $\alpha$ is the basic length of the injection interval, and $\beta$ is a positive coefficient to control the strength of adaptivity. Every time $\tau_{k}$ is obtained, the model will generate the next $\tau_{k}$ tokens, inject the hint, and update $l_{k}$ and $\tau_{k}$ in sequence. This cycle is repeated until the reasoning process is completed. The injection interval $\tau_{k}$ is a linear function of the current length, which indicates that the hint interval will increase with the current reasoning length. Here, we hold a prior that the reasoning length of a query is approximately positively correlated with its complexity (Muennighoff et al., 2025; Lee et al., 2025), and the intuitive assumption that easy queries can tolerate a larger compression ratio than complex ones. When the current length $l_{k}$ is small, the injection interval is set to a small value, resulting in a higher hint intensity. The reasoning of easy queries will complete in a short length, such as hundreds of tokens, so their average hint intensity is high, ensuring a high level of conciseness. If the length continues to increase, it will indicate that this query should be complex rather than easy, so [Equation 1](https://arxiv.org/html/2506.18810v3#S3.E1) accordingly relieves the hint intensity by increasing the injection interval $\tau_{k}$, avoiding excessive hinting that harms the accuracy. This adaptive strategy avoids manually setting the injection interval based on precise estimation of the complexity, as it is usually intractable.

The selection of the hyperparameters $\alpha$ and $\beta$. $\alpha$ should be set to a small value to ensure conciseness for easy queries, as they can tolerate high injection intensity. Empirical results show the performance is not sensitive to $\beta$, as long as it is not excessively small. Detailed ablation study and discussion about $\alpha$ and $\beta$ can be found in [Section A.1](https://arxiv.org/html/2506.18810v3#A1.SS1). In all our experiments, we fixed $\alpha$ to 128 (a small value) and $\beta$ to $0.2$ to avoid manual hyper-parameter tuning, and we find it always works well for various models and benchmarks.

The dynamic selection strategy for the hint injection position. Another problem is how to select the position to inject the hint. Let $T$ denote the original generated text whose length is $\tau_{k}$, $p$ denote the position of injection, and $T_{hint}$ denote the hint. Then, the modified text after hint injection will be:

$$ $\displaystyle T^{\prime}=T[0:p]+T_{hint}+T[p:\tau_{k}-1],\ \ p\in[0,\tau_{k}-1].$ (2) $$

We reveal two rules about the selection of injection position $p$: (i) $p$ should not be too close to $\tau_{k}-1$ to avoid accuracy degradation. Concretely, if $p$ is very close to $\tau_{k}-1$, the injected hint will approach the tail of the generated text. In this case, we observe that the subsequent generation will soon terminate the thinking or just lazily repeat the text generated after the last hint (see case studies in [Section A.3](https://arxiv.org/html/2506.18810v3#A1.SS3)), which significantly undermines accuracy, as shown in [Table 4](https://arxiv.org/html/2506.18810v3#S4.T4). (ii) $p$ should not be too close to 0. Although injecting the hint into the head solves the accuracy degradation problem, it introduces extra computing costs caused by prefilling the text between the injection position and the end, i.e., $T[p:\tau_{k}-1]$. Therefore, to ensure a good computing-efficiency balance, we propose a dynamic selection strategy for the position $p$, formulated as follows:

$$ $\displaystyle p=\tau_{k}*\min(\ (\tau_{k}-\alpha)/1024,\ 0.8\ ),$ (3) $$

where $\tau_{k}$ is the current injection interval and $\alpha$ is the basic injection interval length, the same as those in [Equation 1](https://arxiv.org/html/2506.18810v3#S3.E1).
During the early reasoning, $\tau_{k}$ is small, so the injection position is close to the head, not suffering from the aforementioned accuracy degradation. As the reasoning proceeds, $\tau_{k}$ becomes larger, the injection position moves towards the tail to save prefilling costs. Meanwhile, we restrict the maximum position to $\tau_{k}\cdot 0.8$ to prevent it from being too close to the tail, avoiding the accuracy degradation.
The detailed theoretical and empirical analysis for injection costs can be found at [Section A.2](https://arxiv.org/html/2506.18810v3#A1.SS2), which indicates that the extra costs of our strategy are negligible.

Figure: Algorithm 1 The proposed ConciseHint algorithm.

ConciseHint-T: training the embeddings of hint on concise reasoning data to learn concise patterns. Even though the training-free ConciseHint effectively improves the efficiency, further training the hint embeddings can bring additional token reduction. Concretely, firstly, we prepare a dataset consisting of questions and corresponding concise reasoning responses. Next, we construct modified reasoning responses by injecting hint embeddings to be trained into the original responses at a fixed interval. We initialize the hint embeddings as the embeddings of our manually designed hint ($\mathbf{E}_{ori}$) used in ConciseHint. Finally, we conduct supervised fine-tuning (like Prompt Tuning (Lester et al., 2021)) on the questions and corresponding modified responses, following the next-token prediction paradigm, and obtain the optimized hint embeddings $\mathbf{E}_{optim}$. We expect the hint embeddings to learn the inherent concise patterns in the concise reasoning responses. Then, ConciseHint-T uses the optimized hint embeddings and thus further reduces token usage. Moreover, we observe that we can control the token usage through the interpolation between the initial hint embeddings and the optimized embeddings. The interpolation embeddings can be derived from:

$$ $\displaystyle\mathbf{E}_{interp}=\gamma*\mathbf{E}_{optim}+(1-\gamma)*\mathbf{E}_{ori},\ \gamma\in[0,1]$ (4) $$

Controllability can be achieved by adjusting $\gamma$, where a higher value usually leads to less token usage. $\gamma=1$ denotes our ConciseHint-T, while $\gamma=0$ is ConciseHint.

## 4 Experiments

### 4.1 Experimental setup

Benchmarks. We validate our method on three commonly-used benchmarks for large reasoning models, i.e., GSM8K (Cobbe et al., 2021), AIME24 (Committees, 2024), and GPQA-Diamond (Rein et al., 2024).
GSM8K(Grade School Math 8K) consists of more than 8,000 high-quality quality linguistically diverse grade school math word problems. We use the test split containing 1,319 problems. AIME24 consists of 30 mathematical problems from the 2024 American Invitational Mathematics Examination (AIME24), a renowned high school math competition recognized for its difficult and thought-provoking problems. GPQA-diamond consists of 198 high-quality and challenging multiple-choice questions written by domain experts in biology, physics, and chemistry.

Models. We evaluate our method on the state-of-the-art open-source large reasoning models including Qwen3-8B, Qwen3-4B, Qwen3-1.7B (Alibaba, 2025), and DeepSeek-R1-14B (Guo et al., 2025), which deliver remarkable advancements in tackling a wide range of reasoning tasks.

Baselines. The basic baseline is the original reasoning without any efficiency technique. Besides, we include four representative efficient methods as baselines. Specifically, BeConcise (Renze & Guven, 2024) is a commonly-used prompting-based method that appends a prompt of “Be concise” to the input to encourage answering concisely. Besides, we obtain a stronger prompting method by adding “Please adaptively control the answer length based on the query’s complexity. The lower the complexity, the more concise your answer should be”. We denote it as “Prompt” for simplicity. Moreover, we include the early-exit method Deer (Yang et al., 2025), which terminates the reasoning when the model is confident enough. We also include NoWait (Wang et al., 2025), which prohibits transition tokens like “wait” and “alternatively” to obtain more efficient self-reflections.

Evaluation configurations. For all experiments, we set the temperature to 0.6 and top-p to 0.95, which is recommended in the official documentation. We report the accuracy to measure model performance. Following mainstream works, we report the average token usage, i.e., the average number of tokens to answer a query, to measure the efficiency. The injected hints are also counted. Each experiment is run multiple times, and we report the average results.

### 4.2 Main results.

**Table 1: ConciseHint results on GSM8K, AIME24, and GPQA-Diamond with Qwen3-4B, Qwen3-8B, and Deepseek-R1-14B. Ori. denotes the original reasoning process. Besides, we also include BeConcise (Renze & Guven, 2024), Prompt, Deer (Yang et al., 2025), and NoWait (Wang et al., 2025) as baselines. Ours (baseline) denotes the combination of our ConciseHint and the baseline method. We report the accuracy and average token usage. The lowest token usage is highlighted in bold. The red and blue numbers show the token reduction percentage over the original reasoning and the corresponding baseline method, respectively.**
| Model | Method | GSM8K | AIME24 | GPQA-Diamond |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  | Accuracy% | Token usage | Accuracy% | Token usage | Accuracy% | Token usage |  |
| \rowcolorlightgray\cellcolorwhite<br>Qwen3-4B | Ori. | 94.81 | 2381 | 64.33 | 11634 | 51.82 | 7388 |
| \rowcolorlightgreen\cellcolorwhite | Ours (Ori) | 94.74 | 1213<br>-49%<br>[-0.3ex] -49% | 66.67 | 10523<br>-10%<br>[-0.3ex] -10% | 52.73 | 4099<br>-45%<br>[-0.3ex] -45% |
| \rowcolorlightgray\cellcolorwhite | BeConcise | 94.60 | 1597 | 64.33 | 10929 | 53.74 | 6113 |
|  | \cellcolorlightgrayPrompt | \cellcolorlightgray94.56 | \cellcolorlightgray1263 | \cellcolorlightgray63.67 | \cellcolorlightgray10755 | \cellcolorlightgray52.93 | \cellcolorlightgray5180 |
|  | \cellcolorlightgreenOurs (Prompt) | \cellcolorlightgreen94.75 | \cellcolorlightgreen839<br>-65%<br>[-0.3ex] -34% | \cellcolorlightgreen67.00 | \cellcolorlightgreen9255<br>-20%<br>[-0.3ex] -14% | \cellcolorlightgreen51.72 | \cellcolorlightgreen3190<br>-57%<br>[-0.3ex] -38% |
| \rowcolorlightgray\cellcolorwhite | Deer | 94.78 | 1405 | 64.00 | 10149 | 53.23 | 6878 |
| \rowcolorlightgreen\cellcolorwhite | Ours (Deer) | 94.31 | 841<br>-65%<br>[-0.3ex] -40% | 65.33 | 8410<br>-28%<br>[-0.3ex] -17% | 52.31 | 3925<br>-47%<br>[-0.3ex] -43% |
| \rowcolorlightgray\cellcolorwhite | NoWait | 94.33 | 1289 | 59.00 | 10053 | 52.12 | 5246 |
| \rowcolorlightgreen\cellcolorwhite | Ours (NoWait) | 94.03 | 857<br>-64%<br>[-0.3ex] -34% | 58.33 | 8893<br>-24%<br>[-0.3ex] -12% | 51.31 | 2730<br>-63%<br>[-0.3ex] -48% |
| \rowcolorlightgray\cellcolorwhite<br>Qwen3-8B | Ori. | 95.86 | 2382 | 64.67 | 11725 | 57.58 | 8524 |
| \rowcolorlightgreen\cellcolorwhite | Ours (Ori) | 95.53 | 1489<br>-37%<br>[-0.3ex] -37% | 67.33 | 11228<br>-4%<br>[-0.3ex] -4% | 57.68 | 5400<br>-37%<br>[-0.3ex] -37% |
| \rowcolorlightgray\cellcolorwhite | BeConcise | 95.78 | 1822 | 66.67 | 11371 | 57.17 | 7466 |
| \rowcolorlightgray\cellcolorwhite | Prompt | 95.72 | 1353 | 68.00 | 10693 | 57.58 | 6285 |
|  | \cellcolorlightgreenOurs (Prompt) | \cellcolorlightgreen95.51 | \cellcolorlightgreen935<br>-61%<br>[-0.3ex] -31% | \cellcolorlightgreen69.67 | \cellcolorlightgreen9996<br>-15%<br>[-0.3ex] -7% | \cellcolorlightgreen55.56 | \cellcolorlightgreen3880<br>-54%<br>[-0.3ex] -38% |
| \rowcolorlightgray\cellcolorwhite | Deer | 95.62 | 1223 | 66.33 | 10298 | 55.45 | 7778 |
| \rowcolorlightgreen\cellcolorwhite | Ours (Deer) | 95.22 | 907<br>-62%<br>[-0.3ex] -26% | 64.67 | 8843<br>-25%<br>[-0.3ex] -14% | 55.35 | 5306<br>-38%<br>[-0.3ex] -32% |
| \rowcolorlightgray\cellcolorwhite | NoWait | 95.38 | 1406 | 64.83 | 9936 | 56.67 | 6575 |
| \rowcolorlightgreen\cellcolorwhite | Ours (NoWait) | 95.06 | 1030<br>-57%<br>[-0.3ex] -27% | 64.17 | 9457<br>-19%<br>[-0.3ex] -5% | 55.56 | 3860<br>-55%<br>[-0.3ex] -41% |
| \rowcolorlightgray\cellcolorwhite<br>DeepSeek-R1-14B | Ori. | 95.03 | 981 | 63.00 | 9210 | 56.06 | 5038 |
| \cellcolorlightgreenOurs (Ori) | \cellcolorlightgreen94.87 | \cellcolorlightgreen713<br>-27%<br>[-0.3ex] -27% | \cellcolorlightgreen61.00 | \cellcolorlightgreen7623<br>-17%<br>[-0.3ex] -17% | \cellcolorlightgreen54.65 | \cellcolorlightgreen3715<br>-26%<br>[-0.3ex] -26% |  |
| \cellcolorlightgrayBeConcise | \cellcolorlightgray94.92 | \cellcolorlightgray770 | \cellcolorlightgray63.00 | \cellcolorlightgray8521 | \cellcolorlightgray55.96 | \cellcolorlightgray4739 |  |
| \rowcolorlightgray\cellcolorwhite | Prompt | 94.18 | 627 | 64.67 | 7597 | 55.05 | 4120 |

ConciseHint results. [Table 1](https://arxiv.org/html/2506.18810v3#S4.T1) shows the main quantitative results of our experiments. Ori. denotes the original reasoning process without any efficiency technique. Ours (baseline) denotes the combination of our ConciseHint and the baseline method. For example, Ours (Ori) means applying ConciseHint in the original reasoning. From the experimental results in [Table 1](https://arxiv.org/html/2506.18810v3#S4.T1), we can derive the following two key conclusions:

(i) When individually applied, ConciseHint can effectively improve the reasoning efficiency, which is comparable to strong baselines.
Firstly, compared to the original reasoning (i.e., Ori.), employing ConciseHint (i.e., Ours (Ori)) can effectively reduce the token usage while maintaining the accuracy well. For example, on the GSM8K benchmark and Qwen3-4B, Ours (Ori) reduces 48.9% tokens from 2381 to 1213, with only an accuracy loss of 0.07. On the GPQA Diamond, it reduces 44.5% tokens from 7388 to 4099, even with an accuracy rise of 0.91. Secondly, the efficiency improvement of Ours (Ori) is comparable to these four efficiency baseline methods. For example, on the GSM8K benchmark and Qwen3-4B, the token usage of Ours (Ori) is less than BeConcise (1597), Prompt (1263), Deer (1405) and NoWait (1289). By continuously injecting concise hints, our method effectively reduces the token usage.

(ii) When integrated, ConciseHint consistently and obviously enhances the reasoning efficiency across all baseline methods, substantially raising the upper bound of efficiency. Let us focus on the comparison between Ours (baseline) and the corresponding baseline method. For each baseline method, applying ConciseHint obviously reduces the token usage while maintaining the accuracy well. For example, on the GSM8K benchmark and Qwen3-4B, compared to Deer, Ours (Deer) reduces 40.1% tokens from 1405 to 841. The overall reduction ratio against the original reasoning rises to 65%. Compared to NoWait, Ours (NoWait) reduces 33.5% tokens from 1289 to 857. The overall reduction ratio is 64%. The results validate the flexibility and compatibility of our approach, enabling seamless integration with various existing methods.

**Table 2: ConciseHint-T (incorporating training) results on GSM8K, AIME24, and GPQA-Diamond with Qwen3-1.7B. “Ours” and “Ours-T” denote our ConciseHint and ConciseHint-T, respectively. The embeddings are learned on MixChain-Z-GSM8K.**
| Method | GSM8K | AIME24 | GPQA-Diamond |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| Accuracy | Token usage | Accuracy | Token usage | Accuracy | Token usage |  |
| \rowcolorlightgray<br>Ori. | 90.87 | 2458 | 39.33 | 13570 | 39.39 | 9223 |
| \rowcolorlightblue<br>Ours | 90.04 | 1237 | 42.67 | 11859 | 37.37 | 5105 |
| \rowcolorlightgreen<br>Ours-T ($\gamma=0.7$) | 90.19 | 996 | 39.00 | 11029 | 37.37 | 4279 |
| \rowcolorlightgreen<br>Ours-T ($\gamma=1.0$) | 88.01 | 742 | 40.67 | 10223 | 35.05 | 3776 |

Incorporating hint training to further enhance the efficiency: ConciseHint-T results. We train the hint embeddings on the MixChain-Z-GSM8K (Ma et al., 2025) dataset, which consists of concise question-response pairs built on GSM8K training dataset. [Table 2](https://arxiv.org/html/2506.18810v3#S4.T2) shows the results of ConciseHint-T. At $\gamma=0.7$, ConciseHint-T achieves additional token reduction over ConciseHint while preserving the accuracy. Increasing $\gamma$ to 1 yields a more substantial reduction, even though at the cost of accuracy degradation on GPQA Diamond. These results indicate that the trained embeddings have effectively captured the concise patterns inherent in the concise reasoning data, thereby enhancing the efficiency over the manually designed hint. Moreover, the results demonstrate that the learned embeddings are not only effective on in-domain data (GSM8K) but also generalize well to out-of-domain data (AIME24 and GPQA Diamond).

[Figure 3](https://arxiv.org/html/2506.18810v3#S4.F3) shows the controllability results by adjusting $\gamma$ in [Equation 4](https://arxiv.org/html/2506.18810v3#S3.E4). On all datasets, a higher $\gamma$ value always leads to lower token usage. Additionally, it shows that shorter reasoning chains can sometimes achieve higher accuracy, indicating that a longer reasoning chain does not necessarily lead to better performance (Ma et al., 2025).

Figure: (a) GSM8K
Refer to caption: x3.png

**Table 3: The ablation study on the selection of the injection interval of ConciseHint.**
| Model | Dataset | Inject. interval | Accuracy% | Token usage |
| --- | --- | --- | --- | --- |
| Qwen3-8B | AIME24 | Ours (adaptive) | 69.67 | 9996 |
| Fixed 64 | 61.67 | 9941 |  |  |
| Fixed 128 | 66.67 | 9757 |  |  |
| GSM8K | Ours (adaptive) | 95.51 | 935 |  |
| Fixed 64 | 95.65 | 908 |  |  |
| Fixed 128 | 95.45 | 933 |  |  |
| Qwen3-4B | AIME24 | Ours (adaptive) | 67.00 | 9255 |
| Fixed 64 | 45.33 | 6598 |  |  |
| Fixed 128 | 63.33 | 9036 |  |  |
| GSM8K | Ours (adaptive) | 94.75 | 839 |  |
| Fixed 64 | 93.42 | 763 |  |  |
| Fixed 128 | 94.44 | 835 |  |  |

### 4.3 Ablation studies

Through ablation studies, we demonstrate the necessity of adaptively controlling the injection intensity based on the complexity ([Equation 1](https://arxiv.org/html/2506.18810v3#S3.E1)), and the necessity of dynamically determining the position of hint injection ([Equation 3](https://arxiv.org/html/2506.18810v3#S3.E3)). We also present corresponding cases to make it clearer.

The necessity of adaptively controlling the injection intensity. Recall that our method continuously scales up the injection interval to make it positively correlated with the current length. This strategy avoids excessive intervention in complex problems while ensuring a high intensity of intervention in easy problems. We use [Table 3](https://arxiv.org/html/2506.18810v3#S4.T3) to quantitatively demonstrate it, where “Fixed” denotes that the injection interval is set to the fixed value, and the injection intensity is inversely proportional to the interval. We conduct experiments on AIME24 and GSM8K, as their complexity levels differ a lot. From the results, we can conclude that a high intensity of hint injection impairs the performance of complex queries, but has little effect on simple queries. For example, using the fixed interval of 64 significantly decreases the accuracy of Qwen3-4B from 67.00 to 45.33 on AIME24, but on the GSM8K, the accuracy loss is minor. And it decreases the accuracy of Qwen3-8B from 69.67 to 61.67 on AIME24, but it would even slightly improve the accuracy from 95.51 to 95.65 on GSM8K. Therefore, to avoid performance degradation, it is necessary to relieve the injection intensity for complex queries. In the circumstances where we can know the approximate complexity of a given query in advance, we can just set a larger fixed interval for those complex queries. For example, we know the AIME24 is a challenging benchmark. However, it is intractable to precisely measure the complexity of a wild query, and we do not want to turn it into a hyper-parameter selection problem. Therefore, adaptively adjusting the interval using our [Equation 1](https://arxiv.org/html/2506.18810v3#S3.E1) is essential, as it can automatically adapt to different levels of complexity.

**Table 4: The ablation study on the selection of the injection position of ConciseHint. The prefilling ratio denotes the ratio of tokens to be prefilled after hint injection.**
| Model | Dataset | Inject. postion | Accuracy% | Token usage | Prefilling ratio% |
| --- | --- | --- | --- | --- | --- |
| Qwen3-8B | GPQA-Diamond | Our Dynamic | 55.56 | 3880 | 0.0 to 0.8 (dynamic) |
| At the tail | 42.93 | 1321 | 0.0 |  |  |
| In the middle | 55.05 | 4443 | 0.5 |  |  |
| At the head | 58.95 | 3798 | 1.0 |  |  |

The necessity of dynamically determining the position of hint injection. We discuss the influence of the selection of the injection position. Recall that as the reasoning proceeds, our method dynamically moves the injection position from the head towards the tail, to avoid accuracy degradation and save computing. We compare our method to three fixed position selection strategies, i.e., injecting at the tail, in the middle, and at the head. The experimental results in [Table 4](https://arxiv.org/html/2506.18810v3#S4.T4) indicate that the closer the fixed position is to the head, the better the accuracy it achieves. Specifically, injecting at the tail induces a significant accuracy degradation, from 55.25 to 43.03. Injecting in the middle achieves a comparable accuracy to ours, but causes the rise of token usage. Moreover, although injecting at the head slightly improves the accuracy, it increases the computing a lot due to the 100% token prefilling. Therefore, to avoid both accuracy degradation and computing increase, our dynamic position selection is essential. [Section A.2](https://arxiv.org/html/2506.18810v3#A1.SS2) elaborates on the analysis of prefilling costs, and shows the extra costs of our method are negligible.

### 4.4 The statistics of transition words when speaking concisely

The appearance of transition words (i.e., “Wait” and “Alternatively”) often marks the beginning of a new thought step for self-reflection. To investigate the impact on the self-reflection, we compare the average number of transition words and the average interval length between two words, presented in [Table 5](https://arxiv.org/html/2506.18810v3#S4.T5). It indicates that our method reduces a large proportion of redundant transition words (i.e., redundant thought steps), thereby promoting efficient self-reflections and making the overall reasoning more concise.

**Table 5: The statistics of transition words.**
|  |  | GSM8K | GPQA-Diamond |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Model | Method | # Token | # Transition words | Transition interval | # Token | # Transition words | Transition interval |
|  | Ori. | 2381 | 14.97 | 113.42 | 7388 | 59.92 | 102.05 |
| Qwen3-4B | Ours (Ori) | 1213 | 4.39 | 118.66 | 4099 | 32.08 | 95.55 |
|  | Ori. | 2382 | 14.05 | 115.77 | 8524 | 66.36 | 105.38 |
| Qwen3-8B | Ours (Ori) | 1489 | 5.50 | 126.91 | 5400 | 38.17 | 107.92 |

## 5 Conclusion

We propose an in-reasoning intervention framework dubbed ConciseHint to boost the efficient reasoning of large reasoning models. Different from mainstream methods that try to enhance the efficiency before the actual reasoning, we highlight a promising paradigm of performing intervention during the generation of the reasoning to make it more concise. ConciseHint injects learnable hints (manually designed or learned on the concise data) into the reasoning process to encourage conciseness. To avoid accuracy degradation for complex queries due to excessive hints, ConciseHint adaptively controls the injection intensity according to the complexity of the query. Besides, it dynamically adjusts the injection position to achieve a good computing-accuracy balance. We conduct experiments on GSM8K, AIME24, and GPQA-Diamond benchmarks with the state-of-the-art reasoning models DeepSeek-R1 and Qwen3 series. The results demonstrate that ConciseHint effectively improves the reasoning efficiency while maintaining the performance well, indicating that the in-reasoning intervention is a promising direction for boosting reasoning efficiency. Moreover, the results demonstrate that ConciseHint can serve as a flexible plugin that seamlessly integrates with existing methods to further enhance efficiency.

## References

- Alibaba (2025)
Alibaba.
[https://qwenlm.github.io/blog/qwen3/](https://qwenlm.github.io/blog/qwen3/), 2025.
- Aytes et al. (2025)
Simon A Aytes, Jinheon Baek, and Sung Ju Hwang.
Sketch-of-thought: Efficient llm reasoning with adaptive cognitive-inspired sketching.
*arXiv preprint arXiv:2503.05179*, 2025.
- Chang et al. (2024)
Yupeng Chang, Xu Wang, Jindong Wang, Yuan Wu, Linyi Yang, Kaijie Zhu, Hao Chen, Xiaoyuan Yi, Cunxiang Wang, Yidong Wang, et al.
A survey on evaluation of large language models.
*ACM transactions on intelligent systems and technology*, 15(3):1–45, 2024.
- Chen et al. (2024)
Xingyu Chen, Jiahao Xu, Tian Liang, Zhiwei He, Jianhui Pang, Dian Yu, Linfeng Song, Qiuzhi Liu, Mengfei Zhou, Zhuosheng Zhang, et al.
Do not think that much for 2+ 3=? on the overthinking of o1-like llms.
*arXiv preprint arXiv:2412.21187*, 2024.
- Chowdhery et al. (2023)
Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al.
Palm: Scaling language modeling with pathways.
*Journal of Machine Learning Research*, 24(240):1–113, 2023.
- Cobbe et al. (2021)
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.
*arXiv preprint arXiv:2110.14168*, 2021.
- Committees (2024)
MAA Committees.
[https://artofproblemsolving.com/wiki/index.php/AIME_Problems_and_Solutions.](https://artofproblemsolving.com/wiki/index.php/AIME_Problems_and_Solutions.), 2024.
- Deepmind (2025)
Google Deepmind.
[https://storage.googleapis.com/model-cards/documents/gemini-2.5-pro-preview.pdf](https://storage.googleapis.com/model-cards/documents/gemini-2.5-pro-preview.pdf), 2025.
- Deng et al. (2024)
Yuntian Deng, Yejin Choi, and Stuart Shieber.
From explicit cot to implicit cot: Learning to internalize cot step by step.
*arXiv preprint arXiv:2405.14838*, 2024.
- Fang et al. (2025)
Gongfan Fang, Xinyin Ma, and Xinchao Wang.
Thinkless: Llm learns when to think.
*arXiv preprint arXiv:2505.13379*, 2025.
- Feng et al. (2025)
Sicheng Feng, Gongfan Fang, Xinyin Ma, and Xinchao Wang.
Efficient reasoning models: A survey.
*arXiv preprint arXiv:2504.10903*, 2025.
- Fu et al. (2025)
Yichao Fu, Junda Chen, Yonghao Zhuang, Zheyu Fu, Ion Stoica, and Hao Zhang.
Reasoning without self-doubt: More efficient chain-of-thought through certainty probing.
In *ICLR 2025 Workshop on Foundation Models in the Wild*, 2025.
- Grattafiori et al. (2024)
Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al.
The llama 3 herd of models.
*arXiv preprint arXiv:2407.21783*, 2024.
- Guo et al. (2025)
Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, et al.
Deepseek-r1: Incentivizing reasoning capability in llms via reinforcement learning.
*arXiv preprint arXiv:2501.12948*, 2025.
- Han et al. (2024)
Tingxu Han, Zhenting Wang, Chunrong Fang, Shiyu Zhao, Shiqing Ma, and Zhenyu Chen.
Token-budget-aware llm reasoning.
*arXiv preprint arXiv:2412.18547*, 2024.
- Hao et al. (2023)
Shibo Hao, Yi Gu, Haodi Ma, Joshua Jiahua Hong, Zhen Wang, Daisy Zhe Wang, and Zhiting Hu.
Reasoning with language model is planning with world model.
In *The 2023 Conference on Empirical Methods in Natural Language Processing*, 2023.
- Hao et al. (2024)
Shibo Hao, Sainbayar Sukhbaatar, DiJia Su, Xian Li, Zhiting Hu, Jason Weston, and Yuandong Tian.
Training large language models to reason in a continuous latent space.
*arXiv preprint arXiv:2412.06769*, 2024.
- Huang et al. (2025)
Shijue Huang, Hongru Wang, Wanjun Zhong, Zhaochen Su, Jiazhan Feng, Bowen Cao, and Yi R Fung.
Adactrl: Towards adaptive and controllable reasoning via difficulty-aware budgeting.
*arXiv preprint arXiv:2505.18822*, 2025.
- Hurst et al. (2024)
Aaron Hurst, Adam Lerer, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, et al.
Gpt-4o system card.
*arXiv preprint arXiv:2410.21276*, 2024.
- Jaech et al. (2024)
Aaron Jaech, Adam Kalai, Adam Lerer, Adam Richardson, Ahmed El-Kishky, Aiden Low, Alec Helyar, Aleksander Madry, Alex Beutel, Alex Carney, et al.
Openai o1 system card.
*arXiv preprint arXiv:2412.16720*, 2024.
- Kojima et al. (2022)
Takeshi Kojima, Shixiang Shane Gu, Machel Reid, Yutaka Matsuo, and Yusuke Iwasawa.
Large language models are zero-shot reasoners.
*Advances in neural information processing systems*, 35:22199–22213, 2022.
- Kwon et al. (2023)
Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph E. Gonzalez, Hao Zhang, and Ion Stoica.
Efficient memory management for large language model serving with pagedattention.
In *Proceedings of the ACM SIGOPS 29th Symposium on Operating Systems Principles*, 2023.
- Lee et al. (2025)
Ayeong Lee, Ethan Che, and Tianyi Peng.
How well do llms compress their own chain-of-thought? a token complexity approach.
*arXiv preprint arXiv:2503.01141*, 2025.
- Lester et al. (2021)
Brian Lester, Rami Al-Rfou, and Noah Constant.
The power of scale for parameter-efficient prompt tuning.
In *Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing*, pp. 3045–3059, 2021.
- Liu et al. (2024)
Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al.
Deepseek-v3 technical report.
*arXiv preprint arXiv:2412.19437*, 2024.
- Liu et al. (2025)
Yue Liu, Jiaying Wu, Yufei He, Hongcheng Gao, Hongyu Chen, Baolong Bi, Jiaheng Zhang, Zhiqi Huang, and Bryan Hooi.
Efficient inference for large reasoning models: A survey.
*arXiv preprint arXiv:2503.23077*, 2025.
- Luo et al. (2025)
Haotian Luo, Li Shen, Haiying He, Yibo Wang, Shiwei Liu, Wei Li, Naiqiang Tan, Xiaochun Cao, and Dacheng Tao.
O1-pruner: Length-harmonizing fine-tuning for o1-like reasoning pruning.
*arXiv preprint arXiv:2501.12570*, 2025.
- Ma et al. (2025)
Xinyin Ma, Guangnian Wan, Runpeng Yu, Gongfan Fang, and Xinchao Wang.
Cot-valve: Length-compressible chain-of-thought tuning.
*arXiv preprint arXiv:2502.09601*, 2025.
- Muennighoff et al. (2025)
Niklas Muennighoff, Zitong Yang, Weijia Shi, Xiang Lisa Li, Li Fei-Fei, Hannaneh Hajishirzi, Luke Zettlemoyer, Percy Liang, Emmanuel Candès, and Tatsunori Hashimoto.
s1: Simple test-time scaling.
*arXiv preprint arXiv:2501.19393*, 2025.
- Munkhbat et al. (2025)
Tergel Munkhbat, Namgyu Ho, Seo Hyun Kim, Yongjin Yang, Yujin Kim, and Se-Young Yun.
Self-training elicits concise reasoning in large language models.
*arXiv preprint arXiv:2502.20122*, 2025.
- Ouyang et al. (2022)
Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al.
Training language models to follow instructions with human feedback.
*Advances in neural information processing systems*, 35:27730–27744, 2022.
- Qu et al. (2025)
Xiaoye Qu, Yafu Li, Zhaochen Su, Weigao Sun, Jianhao Yan, Dongrui Liu, Ganqu Cui, Daizong Liu, Shuxian Liang, Junxian He, et al.
A survey of efficient reasoning for large reasoning models: Language, multimodality, and beyond.
*arXiv preprint arXiv:2503.21614*, 2025.
- Rein et al. (2024)
David Rein, Betty Li Hou, Asa Cooper Stickland, Jackson Petty, Richard Yuanzhe Pang, Julien Dirani, Julian Michael, and Samuel R Bowman.
Gpqa: A graduate-level google-proof q&a benchmark.
In *First Conference on Language Modeling*, 2024.
- Renze & Guven (2024)
Matthew Renze and Erhan Guven.
The benefits of a concise chain of thought on problem-solving in large language models.
In *2024 2nd International Conference on Foundation and Large Language Models (FLLM)*, pp. 476–483. IEEE, 2024.
- Shen et al. (2025)
Yi Shen, Jian Zhang, Jieyun Huang, Shuming Shi, Wenjing Zhang, Jiangze Yan, Ning Wang, Kai Wang, and Shiguo Lian.
Dast: Difficulty-adaptive slow-thinking for large reasoning models.
*arXiv preprint arXiv:2503.04472*, 2025.
- Su et al. (2025)
DiJia Su, Hanlin Zhu, Yingchen Xu, Jiantao Jiao, Yuandong Tian, and Qinqing Zheng.
Token assorted: Mixing latent and text tokens for improved language model reasoning.
*arXiv preprint arXiv:2502.03275*, 2025.
- Sui et al. (2025)
Yang Sui, Yu-Neng Chuang, Guanchu Wang, Jiamu Zhang, Tianyi Zhang, Jiayi Yuan, Hongyi Liu, Andrew Wen, Hanjie Chen, Xia Hu, et al.
Stop overthinking: A survey on efficient reasoning for large language models.
*arXiv preprint arXiv:2503.16419*, 2025.
- Wang et al. (2025)
Chenlong Wang, Yuanning Feng, Dongping Chen, Zhaoyang Chu, Ranjay Krishna, and Tianyi Zhou.
Wait, we don’t need to” wait”! removing thinking tokens improves reasoning efficiency.
*arXiv preprint arXiv:2506.08343*, 2025.
- Wei et al. (2022)
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoc V Le, Denny Zhou, et al.
Chain-of-thought prompting elicits reasoning in large language models.
*Advances in neural information processing systems*, 35:24824–24837, 2022.
- Xia et al. (2025)
Heming Xia, Yongqi Li, Chak Tou Leong, Wenjie Wang, and Wenjie Li.
Tokenskip: Controllable chain-of-thought compression in llms.
*arXiv preprint arXiv:2502.12067*, 2025.
- Yang et al. (2024)
An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, et al.
Qwen2. 5 technical report.
*arXiv preprint arXiv:2412.15115*, 2024.
- Yang et al. (2025)
Chenxu Yang, Qingyi Si, Yongjie Duan, Zheliang Zhu, Chenyu Zhu, Qiaowei Li, Zheng Lin, Li Cao, and Weiping Wang.
Dynamic early exit in reasoning models.
*arXiv preprint arXiv:2504.15895*, 2025.
- Zhang et al. (2025)
Jiajie Zhang, Nianyi Lin, Lei Hou, Ling Feng, and Juanzi Li.
Adaptthink: Reasoning models can learn when to think.
*arXiv preprint arXiv:2505.13417*, 2025.
- Zhao et al. (2023)
Wayne Xin Zhao, Kun Zhou, Junyi Li, Tianyi Tang, Xiaolei Wang, Yupeng Hou, Yingqian Min, Beichen Zhang, Junjie Zhang, Zican Dong, et al.
A survey of large language models.
*arXiv preprint arXiv:2303.18223*, 2023.

## Appendix A Appendix

### A.1 Ablation Study and Analysis of Hyper-parameters

In the main experiments, we set $\alpha$ and $\beta$ to 128 and 0.2, respectively, and find that it works well across different benchmarks and models. Here, we demonstrate the principles behind this choice and systematically investigate the influence of different values of our hyper-parameters $\alpha$ and $\beta$. [Figure 4](https://arxiv.org/html/2506.18810v3#A1.F4) shows the ablation results of $\beta$, from which we can obtain the following observations:

- •
When $\beta$ is greater than 0.2, the improvement in accuracy brought by further increasing beta is not significant.
- •
When $\beta$ is less than 0.1 (especially equal to 0), it will cause an obvious accuracy degradation on difficult benchmarks (AIME24 and GPQA-Diamond).

It indicates the performance will not be sensitive to $\beta$, as long as it is not excessively small. Therefore, $\beta$ should be greater than a certain threshold, e.g., $\geq 0.2$ in our settings. So, we set $\beta$ to 0.2 in our main experiments.

Figure: (a) GSM8K
Refer to caption: x6.png

[Table 6](https://arxiv.org/html/2506.18810v3#A1.T6) shows the results of different $\alpha$, from which we observe:

- •
A larger $\alpha$ generally induces a greater number of output tokens and a better accuracy.
- •
The impact of $\alpha$ on accuracy is more significant on difficult benchmarks (GPQA-Diamond) than on simple benchmarks (GSM8K).

Therefore, to ensure conciseness on easy benchmarks, $\alpha$ should be set to a small value (e.g., 128 and 256). Besides, $\alpha$ should not be excessively small (e.g., 64 or less), aiming to obtain a good accuracy-efficiency balance for difficult benchmarks.

**Table 6: Ablation study of $\alpha$ on GSM8K and GPQA-Diamond with Qwen3-4B.**
| $\alpha$ | GSM8K | GPQA-Diamond |  |  |
| --- | --- | --- | --- | --- |
| Acc (%) | # Tokens | Acc (%) | #Tokens |  |
| 64 | 94.78 | 1062 | 51.92 | 3920 |
| 128 | 94.74 | 1213 | 52.73 | 4099 |
| 256 | 94.74 | 1370 | 53.54 | 4347 |
| 512 | 94.81 | 1571 | 53.43 | 4675 |
| 1024 | 94.92 | 1851 | 53.74 | 4986 |

Figure: Figure 5: Visualization of cost analysis for hint injection. Green and orange represent cached and non-cached tokens, respectively. The rectangles and triangles represent common and injected hint tokens, respectively.
Refer to caption: x9.png

Figure: Figure 6: Empirical evaluation of the relative latency on AIME24 with Qwen3-4B. The x-axis represents the injection index, and the y-axis represents the relative latency caused by this hint injection. Injection index=N means that we have previously injected N-1 hints in this reasoning, and the current one is the N-th hint.
Refer to caption: x10.png

Figure: (a) GSM8K
Refer to caption: x11.png

### A.2 Theoretical and Empirical Analysis for Injection Costs

The extra costs of injecting hint derive from the prefilling of tokens after the injection position. We use [Figure 5](https://arxiv.org/html/2506.18810v3#A1.F5) to visualize this process. According to our ConciseHint algorithm ([Algorithm 1](https://arxiv.org/html/2506.18810v3#alg1)), in each iteration, we first generate the text $T$ and meanwhile cache tokens in $T$ (marked in green). Then, we inject the hint into $T$, which makes the cached KV values after the injection position invalid (marked in orange). So, when generating the next token, these KV values need to be recomputed, like a prefilling stage. Let $t_{pre}$ denote the latency of the prefilling stage. Based on [Algorithm 1](https://arxiv.org/html/2506.18810v3#alg1), the number of tokens needing prefilling is $\tau_{k}-p$ (for simplicity, we ignore the length of the hint, as it is short). On the other hand, we also save time due to injecting tokens, as these tokens appear immediately without token-by-token decoding, and they also account for the total number of tokens. Let $t_{dec_hint}$ denote the saving time. Therefore, the equivalent absolute latency caused by each hint injection is: $t_{lat_abs}=t_{pre}-t_{dec_hint}$. As is well known, the prefilling is usually much faster than token-by-token decoding. So, the values of $t_{lat_abs}$ are usually low. Besides, a more meaningful metric is the relative latency, i.e., $t_{lat_rel}=\frac{t_{lat_abs}}{t_{dec_text}}$, where $t_{dec_text}$ is the latency of generating the text $T$ in the subsequent iteration. $t_{lat_rel}$ measures the proportion of extra latency w.r.t the original generation latency. The relative latency is low, which is also because the decoding is more costly.

Empirical evaluation of the relative latency $t_{lat_rel}$ is shown in [Figure 6](https://arxiv.org/html/2506.18810v3#A1.F6), which indicates the extra costs of our ConciseHint are negligible (less than 0.3%).

Empirical end-to-end latency evaluations are presented in [Figure 7](https://arxiv.org/html/2506.18810v3#A1.F7), which demonstrates that our method significantly reduces the actual reasoning latency. For example, on GSM8K, Ours (Ori) reduces the latency from 3.23s to 1.68s, and Ours (Prompt) further reduces it to only 1.00s.

### A.3 Case studies

We present case studies in  [Figure 8](https://arxiv.org/html/2506.18810v3#A1.F8) to demonstrate the ablation studies more clearly, showing how the injection intensity and position affect the reasoning. The upper panel shows a sample from AIME24 benchmark with Qwen3-4B when the injection interval is fixed to 64, leading to a high hint intensity (corresponds to row 9 in [Table 3](https://arxiv.org/html/2506.18810v3#S4.T3)). We can see that the model directly terminates the output after generating “Rotation by 135° (3/8 of a full rotation)” and gives no final answer under the intensive hint, resulting in a significant accuracy degradation. The lower panel shows a sample from GPQA-Diamond benchmark with Qwen3-8B when the hint is injected at the tail (corresponds to row 3 in [Table 4](https://arxiv.org/html/2506.18810v3#S4.T4)). On the first query, the model suddenly ends the thinking after “Let me recall: benzoquinone has two carbonyl groups”, and then gives its final answer, and this sort of insufficient thinking will reduce the accuracy. On the second query, the model repeats the text between two adjacent hints, i.e., “Step-by-step explanation: step1… step2… step3”. The underlying reason lies in the fact that generating tokens immediately following the hint predisposes the model to lazily recycle textual outputs previously generated following the last hint, which will harm the performance. Therefore, moving the injection position forward can alleviate this problem, which leaves enough tokens after the hint to make the subsequent generation stable.

Figure: Figure 8: Case studies for using intensive hints for complex queries and injecting the hint at the tail of the original text. Samples from AIME24 and GPQA-Diamond. The orange bar represents the injected hints.
Refer to caption: x13.png

### A.4 The Use of Large Language Models

In this paper, including the main body and appendix, large language models are used solely to polish writing, and only for a small portion of sentences.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 4
presentation: 3
questions: The paper does not discuss the generalizability of the designed hint. Would the same hint work effectively across other reasoning domains, or would they require task-specific tuning?
soundness: 2
strengths: -	The approach of inserting a short, instructive hint (e.g., “make answer concise”) into the model’s reasoning process is simple and straightforward.
-	The strategy for adjusting the hint injection intervals and positions is intuitive and well-motivated.
-	The paper is clearly written and logically structured.
summary: This paper focuses on the reasoning efficiency problem of large reasoning models (LRMs) with CoT that tend to generate verbose intermediate reasoning steps. To improve the efficiency, the paper proposes ConciseHint, a method that performs intervention during the generation of reasoning, making the reasoning process concise. ConciseHint continuously injects hints (either a designed text or continuous embeddings) to control the subsequent token generation. ConciseHint also adaptively adjust the injection intensity according to the complexity of the query, which balances efficiency-accuracy by applying a lower hint intensity for complex queries and a higher intensity for easy ones.
weaknesses: -	Limited evaluation. The experiments are run on only three datasets, and two of them (AIME24 and GPQA-Diamond) are quite small. It would be helpful to test the method on more datasets from different domains.
-	Performance drop. While ConciseHint successfully reduces the number of generated tokens, it also causes a clear drop in accuracy, especially for ConciseHint-T. 
-	Narrow analysis. The evaluation mainly looks at accuracy and token count. It would be valuable to also assess the quality of the reasoning steps. It’s unclear how the injected hints change the reasoning path, whether they improve clarity, oversimplify the reasoning, or disrupt its flow. A more detailed quality or behavioral analysis would make the work stronger.
-	Limited novelty. Although the method is simple and practical, its scientific novelty is modest. The hint scheduling and injection mechanisms are relatively intuitive and heuristic, and the paper does not analyze why or how the hints affect the model’s reasoning process. Exploring how sensitive the model is to different hint designs or injection positions would add important insights.

---

confidence: 3
contribution: 2
initial_rating: 4
presentation: 2
questions: - Could fine-tuning the model (even with a lightweight method like LoRA) on the same concise dataset also work?
- What is the end-to-end latency impact of the periodic KV-cache invalidation?
- Are there any other proxies for complexity besides current length?
soundness: 3
strengths: - The "in-reasoning intervention" paradigm is new and interesting; it is intelligently designed to avoid hurting performance.
- The method is flexible and can be integrated with other existing efficiency methods, and it can also be controlled either in a training-free or a trained manner.
- Experimental results show that the method works effectively across multiple state-of-the-art models (Qwen3 series, DeepSeek-R1) and challenging benchmarks.
summary: The authors propose ConciseHint to tackle the inefficiency of reasoning models. This is a framework that injects "concise hints" (like "make answer concise!") during the reasoning process, rather than only prompting before it. The method’s key features include: (1) Complexity-Adaptive Intensity, which automatically adjusts how often it injects hints. (2) Dynamic Injection Position, which dynamically adjusts where it injects the hint in the text. A trained version, ConciseHint-T, learns hint embeddings from data to further improve efficiency. Experiments show ConciseHint significantly reduces token usage (e.g., ~49% on GSM8K) while maintaining accuracy.
weaknesses: - The core assumption relies on the idea that the current reasoning length is a good proxy for query complexity. This largely depends on specific models, as a model can be verbose on an easy problem or concise on a hard one.
- The evaluation methodology is weak:
  - The paper is missing comparisons to other efficient reasoning methods like AlphaOne, AdaptThink, O1-pruner and Autol2s.
  - Missing multiple runs and pass@1: For small, complex benchmarks like AIME24 (only 30 problems), reporting "accuracy" from a single run or small average is not statistically sound, especially when using sampling (temp 0.6).
- The trained version, ConciseHint-T, is trained only on the GSM8K (math) dataset. The paper's claim that it "generalizes well" to completely different domains like GPQA has limited evidence.The hyperparameters are sensitive and need careful choice. 
- The paper claims $\alpha$ and $\beta$ work well when fixed, but the appendix shows that poor choices can "significantly undermine accuracy."

[1] AlphaOne: Reasoning Models Thinking Slow and Fast at Test Time

[2] Adaptthink: Reasoning models can learn when to think

[3] O1-pruner: Length-harmonizing fine-tuning for o1-like reasoning pruning

[4] Autol2s: Auto long-short reasoning for efficient large language models

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 2
questions: see Weaknesses
soundness: 3
strengths: Novel In-Reasoning Intervention Paradigm: Breaks the limitation of "pre-reasoning intervention" in existing works, directly guiding conciseness during token generation—opening a new direction for efficient LRMs.

Adaptive and Dynamic Mechanisms: Designs complexity-aware hint intensity (adapting to query difficulty via reasoning length) and dynamic injection positions, ensuring accuracy while maximizing efficiency.

Flexible and Controllable Hint Design: Supports both training-free manual hints and data-learned hints (ConciseHint-T), with interpolation-based controllability to balance token reduction and performance.

Strong Compatibility: Serves as a plug-and-play plugin that integrates seamlessly with existing efficient methods, pushing the upper bound of reasoning efficiency without modifying the base model.
summary: To address the inefficiency of Large Reasoning Models (LRMs) caused by verbose Chain-of-Thought (CoT) generation (e.g., redundant tokens and self-checks), this paper proposes ConciseHint, an in-reasoning intervention framework. Unlike existing methods that only intervene before reasoning (e.g., input prompting, SFT/RL), ConciseHint continuously injects learnable hints (manually designed text or data-learned embeddings) during the reasoning generation process. It adaptively adjusts hint intensity based on reasoning length to avoid over-intervention on complex queries, and dynamically shifts injection positions (from head to tail, capped at \(\tau_{k} \cdot 0.8\)) to balance accuracy and computational cost. An enhanced variant, ConciseHint-T, further optimizes hints via supervised fine-tuning on concise data, enabling controllable reasoning length through embedding interpolation. Experiments on GSM8K, AIME24, and GPQA-Diamond with models like Qwen3 series and DeepSeek-R1 show that ConciseHint reduces tokens by 27%-65% while maintaining accuracy, and seamlessly integrates with existing methods (e.g., BeConcise, Deer) to further boost efficiency.
weaknesses: The largest model tested is 14B (DeepSeek-R1-14B)—no validation on ultra-large LRMs (70B+, e.g., Qwen3-72B, GPT-4o) where CoT verbosity and computational costs are more severe. Larger models often have more stable reasoning chains; it is unclear if ConciseHint’s intervention is redundant or still effective here.

Lack of Redundancy Targeting and Parameter SensitivityWeakness Details:Unquantified Redundancy Suppression: The paper claims ConciseHint reduces "redundant tokens and self-checks" but provides no breakdown of which specific redundancies are eliminated (e.g., transition words like "wait", repetitive premise restatements, logically superfluous steps). Without this analysis, readers cannot confirm if the framework targets meaningful redundancy (vs. accidental suppression of critical logic).Unvalidated Adaptive Parameters: The default values for \(\alpha=128\) (base interval) and \(\beta=0.2\) (adaptive coefficient) are provided without parameter sensitivity analysis. It is unknown how these values perform across tasks (e.g., AIME24’s long reasoning vs. GSM8K’s short steps) or if optimal parameters exist for different scenarios—hindering practical adoption.Hint Content Impact Ignored: The paper tests only one manual hint ("make answer concise!") and a single training dataset (MixChain-Z-GSM8K) for ConciseHint-T. 

Lack of Error Analysis and Edge Case RobustnessWeakness Details:Unanalyzed Accuracy Drops: The paper notes minor accuracy drops (e.g., Qwen3-1.7B on GSM8K: 90.87% → 88.01% for \(\gamma=1.0\)) but provides no analysis of why these drops occur.

---

confidence: 4
contribution: 3
initial_rating: 4
presentation: 2
questions: Please refer to the weaknesses.
soundness: 2
strengths: - The proposed training-free ConciseHint framework introduces an interesting perspective by applying in-reasoning intervention rather than pre-reasoning prompting or fine-tuning.
- The paper addresses an important and timely question about improving reasoning efficiency in large reasoning models.
- The experimental results are promising, showing substantial token reduction while maintaining accuracy across the Qwen family of models.
- The idea of adaptive hint injection and its potential for plug-and-play integration with existing efficiency techniques is conceptually appealing.
summary: This paper proposes ConciseHint, a framework that improves reasoning efficiency in large reasoning models by injecting concise hints during generation rather than before reasoning or through fine-tuning. The method continuously introduces either manually designed or learned hints to encourage concise thinking while maintaining accuracy. It adaptively controls the hint intensity and injection position based on query complexity through parameters α and β. The extended version, ConciseHint-T, learns hint embeddings from concise reasoning data and introduces a controllable interpolation parameter γ. Experiments on GSM8K, AIME24, and GPQA-Diamond using Qwen and DeepSeek-R1 show token reduction with minimal accuracy loss.
weaknesses: 1. Hyperparameter Selection and Clarity
- The strategy for determining hint injection intensity (parameters α and β) appears ad hoc.
- Although the paper claims that hints are “learnable,” the positions and frequencies of injection are determined through manually tuned hyperparameters rather than learned mechanisms.
- The description of α and β is confusing and inconsistent. For example, the paper suggests α should be “small,” yet sets α = 128 without clarifying what range is considered small or providing sufficient justification through sensitivity analysis

2. Overreliance on Hyperparameters
- The effectiveness of ConciseHint heavily depends on α, β, and γ, which undermines its claim of adaptivity.
- The framework’s practicality is limited without a clear or automated method for selecting these hyperparameters. This raises concerns about reproducibility and robustness across unseen models. Obviously, the current hyperparameter settings are good for Qwen family models, but not as significantly effective in DeepSeek models.

3. Incomplete Experimental Coverage
- The comparison with baselines is uneven across models. For instance, Qwen3-4B includes BeConcise and other baselines, but DeepSeek-R1-14B results omit some of these. 
- It is unclear why BeConcise or similar prompting-based baselines cannot be combined with ConciseHint for stronger comparisons. These inconsistencies suggest the experiments are not yet fully comprehensive or standardized.

4. Overclaim on Reasoning
- The evaluation focuses primarily on math and physics QA datasets (GSM8K, AIME24, GPQA-Diamond). Such domains do not represent general reasoning; broader evaluations on coding, commonsense, or multimodal reasoning datasets are needed.
- As a result, the paper’s claim of improving “reasoning efficiency” in general is somewhat overstated.

5. Trade-off Between Accuracy and Efficiency
- In Table 2, performance noticeably degrades when γ increases (e.g., γ = 1), indicating potential instability or limited generalization.
- The results reveal a clear trade-off between conciseness and accuracy, which should be analyzed more thoroughly rather than only reported. A discussion of this trade-off would help readers better understand practical deployment choices.

6. Writing and Presentation Issues
- The paper is difficult to read, with dense notation and numerous hyperparameters that could be summarized more clearly.
- Several equations (e.g., Eq. (1)–(3)) could benefit from intuitive explanations or visual aids describing the adaptive behavior.


Decision: Reject