WorksComputer Science
TAC-CoT: Tool-Empowered Implicit Chain-of-Thought via Interleaving Explicit Tokens
Abstract
LLM-based agentic systems are increasingly combined with CoT reasoning to solve tasks that require accurate reasoning, external knowledge, and multi-step deliberation. Yet, explicit CoT incurs substantial generation overhead, while implicit CoT, which replaces textual rationales with compact continuous tokens, does not naturally support the explicit communication interface required for agentic tool-use. We propose TAC-CoT, a tool-empowered adaptive implicit CoT framework that replaces explicit reasoning traces with compact latent reasoning segments while retaining textual tokens only for tool calls, observations, and final answers. This interleaved design enables agentic tool-use without verbalizing every intermediate reasoning step. Experiments on agentic math and QA benchmarks show that TAC-CoT improves accuracy by up to 8.8 points while reducing model forward passes by up to 6.8x. Furthermore, analyses show that TAC-CoT improves tool-use quality in both single- and multi-tool settings.
Introduction
To enhance the problem-solving ability of large language models (LLMs), a wide range of reasoning-oriented methods have been explored. In particular, for tasks that require accurate and reliable reasoning, such as mathematical reasoning and knowledge-intensive question answering, research has evolved toward Chain-of-Thought (CoT) reasoning, which improves models’ internal reasoning capabilities through intermediate reasoning steps [5] (Wei et al. 2022), as well as agentic tool-use frameworks, which enhance rigor and factuality by enabling models to interact with external tools during problem solving (Zhang et al., 2026; Kim et al., 2026).
Most prior work adopts the explicit CoT paradigm, where intermediate reasoning is represented as human-readable natural-language tokens. This paradigm is attractive because it is directly compatible with autoregressive generation and provides an interpretable interface between reasoning and action (Kojima et al., 2022; Yao et al., 2023). However, verbalizing the entire reasoning process substantially increases inference cost as reasoning traces grow longer and makes the model more susceptible to error accumulation across intermediate steps [10] (Wu et al. 2026).
Implicit CoT has emerged as an alternative paradigm that replaces readable natural-language rationales with compact continuous thought tokens. By performing reasoning in non-verbal latent spaces, implicit CoT aims to retain the benefits of multi-step reasoning while mitigating the inference cost and vulnerability to error accumulation of lengthy textual traces (Shen et al., 2025).
Despite these benefits, implicit CoT methods are ill-suited for LLM-based agent systems. They rely on a fixed number of implicit tokens to carry the entire reasoning process of every query, which gives rise to two limitations. First, since the implicit-token budget is consumed in a single uninterrupted block before the final answer [6] (Wei et al. 2026), there is no intermediate point at which the model can emit an explicit tool call or ingest an observation, so tool use is structurally infeasible. Second, the same token count is applied to every input regardless of its difficulty or the number of intermediate decision points it requires [1] (Wu et al. 2026). As a result, prior implicit CoT methods cannot interact with external environments and under-allocate reasoning capacity to more difficult queries.
In this paper, we propose TAC-CoT (Tool-empowered Adaptive Continuous CoT), which interleaves compact implicit reasoning segments with explicit tokens for tool calls, observations, and final answers. Rather than carrying the entire reasoning process in a single block of implicit tokens, TAC-CoT reasons within a short implicit segment and then either invokes a tool or produces the answer, resuming with another segment after each tool observation. This interleaving simultaneously addresses both limitations of prior implicit CoT, as explicit tokens between segments make tool use executable, while the number of segments, determined on the fly, makes the reasoning budget query-adaptive. To train this behavior, we automatically construct tool-use trajectories from reasoning datasets and supervise the model to perform compact latent reasoning between tool invocations.
Our contributions are summarized as follows.
We extend implicit CoT to tool-empowered agentic systems, enabling compact continuous reasoning in iterative reasoning–action workflows.
We show that TAC-CoT improves reasoning performance while substantially reducing the number of reasoning tokens compared with explicit CoT-style reasoning by interleaving continuous thought tokens with explicit tokens.
We introduce an adaptive token-allocation mechanism that flexibly adjusts the length of implicit reasoning according to query difficulty.
As highlighted in Figure 1, TAC-CoT improves downstream task performance while using the forward reasoning budget more efficiently. Our analysis shows that TAC-CoT benefits from query-adaptive implicit reasoning budgets, improves tool-using scenarios, and mitigates error accumulation through implicit reasoning.
Figure 1. TAC-CoT improves over the Explicit-CoT baseline in both agentic math and question-answering (QA) settings. The two methods use the same tool-using agents and differ only in their reasoning backbone: TAC-CoT uses implicit CoT, whereas the baseline uses explicit CoT. # Fwd denotes the number of model forward passes (Kuzina et al., 2026; Wei et al., 2026).
TAC-CoT: Tool-Empowered Implicit CoT via Interleaving Explicit Tokens
We explain TAC-CoT, a tool-empowered implicit CoT framework that interleaves latent reasoning segments with explicit, executable tool interactions. We first describe TAC-CoT’s inference procedure (§ 2.1), then how we construct training trajectories (§ 2.3), and finally the learning objective (§ 2.4). Algorithm 1 shows its inference procedure.
Tool-Interleaved Implicit CoT with Query-Adaptive Budgets
The key idea of TAC-CoT is to jointly leverage implicit reasoning tokens and textual tokens for tool-use trajectories. In this process, the length of the reasoning tokens is adaptively adjusted according to the query. As shown in Figure 2, this produces an interleaved trajectory that preserves the executable interface of tool-using agents without verbalizing every intermediate step.
Figure 2. Overview of TAC-CoT compared with the Explicit-CoT agent and implicit-CoT methods. TAC-CoT uses implicit CoT as its reasoning backbone while preserving interaction segments in explicit natural language. This design enables implicit CoT to use tools and allocate query-dependent implicit reasoning budgets, improving efficiency, performance, and robustness over the Explicit-CoT agent. Here, denotes the number of discrete tokens generated by the Explicit-CoT agent at each step, denotes the number of continuous tokens in each implicit reasoning segment of TAC-CoT, and denotes the fixed continuous-token budget used by prior implicit-CoT methods.
Given a query , we consider an explicit tool-using CoT trajectory as:
where is the -th explicit reasoning segment of discrete tokens; and are the corresponding tool call and observation, and is the final answer. The last segment produces no tool call, as the model uses it to consolidate prior observations before generating . TAC-CoT constructs the corresponding interleaving trajectory by replacing each explicit reasoning segment with an implicit segment of () continuous thought tokens, while keeping , , and in their original explicit textual form:
Each continuous thought token is obtained by applying a projection layer to the last-layer hidden state at the current position and is fed back to the model via input embeddings, bypassing the vocabulary projection; following CODI (Shen et al., 2025), this projection layer separates the latent thought space from the token embedding space.
Deciding When to Call a Tool. A key design decision of TAC-CoT is when to interrupt latent reasoning for an external interaction. At the end of every implicit segment , TAC-CoT compares the logits of the tool call and answer options to decide the next step. If the tool-call logit is higher, TAC-CoT emits a tool call, appends the returned observation to the context, and starts another implicit segment. Otherwise, the current segment becomes the consolidating segment from which the final answer is generated. Unlike prior implicit CoT methods that consume a fixed implicit budget before any explicit output, this per-segment routing is what makes tool use feasible under implicit reasoning.
Algorithm 1: TAC-CoT inference
Input: Query q, model fθ, tool executor E,
implicit segment length b
Output: Final answer a
1 τ ← [ ] // prefix of τI
2 repeat
// Implicit reasoning segment
3 for t ← 1 to b do
4 ht ← LastHiddenθ(q ◦ τ)
// Continuous thought token
5 ct ← Projθ(ht)
6 τ ← τ ◦ [ct]
// Route selection
7 (ℓact, ℓans) ← RouteLogitsθ(q ◦ τ)
8 if ℓact < ℓans then
9 u ← DecodeToolθ(q ◦ τ)
10 o ← E(u)
11 τ ← τ ◦ [u, o]
12 until ℓans > ℓact
13 a ← DecodeAnsθ(q ◦ τ)
14 return a
Query-Adaptive Continuous-Thought Token Budget.
Since the tool call decision is made after every implicit segment, the total reasoning budget becomes query-adaptive. Simple queries may terminate after a single segment, while more complex queries can continue through multiple tool interactions. Thus, is fixed only locally within each segment. In contrast, if TAC-CoT terminates after implicit segments , it uses continuous tokens in total, where is determined dynamically during inference.
Dataset Construction for Agentic CoT
Realizing our interleaved inference mechanism in Eq. (2) requires training data that exposes the explicit counterpart of the interleaved trajectory . That is, each example must provide the full sequence of explicit reasoning segments , tool calls , observations , and the final answer , from which TAC-CoT learns to replace each with an implicit segment while preserving the surrounding explicit interactions.
We construct such data with two strategies depending on whether the source dataset already includes executable tool interactions, or only reasoning traces and gold answers.
Sources with Tool Interactions. We convert the
provided executable annotations into tool calls. If the executable annotations are provided separately from the reasoning traces, we match their tool-call parameters and returned observations to the corresponding reasoning spans. We then normalize the matched interactions into a unified tool-call format with explicit tool names and parameters, and insert the tool calls and observations into the reasoning trajectory.
Sources without Tool Interactions. As intermediate interactions are not directly available, we instead employ a stronger LLM (DeepSeek-V3; See Appendix A) as a tool-augmented solver to synthesize them. Given a question and the available tools, the model generates a complete trajectory with interleaved reasoning spans, tool calls, observations, and a predicted answer. We retain only trajectories whose predicted answers match the source gold answers, and normalize the retained trajectories into the same format.
Training Objective
Given the explicit trajectory from § 2.3, training must teach the model to (i) encode the reasoning of each into an implicit segment , and (ii) preserve the surrounding tool calls , observations , and final answer in explicit form. We achieve both through self-distillation (Shen et al., 2025), where the same backbone model serves as both the student and the teacher, with providing the teacher signal, as in Figure 3.
Figure 3. Training objective of TAC-CoT. The student generates continuous thought tokens, from which explicit reasoning chunks are reconstructed for supervision. Explicit outputs are trained with cross-entropy loss, while answer-boundary hidden states are distilled from an explicit-CoT teacher. The final objective combines student, teacher, and distillation losses.
Student Training. Following the reconstruction idea of Wei et al. (2026), we attach an auxiliary
| Task | Benchmark | Setting |
| Math | GSM8K (Cobbe et al., [3]) | In-domain |
| GSM-Hard (Gao et al., [7]) | Out-of-domain | |
| SVAMP (Patel et al., 2021) | Out-of-domain | |
| QA | HotpotQA (Yang et al., 2018) | In-domain |
| 2WikiMultihopQA (Ho et al., 2020) | Out-of-domain | |
| KILT-TriviaQA (Petroni et al., 2021) | Out-of-domain | |
| Tool-use | ToolBench (Qin et al., 2024) | Tool-use evaluation |
reconstruction decoder , which is discarded at inference. Because TAC-CoT hides only reasoning spans, the auxiliary decoder reconstructs the omitted reasoning content rather than the whole trajectory. Each is split into chunks , and each continuous thought token is aligned with :
where is the autoregressive reconstruction likelihood assigned by to . This loss forces each implicit segment to encode the reasoning content that would otherwise be verbalized at the corresponding point in the tool-use trajectory.
For the model-generated explicit segments, including tool calls and final answers, we apply the standard cross-entropy loss . Observations are kept as explicit context returned by the environment. The student loss is
Teacher Training and Distillation. We train the teacher with the standard cross-entropy loss on the explicit trajectory. We then distill the teacher’s hidden activations at the answer boundary so that the student after implicit reasoning matches the teacher after explicit reasoning:
and are the teacher and student hidden activations at the colon token before answer generation, is the number of layers, and denotes the stop-gradient operation. The final objective is therefore .
Experiments
We design experiments to evaluate two capabilities of our proposed method: (1) agentic math problem-solving training and evaluation to assess its reasoning capability, and (2) agentic QA training and evaluation to assess its agentic capability.
Experimental Setup
Training Datasets. TAC-CoT requires training to use implicit tokens. To evaluate mathematical reasoning, we use GSM8K-Aug-NL (Deng et al., [6]), which contains explicit interactions as textual explanations. Since GSM8K-Aug-NL contains explicit reasoning trajectories without executable interfaces, we insert executable calculator annotations from GSM8K-Aug (Deng et al., [6]). To evaluate QA capability, we use the HotpotQA (Yang et al., 2018) dataset. We construct 40,000 trajectories by using DeepSeek-V3 (DeepSeek-AI et al., [4]) with the available tool and allowing it to solve each question through iterative tool interaction. We retain only trajectories whose final answer matches the gold annotation. Although teacher-generated trajectories may inherit teacher-specific biases, TAC-CoT and all
QA baselines are trained on the same trajectories; such biases are therefore shared across methods and cannot by themselves explain TAC-CoT’s relative improvements. Dataset construction details are provided in Appendix § 6.
Evaluation Benchmarks. We evaluate TAC-CoT on agentic math problem solving (Math), agentic Question-Answering (QA), and tool-use benchmarks, as summarized in Table 1. On tool-Bench, we use ‘Single’ for the I1 single-tool scenario, and ‘Multi’ as the I2 + I3 multi-tool scenario. We report accuracy (Acc) for math tasks and exact match (EM) for QA. To compare the inference cost independently of hardware and external API latency, we report the average number of forward passes (# Fwd) (Kuzina et al., 2026; Wei et al., 2026). For no-tool QA setting (TU = ❌), # Fwd also includes autoregressive generation of missing tool observations; see Appendix § 7.§ 2.
Implementation Details. We use Qwen2.5-0.5B-Instruct (Yang et al., 2024), Llama-3.2-1B-Instruct (Grattafiori et al., [8]), and Qwen3-4B (Yang et al., 2025) as backbone models. For agentic QA, we use the Wikipedia API as the search engine, following Yao et al. (2022). Further details are provided in Appendix § 7. We provide pseudocode for reproducibility in Figure 10. For TAC-CoT, we set . Ablation results for different values are provided in Appendix § 8.§ 1.

Figure 10. Minimal TAC-CoT inference loop. is produced by and fed back via inputs_embeds, bypassing vocabulary projection.
Baselines. We compare TAC-CoT against (1) an Explicit-CoT agent, which serves as a strong baseline for tool use and reasoning by using full explicit reasoning traces, fine-tuned on the same training trajectories as our method; (2) TokenSkip (Xia et al. (2025)), an explicit CoT method that compresses intermediate reasoning trajectories by pruning low-importance tokens; (3) PC-CoT (Wu et al. (2025)), which updates implicit thought tokens in parallel using Jacobi iteration, improving efficiency over sequential implicit CoT; (4) CODI (Shen et al. (2025)), an implicit-CoT method trained via trajectory-level self-distillation from CoT-based teacher signals; and (5) SIM-CoT (Wei et al. (2026)), which extends CODI by adding step-level supervision to reconstruct reasoning steps from latent embeddings.
Main Results
Our evaluation examines whether TAC-CoT achieves its design goals in addressing the limitations of extending existing CoT approaches to agentic systems, focusing on four aspects: tool-use effectiveness, internal reasoning ability, query-adaptive continuous-thought budgeting, and inference efficiency. Table 2 presents the main results on agentic math and QA benchmarks across tool-calling and no-tool settings.
| Method | TU | GSM8K Acc↑ | GSM8K # Fwd↓ | GSM-Hard Acc↑ | GSM-Hard # Fwd↓ | SVAMP Acc↑ | SVAMP # Fwd↓ | Average Acc↑ | Average # Fwd↓ | HotpotQA EM↑ | HotpotQA # Fwd↓ | 2WikiMulti EM↑ | 2WikiMulti # Fwd↓ | TriviaQA EM↑ | TriviaQA # Fwd↓ | Average EM↑ | Average # Fwd↓ |
| Qwen2.5-0.5B-Instruct | |||||||||||||||||
| Explicit-CoT | ✗ | 50.9 | 117.3 | 13.4 | 160.0 | 59.0 | 61.9 | 41.1 | 113.1 | 13.2 | 951.2 | 21.0 | 739.1 | 11.3 | 891.6 | 15.2 | 860.6 |
| TokenSkip | ✗ | 46.2 | 73.6 | 10.4 | 104.7 | 49.8 | 38.5 | 35.5 | 72.3 | 14.2 | 502.8 | 21.7 | 452.3 | 9.9 | 474.1 | 15.3 | 476.4 |
| PCCoT | ✗ | 20.6 | 8.4 | 4.9 | 10.7 | 29.1 | 8.0 | 18.2 | 9.0 | 11.2 | 9.7 | 20.6 | 10.5 | 2.8 | 9.4 | 11.5 | 9.9 |
| CODI | ✗ | 34.2 | 14.5 | 9.0 | 17.0 | 42.8 | 14.0 | 28.7 | 15.2 | 13.0 | 13.6 | 20.7 | 14.3 | 5.9 | 13.1 | 13.2 | 13.7 |
| SIM-CoT | ✗ | 39.3 | 14.5 | 8.8 | 17.5 | 45.0 | 14.1 | 31.0 | 15.4 | 13.0 | 13.6 | 22.0 | 14.4 | 5.7 | 13.1 | 13.6 | 13.7 |
| TAC-CoT | ✗ | 58.8 | 54.6 | 14.2 | 75.2 | 63.3 | 31.3 | 45.4 | 53.7 | 14.2 | 615.1 | 21.8 | 497.8 | 11.8 | 660.4 | 15.9 | 591.1 |
| Explicit-CoT | ✓ | 52.4 | 109.2 | 30.4 | 145.7 | 62.4 | 58.4 | 48.4 | 104.4 | 33.1 | 309.0 | 40.8 | 247.8 | 53.3 | 293.0 | 42.4 | 283.3 |
| TAC-CoT | ✓ | 61.2* | 43.9 | 32.8 | 57.0 | 67.7† | 26.4 | 53.9 | 42.4 | 36.2† | 49.4 | 46.5* | 39.8 | 54.8 | 43.3 | 45.8 | 44.2 |
| Llama-3.2-1B-Instruct | |||||||||||||||||
| Explicit-CoT | ✗ | 55.1 | 97.0 | 12.4 | 112.9 | 62.3 | 50.5 | 43.2 | 86.8 | 17.4 | 1126.1 | 19.8 | 928.5 | 30.9 | 957.6 | 22.7 | 1004.1 |
| TokenSkip | ✗ | 52.8 | 57.2 | 11.6 | 67.9 | 60.3 | 28.1 | 41.6 | 51.1 | 17.1 | 438.8 | 22.0 | 361.3 | 24.0 | 387.1 | 21.0 | 395.7 |
| PCCoT | ✗ | 45.6 | 7.5 | 10.8 | 7.9 | 53.9 | 7.5 | 36.8 | 7.6 | 4.6 | 11.3 | 7.9 | 11.9 | 4.8 | 10.6 | 5.8 | 11.3 |
| CODI | ✗ | 55.4 | 15.0 | 12.9 | 17.2 | 61.3 | 15.4 | 43.2 | 15.9 | 18.8 | 13.4 | 22.9 | 14.1 | 24.8 | 13.0 | 22.2 | 13.5 |
| SIM-CoT | ✗ | 56.0 | 15.0 | 12.6 | 20.5 | 61.2 | 16.5 | 43.3 | 17.3 | 19.1 | 13.4 | 23.8 | 14.1 | 26.5 | 12.9 | 23.1 | 13.5 |
| TAC-CoT | ✗ | 61.9 | 45.3 | 14.3 | 52.6 | 69.0 | 26.9 | 48.4 | 41.6 | 18.3 | 592.7 | 22.8 | 554.6 | 28.8 | 512.4 | 23.3 | 553.2 |
| Explicit-CoT | ✓ | 58.2 | 86.1 | 35.7 | 97.3 | 66.2 | 45.4 | 53.4 | 76.3 | 39.9 | 270.2 | 48.2 | 225.1 | 65.1 | 240.5 | 51.1 | 245.3 |
| TAC-CoT | ✓ | 65.1* | 38.2 | 39.3* | 43.5 | 73.2* | 23.6 | 59.2 | 35.1 | 41.4 | 52.8 | 52.0* | 44.7 | 65.8 | 46.6 | 53.1 | 48.0 |
| Qwen3-4B | |||||||||||||||||
| Explicit-CoT | ✗ | 76.7 | 133.2 | 44.1 | 195.7 | 77.4 | 71.9 | 66.1 | 133.6 | 11.2 | 1496.0 | 10.6 | 1524.5 | 23.9 | 1273.7 | 15.2 | 1431.4 |
| TAC-CoT | ✗ | 82.6 | 52.6 | 45.9 | 77.3 | 85.5 | 28.3 | 71.3 | 52.7 | 20.4 | 400.1 | 26.3 | 381.4 | 46.9 | 328.6 | 31.2 | 370.0 |
| Explicit-CoT | ✓ | 78.0 | 115.2 | 49.1 | 154.3 | 78.5 | 61.7 | 68.5 | 110.4 | 43.4 | 272.2 | 59.9 | 224.5 | 72.3 | 235.3 | 58.5 | 244.0 |
| TAC-CoT | ✓ | 83.4* | 41.6 | 54.2* | 55.9 | 86.0* | 23.8 | 74.5 | 40.4 | 45.9* | 43.1 | 60.5 | 44.9 | 75.5* | 37.4 | 60.6 | 41.8 |
Table 2. Main results on the math and QA benchmarks (Qwen2.5-0.5B, Llama-3.2-1B, and Qwen3-4B). # Fwd is the average number of forward passes per query. TU indicates whether tools are used. Best scores are highlighted in bold; * and † mark and improvements over the second-best via paired bootstrap with samples ((Koehn, 2004)).
Performance on Agentic Reasoning. Overall, TAC-CoT consistently outperforms Explicit-CoT and the other baselines. Averaged over all backbone models, Our method improves math accuracy by 5.8%p and QA performance by 2.4 points compared with Explicit-CoT. The gains also transfer to out-of-domain benchmarks: Ours improves math performance by 6.5%p in-domain and 5.5%p out-of-domain, and QA performance by 2.4 points in-domain and 2.5 points out-of-domain. This consistent trend suggests that TAC-CoT provides robust adaptive implicit reasoning beyond the training-domain distribution.
To isolate the effect of implicit reasoning from external tool execution, we compare TAC-CoT with other baselines in the no-tool setting on math datasets. While TokenSkip, which shortens rationales by pruning tokens, underperforms
Explicit-CoT, TAC-CoT consistently outperforms the Explicit-CoT agent across all math datasets.
These results indicate that the improvement in internal reasoning does not simply come from shorter reasoning traces. Consistently, TAC-CoT also outperforms baselines that either remove natural-language reasoning entirely or retain concise, explicit reasoning with tool use; see Appendix § 8.§ 2.
Effectiveness of TAC-CoT. The effectiveness of TAC-CoT comes from both tool-use and query-adaptive implicit reasoning. Tool-use substantially improves QA performance, yielding up to a 29.9 point average gain over the no-tool variant while reducing forward passes by 13.3× on Qwen2.5-0.5B. Even without tools, TAC-CoT benefits from adaptive budgeting: on math benchmarks, its no-tool variant outperforms prior implicit-CoT baselines while requiring far fewer forward passes than explicit CoT. These results show that TAC-CoT improves efficiency and performance by adaptively allocating continuous reasoning, with additional gains when external knowledge is needed.
Supplementary full fine-tuning results are provided in Appendix § 8.§ 3.
Diagnostic Analysis
We conduct diagnostic analyses to identify the sources of TAC-CoT’s performance gains across four dimensions: tool-use quality, reduced error accumulation, query-adaptive budgeting efficiency, and lower inference-token cost.
Effectiveness of Tool Use. We evaluate whether TAC-CoT improves tool-mediated decisions on QA benchmarks using Answer Coverage @ (AC@), which measures whether the gold answer appears in the first retrieved observations. As shown in Table 3, TAC-CoT improves AC@5 and AC@10 across all QA datasets, with significant gains on HotpotQA and 2WikiMultiHopQA. Notably, its AC@5 is comparable to the AC@10 of Explicit-CoT, indicating that TAC-CoT retrieves supporting evidence in fewer steps. We further analyze tool-use complexity on ToolBench by fine-tuning Qwen2.5-0.5B-Instruct and comparing TAC-CoT with Explicit-CoT under the StableToolBench evaluation protocol [9]. As shown in Figure 4, TAC-CoT achieves Solvable Win Rates of 51.8% on the single-tool and 58.6% in the multi-tool scenario, with the latter gain being statistically significant. This suggests that interleaved implicit reasoning is especially beneficial for complex multi-tool interactions. A detailed analysis is provided in Appendix § 8.§ 4.
| Method | HotpotQA | HotpotQA | 2WikiMulti | 2WikiMulti | TriviaQA | TriviaQA |
| @5 | @10 | @5 | @10 | @5 | @10 | |
| Explicit-CoT | 48.8 | 51.7 | 70.9 | 71.6 | 72.6 | 75.5 |
| TAC-CoT | 51.8† | 55.4* | 73.7* | 74.4† | 74.5 | 77.4 |
Table 3. Answer Coverage @ (%) over retrieval steps on the QA benchmarks, Qwen2.5-0.5B-Instruct. All AC values are reported as percentages; Best scores are bold; * and † mark and improvements over the underlined Explicit-CoT.
Figure 4. Solvable win rate (SoWR) of TAC-CoT against Explicit-CoT on ToolBench, judged by GPT-5.1. ‘Single’ denotes the single-tool scenario, and ‘Multi’ denotes the multi-tool scenario. * marks .
Error Accumulation Mitigation. Table 2 shows that TAC-CoT improves internal reasoning even without external execution.
To test whether this comes from reduced error accumulation, we analyze reasoning compression and length mismatch. First, we progressively replace explicit reasoning segments with implicit ones when training Qwen2.5-0.5B-Instruct on the augmented GSM8K trajectories. We vary the replacement depth from one to four segments, since four corresponds to the 90th percentile of the number of explicit reasoning segments in the training trajectories. As shown in Table 4, average accuracy on GSM8K, GSM-Hard, and SVAMP increases monotonically as more segments become implicit, suggesting that implicit CoT mitigates errors from lengthy rationales. Second, following the step-efficiency analysis of prior work (Wu et al., 2026), we group GSM8K examples by the offset between generated and gold reasoning lengths. Figure 5 shows that both Explicit-CoT and TAC-CoT perform best under matched lengths and degrade under over-thinking offsets. However, TAC-CoT degrades less, indicating that implicit reasoning reduces the penalty from unnecessary intermediate steps. We discuss further analysis of error accumulation in Appendix § 8.§ 5.
| Metric | E-CoT | # Replaced | Ours | |||
| Mean Acc ↑ | 41.1 | 41.7 | 42.4 | 43.4 | 44.9 | 45.4 |
| # Fwd ↓ | 113.1 | 96.2 | 79.2 | 63.4 | 58.9 | 53.7 |
Table 4. Effect of replacement depth on Qwen2.5-0.5B-Instruct average accuracy over GSM8K, GSM-Hard, and SVAMP. All accuracy values are reported as percentages. E-CoT denotes the Explicit-CoT agent, and # Replaced denotes the number of explicit reasoning segments swapped for continuous thought tokens.
Figure 5. GSM8K accuracy stratified by the offset between the number of generated reasoning steps and the gold step count in the gold solution (negative = underthinking, 0 = matched depth, positive = over-thinking).
Query-Adaptive Continuous-Thought Budget. Unlike prior implicit-CoT methods that use a fixed continuous-token budget for every query, TAC-CoT adaptively allocates its total reasoning budget according to the query. This query-adaptive continuous-thought budgeting contributes to the performance gains, especially for math tasks that depend on internal reasoning. As shown in Figure 6, the benefit becomes larger as the required number of reasoning steps increases.
Figure 6. Accuracy comparison across GSM8K subsets grouped by the number of required reasoning steps. Each denotes the number of samples in the corresponding reasoning-step group.
TAC-CoT’s query-adaptive budgeting benefits inputs that require different amounts of internal deliberation before producing the final answer. We group GSM8K examples into five subsets according to the number of gold reasoning steps, ranging from one to five steps, and treat this number as the required reasoning depth. We then evaluate each subset separately and compare TAC-CoT without tool use against SIM-CoT, a state-of-the-art fixed-budget implicit-CoT baseline, using Qwen2.5-0.5B-Instruct. Figure 6 shows that TAC-CoT consistently outperforms SIM-CoT across all reasoning-depth groups, with larger gains on examples that require more reasoning steps. The improvement increases from 4.6 points on one-step examples to 30.3 points on four-step examples. This trend suggests that assigning the same continuous-thought-token budget to every input becomes increasingly restrictive as the required number of reasoning steps grows. In contrast, TAC-CoT increases the total continuous-token budget by continuing through additional implicit reasoning segments when more reasoning steps are needed. These results demonstrate that TAC-CoT flexibly allocates reasoning budget across queries, which is especially important for reasoning-intensive tasks.
Inference Efficiency. TAC-CoT substantially reduces inference cost relative to Explicit-CoT while improving task accuracy. Across backbones, it reduces the per-query forward count by up to on math benchmarks and on QA benchmarks, with larger savings on QA due to longer multi-step trajectories. This suggests that TAC-CoT becomes increasingly beneficial for longer trajectories.
Although fixed-budget implicit-CoT baselines use fewer forward passes, they do not adapt to query complexity or retrieve missing observations. This limitation is especially harmful for QA, where answers often depend on retrieved evidence, leading to pronounced performance degradation. In contrast, TAC-CoT achieves a better cost–performance trade-off by reducing inference cost relative to Explicit-CoT while avoiding the QA degradation of fixed-budget implicit-CoT methods.
On a single NVIDIA L40S GPU, TAC-CoT achieves measured wall-clock speedups of on math and on QA. Since realized latency depends on hardware, implementation, and external API overhead, #Fwd reductions should not be interpreted directly as wall-clock speedups; see Appendix § 8.6 for full results.
Related Works
Explicit and Implicit CoT. Chain-of-Thought (CoT) improves the reasoning ability of large language models by generating intermediate reasoning before the final answer (Wei et al., 2022; Kojima et al., 2022). CoT methods are commonly categorized as explicit or implicit, depending on whether intermediate reasoning is represented as discrete tokens or continuous representations. Explicit CoT is readable and easy to supervise (Wei et al., 2022; Kojima et al., 2022; Yao et al., 2023), but decoding long reasoning traces increases inference cost [10] (Xia et al. 2025) and exacerbates stepwise error accumulation (Wu et al., 2026).
Implicit CoT instead performs intermediate reasoning in continuous latent space (Hao et al., 2025; Shen et al., 2025; Wu et al., 2025; Wei et al., 2026; Kuznia et al., 2026). For example, Coconut feeds hidden states back as continuous thought tokens (Hao et al., 2025), CODI distills explicit CoT into continuous representations (Shen et al., 2025), PCCoT updates latent thought tokens in parallel for efficient inference (Wu et al., 2025), and SIM-CoT stabilizes implicit reasoning via step-level reconstruction (Wei et al., 2026). Although these methods reduce the cost of verbalized reasoning, they are mainly designed for standalone reasoning: they typically allocate a fixed number of continuous thought tokens per query and do not expose intermediate decisions as executable interfaces, limiting their suitability for agentic settings that require repeated reasoning and acting.
In contrast, TAC-CoT extends implicit CoT to tool-using agentic systems by interleaving compact latent reasoning segments with explicit tool interactions, enabling tool calling and query-adaptive reasoning budgets. At the same time, compared with explicit-CoT agents, TAC-CoT avoids the need to verbalize intermediate reasoning, thereby reducing inference cost and mitigating error accumulation from lengthy reasoning traces.
Tool-Using LLM Agents. LLMs are increasingly studied as agents that solve tasks through interleaved reasoning, tool calls, and observations (Yao et al., 2022; Schick et al., 2023; Shinn et al., 2023; Yang et al., 2025). ReAct formalizes this reasoning–acting loop (Yao et al., 2022), while Toolformer (Schick et al., 2023) and ART (Paranjape et al., 2023) show that models can invoke external APIs and resume generation after tool execution. However, most tool-using agents still rely on explicit CoT (Wei et al., 2022; Kojima et al., 2022; Yao et al., 2023), whose repeated generation across multi-step interaction loops makes inference costly [10, 2] (Xia et al. 2025) and vulnerable to error accumulation (Wu et al., 2026).
Conclusion
We presented TAC-CoT, a tool-empowered adaptive continuous CoT framework that extends implicit reasoning to tool-using agentic problem solving. By interleaving compact continuous reasoning segments with explicit tokens for tool calls, observations, and final answers, TAC-CoT preserves the executable interface required for agentic workflows while avoiding the cost of fully verbalized reasoning traces. Across agentic math and knowledge-intensive QA benchmarks, TAC-CoT consistently outperforms Explicit-CoT agents in both in-domain and out-of-domain settings, while using substantially fewer model forward passes. Further analyses show that TAC-CoT improves tool-use decisions, performs better in multi-tool scenarios, mitigates error accumulation, and benefits from query-adaptive continuous thought-token allocation.
Limitations
This work has a few limitations: First, the adaptive routing mechanism operates at the segment level rather than the token level. Second, longer interaction horizons remain an important direction for evaluating the practical deployment of TAC-CoT.
Acknowledgements
This work was supported by the National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT) (No. RS-2024-00334343). Additionally, this work was supported by the National IT Industry Promotion Agency (NIPA) grant funded by the Korea government (MSIT) (No. RS-2026-25621604).
Details of Data Construction
This section provides the details of the recipe described in § 2.3 for each domain.
Math Problem Solving. The math domain follows the source-obtainable interaction setting described. For GSM8K, where data with explicit interactions already exist, we use GSM8K-Aug and GSM8K-Aug-NL, two GSM8K augmentations with 385k samples each [6]. GSM8K-Aug retains only the arithmetic equations in each reasoning step (e.g., «86.715.01=13.005»), whereas GSM8K-Aug-NL contains only explicit reasoning (e.g. ...day, 86.7 x 15% = 13.005 coins...). Because the two datasets have the same questions, we align examples by question and insert the equations from GSM8K-Aug into the corresponding natural language reasoning trajectory from GSM8K-Aug-NL.
Question-Answering. For HotpotQA, which provides only questions and their gold answers without faithful tool-use trajectories, we construct trajectories by prompting DeepSeek-V3 to solve each question with access to a retrieval tool. Following Yao et al. (2022), we implement a Wikipedia retrieval system and use the ReAct-style few-shot demonstrations from their setup. The prompt template is shown in Figure 11 and Figure 12.

Figure 11. Prompt used to construct QA tool-use trajectories. We prompt DeepSeek-V3 as a ReAct-style Wikipedia agent with access to Search, Lookup, and Finish.

Figure 12. Prompt used to construct QA tool-use trajectories, continued from Figure 11. The few-shot demonstrations follow the ReAct prompt format.
Quality Audit and Construction Cost. To assess the quality of the synthesized QA trajectories, we randomly sampled 200 trajectories and evaluated them using GPT-5.1, a model different from the DeepSeek-V3 teacher. The evaluator assessed whether the generated actions and final answers were logically valid, and judged 99% of the sampled trajectories to be valid.
Generating the QA trajectories cost $102.73 in total, including generations discarded during answer-based filtering. The filtering pass rate was 56.24%. Because exact-match filtering may reject semantically correct answers expressed differently from the gold annotation, this procedure may underestimate the usable trajectory yield.
Implementation Details
Training hyperparameters
For the CODI loss weight, we set for TAC-CoT and for PCCoT, CODI, and SIM-CoT, following Shen et al. (2025); Wu et al. (2025); Wei et al. (2026). For TokenSkip,
we use a 50% compression ratio during training to keep its number of forward passes comparable to that of TAC-CoT. For the larger Qwen3-4B backbone, we use continuous tokens per segment for a practical training setup.
Implicit CoT Baseline Details
For each implicit CoT baseline, we report the higher score between models trained on GSM8K-Aug-NL and GSM8K-Aug.
Evaluation benchmark. For math benchmarks, we evaluate on the full test sets. For QA benchmarks, we evaluate on 1,000 randomly sampled examples from each dataset. This follows approaches used by Yin et al. (2023); Kaesberg et al. (2025); Jang et al. (2025). Specifically, we follow the standard sample-size estimate for population proportions:
where , , and , corresponding to a 95% confidence level and a 5% margin of error under the conservative maximum-variance assumption. This gives , so our choice of 1,000 examples per QA dataset is above the required sample size. Since EM and Answer Coverage are averaged binary outcomes over examples, 1,000 random samples yield a conservative worst-case 95% margin of error of approximately percentage points before finite-population correction.
Calculator setting. For math tasks, we build a calculator database by extracting equations from the training trajectories. During evaluation, if an expression matches an entry in this database, we use the corresponding stored result. Otherwise, we process the expression before calculation and then execute it with the calculator. This design handles cases where expressions contain units or other non-numeric tokens that cannot be directly evaluated by a standard calculator.
ToolBench API details. For ToolBench, many of the original APIs are no longer available at inference time. Following Guo et al. [9], we therefore use MirrorAPI. Because TAC-CoT does not verbalize its reasoning, we explicitly note this in the GPT-5.1 judge prompt.
No-tool evaluation protocol. For the no-tool setting (TU = ), we disable the external tool executor while preserving the trajectory format used by tool-using agents. When the model emits an action-like span, no environment-returned observation is injected. Instead, the model continues generation and produces the corresponding observation text by itself. Thus, the no-tool setting evaluates reasoning without externally supplied tool outputs. All generated observation tokens are counted in the inference cost, and we use the same answer extraction and evaluation metrics as in the tool-use setting.
| Hyperparameter | Qwen2.5 0.5B-Instruct | Llama-3.2 1B-Instruct | Qwen3 4B |
| Fine-tuning strategy | Full fine-tuning | LoRA | LoRA |
| LoRA rank | – | 128 | 128 |
| LoRA scaling factor | – | 32 | 32 |
| LoRA dropout | – | 0.1 | 0.1 |
| Learning rate | |||
| LR scheduler | Cosine | Cosine | Cosine |
| Warmup | 0.03 | 0.03 | 0.03 |
| Optimizer | AdamW | AdamW | AdamW |
| Batch size | 128 | 128 | 128 |
| Gradient norm clipping | 2 | 2 | 2 |
| Training epochs | 10 | 10 | 5 |
Table 5. Training hyperparameters used for each backbone model. Values are shared across all compared methods unless otherwise specified.
Additional Experiments
This appendix provides additional analyses that complement the main experimental results. We first study how the number of allowed tool calls can mitigate error propagation (Yao et al., 2022). We then analyze how errors accumulate as reasoning depth increases, which motivates the need for shorter reasoning methods, such as implicit CoT. Finally, we report supplementary full fine-tuning results for additional backbone settings that are not included in the main results table.
Effect of Continuous-Thought Tokens
We analyze the effect of the number of continuous thought tokens (CT) per continuous segment. We vary the CT budget over and evaluate Qwen2.5-0.5B-Instruct on GSM8K, GSM-Hard, and SVAMP. Table 6 shows the results. Compared to the 0 CT setting, using CT tokens improves the average accuracy from 42.0% to 44.9% with one CT token and 45.4% with three CT tokens. These results suggest that allocating more CT can be beneficial.
| # CT | Math | |||
| GSM8K | GSM-Hard | SVAMP | Average | |
| 0 | 55.7 | 13.9 | 56.3 | 42.0 |
| 1 | 58.5 | 14.7 | 61.5 | 44.9 |
| 3 | 58.8 | 14.2 | 63.3 | 45.4 |
Table 6. Effect of the number of continuous thought tokens (# CT) per continuous segment on math datasets, using Qwen2.5-0.5B-Instruct. All scores are reported as percentages.
Controlled Baseline Comparisons
We conduct additional controlled comparisons to distinguish the benefit of implicit reasoning from two simpler explanations: removing natural-language rationales and shortening explicit reasoning traces. All experiments in this section use Qwen2.5-0.5B-Instruct.
No Reasoning. We first consider a no reasoning control. This baseline removes natural-language rationales, while retaining the arithmetic equations used for intermediate computation. This comparison isolates whether TAC-CoT’s improvement can be explained simply by removing verbose natural-language reasoning. As shown in Table 7, TAC-CoT improves the average accuracy from 42.0% to 45.4% in the no-tool setting.
| Method | GSM8K | GSM-Hard | SVAMP | Average |
| No-tool setting | ||||
| No Reasoning | 55.7 | 13.9 | 56.3 | 42.0 |
| TAC-CoT | 58.8 | 14.2 | 63.3 | 45.4 |
| Tool-enabled setting | ||||
| TokenSkip | 52.3 | 27.0 | 57.0 | 45.4 |
| TAC-CoT | 61.2 | 32.8 | 67.7 | 53.9 |
Table 7. Controlled comparisons on the mathematical reasoning benchmarks using Qwen2.5-0.5B-Instruct. The no-natural-language reasoning control removes natural-language rationales and continuous thought tokens while retaining arithmetic equations. TokenSkip + Tool provides a concise explicit-CoT control under the tool-enabled setting. All scores are accuracy (%).
Concise Explicit-CoT with Tools. We further compare against a concise explicit-CoT agent with the same tool-enabled setting. Specifically, we extend TokenSkip to tool use and apply the same 50% compression ratio used in our main experiments, thereby shortening explicit reasoning traces while preserving explicit reasoning and tool interaction. TAC-CoT achieves an average accuracy of 53.9%, compared with 45.4% for TokenSkip with tools. The improvement is consistent across GSM8K, GSM-Hard, and SVAMP.
Overall, these controlled comparisons indicate that TAC-CoT’s improvement is not solely attributable to eliminating natural-language prose or reducing the length of explicit reasoning.
Additional Full Fine-Tuning Results
We report supplementary results under full fine-tuning for backbone settings not covered in the main results table. Table 8 shows results for Llama-3.2-1B-Instruct with full fine-tuning, complementing the LoRA-adapted Llama results in Table 2.
| Method | GSM8K | GSM-Hard | SVAMP | Average | |
| Explicit-CoT | 52.2 | 13.9 | 68.5 | 44.9 | |
| TAC-CoT | 62.0 | 14.9 | 68.7 | 48.5 |
Table 8. Math accuracy of Explicit-CoT agent and TAC-CoT on GSM8K, GSM-Hard, and SVAMP when Llama3.2-1B-Instruct is fully fine-tuned (no LoRA), reported for reference against the LoRA-adapted Llama numbers in Table 2.
Table 9 reports full fine-tuning results for a GPT-2 backbone. Across both settings, TAC-CoT consistently improves over the Explicit-CoT agent baseline, further supporting the effectiveness of our method across model families and settings.
| Method | GSM8K | GSM-Hard | SVAMP | Average | |
| Explicit-CoT | 32.8 | 6.6 | 38.2 | 25.9 | |
| TAC-CoT | 47.7 | 10.8 | 45.0 | 34.5 |
Table 9. Math accuracy of Explicit-CoT agent and TAC-CoT on GSM8K, GSM-Hard, and SVAMP under a GPT2 backbone with full fine-tuning, complementing the Qwen and Llama backbones reported in Table 2.
Impact of the Tool-Use Budget
To investigate how the number of permitted tool-use affects performance, we conduct an ablation study on GSM8K samples containing four or more equations, since each equation corresponds to a potential calculator invocation. We vary the maximum number of calculator calls from 0 to 4, and also evaluate with unlimited calls. As shown in Figure 8, accuracy improves monotonically as the number of allowed tool calls increases. This suggests that each additional tool call can contribute to mitigate error propagation during multi-step reasoning.
Figure 8. Impact of the number of tool calls on GSM8K accuracy. TC=0 denotes no tool calling, and TC=all denotes unlimited tool calls.
Impact of Error Accumulation
As shown in Figure 7, we trained GPT-2 and Llama3.2-1B-Instruct on GSM8k-Aug and GSM8K-Aug-NL to analyze how intermediate reasoning errors accumulate as reasoning depth increases. In these datasets, equations are inserted into explicit reasoning. When gold reasoning is provided, GSM8K-Aug-NL-trained models outperform models trained on GSM8K-Aug, which are not trained to generate natural-language rationales. However, this advantage progressively diminishes as the number of generated reasoning steps increases. This trend suggests that, although explicit natural language reasoning can be beneficial under oracle reasoning conditions, error accumulation during intermediate steps can degrade accuracy. The degradation is less pronounced for the larger 1B model, which is consistent with prior observations that larger models are more robust to error accumulation in multi-step reasoning (von Recum et al., 2026).
Figure 7. Effect of reasoning depth on error accumulation.
Wall-Clock Speedup of TAC-CoT
We additionally report wall-clock inference time on a single NVIDIA L40S GPU using Qwen2.5level parallelization.
0.5B-Instruct. As shown in Table 10, TAC-CoT consistently reduces both the number of forward passes and end-to-end latency compared with the Explicit-CoT agent. On average, TAC-CoT uses fewer forward passes on the math benchmarks and fewer forward passes on the QA benchmarks. These reductions also translate into practical wall-clock speedups: TAC-CoT runs faster on math benchmarks and faster on QA benchmarks on average. When isolating model generation time by excluding external overheads, the speedup further increases, reaching up to .
| Method | Dataset | # Fwd | ms/sample |
| Agentic Math | |||
| TAC-CoT | GSM8K | 43.9 | 545.0 |
| TAC-CoT | GSM-Hard | 57.0 | 712.2 |
| TAC-CoT | SVAMP | 26.2 | 335.9 |
| TAC-CoT | Average | 42.4 | 531.0 |
| Explicit-CoT | GSM8K | 109.2 | 1232.2 |
| Explicit-CoT | GSM-Hard | 145.7 | 1673.5 |
| Explicit-CoT | SVAMP | 58.4 | 682.5 |
| Explicit-CoT | Average | 104.4 | 1196.1 |
| Agentic QA | |||
| TAC-CoT | HotpotQA | 49.4 | 4455.3 |
| TAC-CoT | 2WikiMulti | 39.8 | 2409.6 |
| TAC-CoT | TriviaQA | 43.3 | 2697.7 |
| TAC-CoT | Average | 44.2 | 3187.5 |
| Explicit-CoT | HotpotQA | 272.2 | 7765.8 |
| Explicit-CoT | 2WikiMulti | 224.5 | 7372.7 |
| Explicit-CoT | TriviaQA | 235.3 | 7825.0 |
| Explicit-CoT | Average | 244.0 | 7654.5 |
Table 10. Inference-time comparison between TAC-CoT and Explicit-CoT on the Qwen2.5-0.5B-Instruct backbone. ms/sample denotes the average wall-clock inference latency in milliseconds per sample, measured on a single NVIDIA L40S GPU.
These speedups are smaller than the reductions in forward passes because forward-pass count does not translate linearly into end-to-end latency. In our current implementation, total latency still includes non-optimized execution paths, parallelization overheads, and API-call latency. Thus, while TAC-CoT already provides consistent practical speedups in wall-clock time, the gap between forward-pass reduction and realized latency reduction suggests that further gains are possible with more optimized implementation and execution-level parallelization.
Case Studies
Figure 9 presents qualitative examples from agentic math and QA using Qwen2.5-0.5B-Instruct. Explicit-CoT and TAC-CoT are both tool-using agents, while SIM-CoT does not expose intermediate tool interactions.

Figure 9. Case studies on Qwen2.5-0.5B-Instruct. Gold Explicit-CoT (SFT) SIM-CoT TAC-CoT (ours). Red: error step. (a) Explicit-CoT applies the overtime rate to all 45 h instead of 5 h; SIM-CoT’s fixed latent budget yields a wrong answer with no intermediate steps; TAC-CoT grounds each arithmetic step via calculator calls. (b) SIM-CoT hallucinates “Wake Island” without retrieval; Explicit-CoT searches but rationalizes a wrong answer with a false claim (Thought 9); TAC-CoT spots “Laysan” in search suggestions and retrieves the evidence.
In the math example, Explicit-CoT calls the calculator but applies the overtime rate to all 45 hours instead of the 5 overtime hours. SIM-CoT also fails without explicit intermediate computation. TAC-CoT grounds each arithmetic sub-step with calculator calls and preserves the correct decomposition of regular pay, overtime hours, and final summation.
In the QA example, SIM-CoT hallucinates “Wake Island” without retrieval. Explicit-CoT searches for evidence but follows an irrelevant O‘ahu suggestion and later makes a false factual claim. TAC-CoT instead uses the failed search’s similar-results list to identify “Laysan” and then retrieves confirming evidence.
Code Details
Figure 10 presents the TAC-CoT inference loop code. We describe the key implementation decisions below.
Continuous thought token injection. The continuous thought token is produced by applying a projection head to the last hidden state of the transformer: , where is extracted from the final layer at the last sequence position. The continuous token is fed back to the model via inputs_embeds, bypassing the vocabulary embedding lookup entirely. No vocabulary index is ever assigned to a continuous thought token.
Route selection and observation injection. At the end of each latent segment, is fed via inputs_embeds to obtain route logits. If the [[ANSWER]] logit exceeds [[EXPLICIT]], the model switches to answer generation; otherwise, action tokens are generated greedily until a stop token (</action>). Upon a tool call, the closing action token and the returned observation text are concatenated and processed in a single forward pass, after which the latent iteration loop restarts.
References
- [1]Pranjal Aggarwal, Seungone Kim, Jack Lanchantin, Sean Welleck, Jason E Weston, Ilia Kulikov, and Swarnadeep Saha. 2026. OptimalThinkingBench: Evaluating over and underthinking in LLMs. In The Fourteenth International Conference on Learning Representations.arxiv.org/abs/2508.13141
- [2]Simon A. Aytes, Jinheon Baek, and Sung Ju Hwang. 2025. Sketch-of-thought: Efficient LLM reasoning with adaptive cognitive-inspired sketching. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing, pages 24296–24320, Suzhou, China. Association for Computational Linguistics.
- [3]Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. 2021. Training verifiers to solve math word problems. Preprint, arXiv:2110.14168.arxiv.org/abs/2110.14168
- [4]DeepSeek-AI, Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chenggang Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, Damai Dai, Daya Guo, Dejian Yang, Deli Chen, Dongjie Ji, Erhang Li, Fangyu Lin, Fucang Dai, and 181 others. 2025a. Deepseek-v3 technical report. Preprint, arXiv:2412.19437.arxiv.org/abs/2412.19437
- [5]DeepSeek-AI, Aixin Liu, Aoxue Mei, Bangcai Lin, Bing Xue, Bingxuan Wang, Bingzheng Xu, Bochao Wu, Bowei Zhang, Chaofan Lin, Chen Dong, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenhao Xu, Chong Ruan, Damai Dai, Daya Guo, Dejian Yang, and 245 others. 2025b. Deepseek-v3.2: Pushing the frontier of open large language models. Preprint, arXiv:2512.02556.arxiv.org/abs/2512.02556
- [6]Yuntian Deng, Kiran Prasad, Roland Fernandez, Paul Smolensky, Vishrav Chaudhary, and Stuart Shieber. 2024. Implicit chain of thought reasoning via knowledge distillation.arxiv.org/abs/2311.01460
- [7]Luyu Gao, Aman Madaan, Shuyan Zhou, Uri Alon, Pengfei Liu, Yiming Yang, Jamie Callan, and Graham Neubig. 2023. PaL: program-aided language models. In Proceedings of the 40th International Conference on Machine Learning, ICML’23. JMLR.org.arxiv.org/abs/2211.10435
- [8]Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. 2024. The llama 3 herd of models. arXiv preprint arXiv:2407.21783.arxiv.org/abs/2407.21783
- [9]Zhicheng Guo, Sijie Cheng, Hao Wang, Shihao Liang, Yujia Qin, Peng Li, Zhiyuan Liu, Maosong Sun, and Yang Liu. 2024. StableToolBench: Towards stable large-scale benchmarking on tool learning of large language models. In Findings of the Association for Computational Linguistics: ACL 2024, pages 11143–11156, Bangkok, Thailand. Association for Computational Linguistics.
- [10]Tingxu Han, Zhenting Wang, Chunrong Fang, Shiyu Zhao, Shiqing Ma, and Zhenyu Chen. 2025. Token-budget-aware LLM reasoning. In Findings of the Association for Computational Linguistics: ACL 2025, pages 24842–24855, Vienna, Austria. Association for Computational Linguistics.arxiv.org/abs/2412.18547







