Capable yet Parsimonious: Extracting and Characterizing Hidden Chain-of-Thought in Frontier Models

AI summary

Overview

Research area: Natural Language Processing / large language model interpretability, specifically chain-of-thought (CoT) reasoning in closed-source frontier models.

Technical level: Intermediate. The protocol itself is simple (a single custom API tool), but the analysis draws on reasoning-tree construction, episode taxonomies, and transfer experiments.

Scope: The paper introduces a tool-based protocol for eliciting intermediate reasoning from frontier models whose native CoT is hidden, validates it against observable native CoT on open models, and then uses the extracted traces to compare how four closed-source models structure, compress, and reuse reasoning.

What This Paper Is About

Closed-source providers hide native chain-of-thought, so benchmark accuracy tells us what a model can solve but not how it reasons or why stronger and more efficient models differ. The authors register a custom "scratchpad" tool through a standard API feature, force the model to select it on the first call, and thereby induce frontier models to externalize intermediate reasoning in the tool arguments. They then validate these extracted traces and use them to characterize how frontier models organize their reasoning.

Key Contributions

1. A validated instrument for observing hidden reasoning. A fixed tool schema elicits coherent intermediate reasoning from frontier models even when the designated reasoning mode is disabled or the provider reports zero reasoning tokens, showing that current controls do not fully prevent reasoning-like content from being externalized through other API fields. The traces are validated against native CoT on open models and, behaviorally, on closed-source frontier models.
2. Efficient reasoning is concise, dense, and directed. Across token use, reasoning-step types, and induced reasoning trees, models primarily differ in how much they externalize, not in which operations they perform. GPT-6 Astra produces the shortest but least compressible traces and follows the most direct reasoning paths with little branching.
3. Cross-model trace transferability is uneven. Compact traces are used almost losslessly by strong recipient models but only partly by weaker ones, which sometimes fail to produce an answer the trace already states.
4. A behavioral lens beyond benchmark scores. The work characterizes frontier-model reasoning through token efficiency, reasoning-step types, and induced reasoning trees, providing a basis for comparison that aggregate accuracy cannot give.

Main Findings

• Extraction succeeds consistently. Across completed benchmark runs conducted before September 9, 2026, Forced-Reasoning extracted nonempty tool content in 100% of runs on Opus 4.8, Sonnet 5, and GPT-5.6-sol, with no observed model-issued flags or warnings.
• Open-model validation recovers near-native performance. On MATH, DeepSeek-V4-Flash rises from 30.5% without reasoning to 73.3% with Forced-Reasoning, compared with 70.0% under native reasoning. GLM-5.2 achieves 21.4% without reasoning, 84.3% with Forced-Reasoning, and 89.9% under native reasoning.
• Extracted traces resemble native CoT lexically and structurally. For DeepSeek-V4-Flash, the native-to-native pair scores 0.613 ROUGE-1, 0.198 ROUGE-L, and 0.017 5-gram Jaccard, while the native-to-forced pair scores 0.538, 0.188, and 0.017. For GLM-5.2, N–N scores 0.588, 0.196, and 0.019 versus N–F at 0.465, 0.171, and 0.008. The median per-question forced-to-native reasoning-length ratio is 1.39x for GLM-5.2 and 1.42x for the N–N reference of DeepSeek-V4-Flash.
• Closed-source Forced-Reasoning approaches native accuracy. On MATH, Opus 4.8 scores 72.5 (None), 86.3 (Native), 85.0 (Forced); Sonnet 5 scores 42.5, 77.5, 81.3; GPT-5.6 Sol scores 25.0, 97.5, 91.3; GPT-6 Astra has N/A for None, 97.5 Native, and 93.8 Forced. On HLE: Opus 4.8 24.0/33.0/27.0, Sonnet 5 17.0/21.0/22.0, Sol 13.0/25.0/23.0, Astra N/A/35.0/32.0. On LiveCodeBench: Opus 4.8 58.0/83.0/82.0, Sonnet 5 52.0/77.0/77.0, Sol 47.0/90.0/90.0, Astra N/A/92.0/89.0.
• Astra produces the shortest and least compressible traces. GPT-6 Astra has the highest zlib ratio in all three benchmarks, indicating less compressible text under this measure, and is described as producing the shortest traces among the models studied.
• Local granularity differs. In matched excerpts, arithmetic and algebraic expansions are collapsed into fewer written steps, and background knowledge is used without being restated (for example, writing 48 + 18 + 36 = 102 without first restating that carbon, hydrogen, and oxygen contribute 4, 1, and 6 valence electrons).
• Global structure differs sharply. On MATH, median reasoning-tree width, depth, and node count are: GPT-6 Astra 5.0 [3.0, 9.0], 11.0 [8.8, 15.0], 27.0 [17.8, 44.0]; GPT-5.6 Sol 12.0 [5.0, 19.3], 11.0 [10.0, 13.0], 60.0 [29.8, 90.3]; Claude Opus 4.8 22.0 [5.0, 44.0], 12.0 [9.0, 14.0], 96.0 [28.5, 220.3]; Claude Sonnet 5 28.5 [9.0, 49.3], 13.0 [10.0, 15.0], 136.0 [44.8, 234.8].
• Reasoning-activity profiles are broadly similar. Analysis and implementation account for the largest shares across all models, while planning, exploration, verification, reading, and monitoring appear in comparable overall proportions; no model shows a qualitatively different activity composition. Astra shows this similar high-level profile despite producing substantially shorter traces.
• Trace reuse depends on the recipient. Traces from Sol and Opus are reused with little loss by every recipient. Astra's traces are reproduced nearly fully by strong recipients but recovered less by weaker ones, with the largest shortfalls for Claude Haiku 4.5 and GPT-5.4 Nano. GPT-5.4 Nano and DeepSeek-V4-Flash have comparable Native-high accuracy but differ in how much they recover.
• A capability ceiling for reading traces. In some cases the donor's trace states the correct answer and the recipient still answers incorrectly with a different final answer.
• Tool calling beats plain step-by-step prompting. For GPT-5.6-sol on HMMT, disabling native reasoning and directly requesting step-by-step reasoning raises accuracy from 39.4% to 60.6%. Moving the maximal-deliberation instruction into the response prompt still yields only 60.6%, whereas forced tool calling reaches 84.8% with the default description and 93.9% with maximal deliberation.
• Tool description modulates how much is externalized. On MATH, Sol's no-tool Default condition scores 25.0% with 442 tokens, Plain 36.3% with 906 tokens, and Maximal 36.3% with 670 tokens; Native Low scores 78.8% with 1,599 tokens and Native Medium 92.5% with 3,403 tokens. On HLE, no-tool Default scores 10.0% with 126 tokens, Plain 12.0% with 263 tokens, Maximal 12.0% with 169 tokens, Native Low 27.0% with 819 tokens, and Native Medium 27.0% with 1,791 tokens.
• Settings differ per model. Sol uses maximal-deliberation wording, while Astra uses low native reasoning effort with the think-here tool description; Astra's reported Forced results have zero provider-reported native reasoning tokens, and native reasoning is not disabled for Astra.

Methodology in Plain English

The authors register a custom tool called forced-reasoning(reasoning:string) whose single free-form string argument is meant to hold intermediate reasoning. The default tool description is simply "Scratchpad for working through the problem."

On the first provider call, they use the API's tool_choice control to require the model to select this tool. They record the returned arguments, append the assistant tool call plus a content-free acknowledgment ("Received") to the conversation, then restore automatic tool choice so the model can call the tool again or produce a final answer. The tool performs no external computation; its only role is to make intermediate text visible and keep it in the conversation. The forced part is the initial tool selection; the reasoning content itself is generated by the model while solving the task.

They evaluate three conditions: None (native reasoning disabled, no tool), Native (native reasoning enabled at high effort), and Forced (their protocol). They test on MATH (80 competition-level problems: 47 APEX Shortlist problems and all 33 February 2026 HMMT problems from MathArena), LiveCodeBench (100 questions: all 80 problems labeled hard in the v6 shard plus 20 hard problems sampled uniformly without replacement from v5, sorted by question identifier with seed 2026), and Humanity's Last Exam (100 questions sampled without replacement with seed 2026 from 1,182 remaining after excluding image-input questions, questions labeled Math, and entries without reference answers; balanced at 15 each for Biology/Medicine and Computer Science/AI and 14 each for Chemistry, Engineering, Humanities/Social Science, Physics, and Other). All experiments were conducted through OpenRouter.

For validation on open models, they compare extracted traces to observable native CoT at three levels: performance, lexical overlap (ROUGE-1, ROUGE-L, and contiguous word 5-gram Jaccard, using ten sampled pairs per question from ten-rollout pools), and structure. For structure they segment traces into local reasoning units and use an LLM-as-a-judge to assign each unit to one of seven categories — Read, Analyze, Plan, Implement, Explore, Verify, Monitor — with Other as a residual label.

For global structure they use LCoT2Tree to convert each trace into a reasoning tree, reporting width p (maximum lateral expansion at any reasoning-sketch step), depth q (furthest occupied sketch step), and node count N (total reasoning nodes excluding the artificial root); revisiting an earlier stage creates an additional node rather than merging.

Finally, they transplant traces between models, calling the producer the donor and the consumer the recipient. Each recipient receives the donor's extracted reasoning trace without its final answer as prior context, then answers in a single call with native reasoning disabled and no tools. Recipients were chosen to span a wide range of standalone Native-high performance on MATH.

Why This Matters

Impact on research. The paper argues that reasoning-mode controls do not fully prevent reasoning-like content from being externalized through other API channels, and it supplies a behavioral basis for comparing frontier-model reasoning beyond aggregate benchmark scores. It also reframes trace explicitness as a variable distinct from teacher strength, offering a candidate mechanism for the capacity gap observed in distillation: the strongest teachers write the most compressed traces, and a compressed trace omits precisely the steps a weaker student cannot reconstruct.

Real-world applications:

• Distillation and supervision design. The finding that compact traces are used almost losslessly by strong models but only partly by weak ones suggests selecting supervision data by the reader's capability, not only by donor strength.
• Model auditing and verification. Providing a channel that surfaces intermediate steps supports deployments where conclusions must be traceable to specific inferential steps, rather than resting on a final answer alone.
• Provider confidentiality and capability-control assessment. The result that a standard tool field can carry reasoning-like content even with the designated reasoning mode off is directly relevant to how providers design and evaluate their controls.
• Benchmark interpretation. Separating how much reasoning a model externalizes from what it can solve gives a more differentiated view of capability than accuracy alone.

Industry relevance. Providers optimizing for token efficiency may find their models' traces less usable by the smaller models most likely to learn from them — a tension the authors expect to sharpen as frontier models continue to be optimized for token efficiency.

Future Directions

• Test the expansion prediction. The authors offer a testable prediction: expanding a compressed trace into its implicit intermediate steps should restore most of its usefulness to weak recipients while leaving strong ones largely unaffected.
• Move from in-context reuse to actual distillation. The paper explicitly does not test post-training distillation; its experiment measures in-context reuse, and donor traces differ in correctness, content, and style, so compression is not isolated as a causal factor.
• Establish whether extracted text is internal reasoning. For closed-source models the evidence is necessarily behavioral: the authors cannot determine whether the extracted text reflects the model's actual internal reasoning or merely provides a useful behavioral proxy. Similarity to native traces and downstream utility should not be interpreted as identity with internal computation.
• Broaden the protocol's reach. The approach requires an API-as-a-service interface supporting custom tools and forced selection of a named tool; endpoints without these controls fall outside its scope. Prompt sensitivity also varies across models, and Forced-Reasoning does not correspond to a fixed native reasoning effort level.

Target Audience

This paper benefits researchers working on LLM reasoning, interpretability, and evaluation; engineers building distillation or reasoning-data pipelines; and safety, policy, and trust-and-safety practitioners interested in what standard API controls do and do not prevent. It is also relevant to anyone who needs to compare frontier models on more than benchmark accuracy. The protocol is simple enough for practitioners to reproduce, while the structural analyses assume familiarity with chain-of-thought terminology and tree-based reasoning representations.

Authors’ abstract

The rapid capability gains of frontier language models are widely attributed to improved reasoning abilities, yet this cannot be verified as raw CoT traces in closed-source systems are hidden. By registering a simple custom tool through a standard API feature, we induce frontier models to externalize intermediate reasoning. Because these traces may reflect post-hoc rationalization rather than genuine reasoning, we first evaluate against native CoT on open-source models and extend to closed-source frontier models including GPT-6 Astra. We find that the extracted reasoning matches native reasoning performance and substantially outperforms no-reasoning baselines, across competition mathematics, science, and code generation. We then characterize how frontier models structure their intermediate reasoning. Across token efficiency, reasoning-step types, and induced reasoning trees, we identify systematic differences in how models externalize, compress, and organize reasoning. We find that Astra exhibits token-efficient directed reasoning, selecting a correct trajectory earlier, while resolving elementary steps internally and externalizing only crucial reasoning. These findings provide a behavioral lens on frontier-model reasoning beyond benchmark scores.