By registering a dummy Forced-Reasoning protocol through a standard API, the authors coax closed models like GPT-6 Astra to externalize hidden reasoning, then show Astra reaches near-native accuracy while writing markedly shorter, narrower reasoning trees than peers.
You’re building on top of a closed frontier model and want to know how it reasons, not just what it answers. Providers hide the native chain-of-thought and expose only final answers, so you cannot audit whether a correct answer came from sound steps or lucky guessing. That gap matters for verification, distillation, and comparing models beyond leaderboard percentages.
Prior work has poked at this in narrow ways. EchoCoT and related methods replay already-generated native reasoning through tool calls, and Trace Inversion reconstructs reasoning from observable outputs. This paper instead asks a plainer question: if you disable the native “thinking” channel and hand the model a scratchpad tool, will it just reason there? The answer, mostly, is yes.
The mechanism is almost embarrassingly simple. You define a single custom function called forced-reasoning that takes one string argument. On the first API call you set tool_choice to require that function, so the model has to write something into the scratchpad before doing anything else. You reply with a fixed acknowledgment (“Received”), then switch to automatic tool choice. The model can call the tool again or emit a final answer. The tool does no computation. It only makes intermediate text visible and keeps it in the conversation.
Crucially, only the initial tool selection is forced. Everything the model then writes is generated while it is actually solving the task, not scripted by the prompt.
To argue the extracted text is real reasoning rather than post-hoc storytelling, the authors first run this on open models where native chain-of-thought is visible (DeepSeek-V4-flash, GLM-5.2) and compare extracted traces to native ones on accuracy, ROUGE overlap, and functional structure using a seven-category taxonomy (Read, Analyze, Plan, Implement, Explore, Verify, Monitor) from Schoenfeld’s episode framework. They then apply the protocol to closed models: Claude Opus 4.8, Claude Sonnet 5, GPT-5.6 Sol, and GPT-6 Astra.
def forced_reasoning(model, problem):
msgs = [system_prompt, user(problem)]
# step 1: force the scratchpad tool
resp = model.call(msgs, tools=[scratchpad], tool_choice="forced_reasoning")
while resp.is_tool_call:
msgs += [resp, tool_result("Received")]
# step 2+: let the model decide
resp = model.call(msgs, tools=[scratchpad], tool_choice="auto")
return resp.final_answer, extract_scratchpads(msgs)
To characterize the extracted traces, they measure output length, zlib compressibility, episode-type distributions, and induced reasoning trees via LCoT2Tree, which turns a trace into a graph with width (max lateral branching), depth (furthest reasoning step), and node count.
On the open-model validation, Forced reasoning recovers most of the native accuracy: DeepSeek-V4-Flash goes from 30.5% (no reasoning) to 73.3% Forced versus 70.0% Native on the MATH set; GLM-5.2 goes 21.4% → 84.3% → 89.9%. Extracted traces show substantial ROUGE overlap with native traces and similar episode composition.
On closed models across MATH (HMMT Nov 2025 plus APEX Shortlist), Humanity’s Last Exam (HLE), and LiveCodeBench, Forced reasoning tracks Native within a few points. For example on MATH: Opus 4.8 85.0 vs 86.3, Sonnet 5 81.3 vs 77.5, Sol 91.3 vs 97.5, Astra 93.8 vs 97.5. The no-reasoning baselines are far lower (Sol at 25.0 on MATH). A control matters here: asking Sol for step-by-step reasoning in ordinary text without the tool only reaches 60.6% on HMMT while the forced tool reaches 93.9%. Something about routing text through a tool argument, rather than the visible response, gets the model to actually reason.
The more interesting finding is behavioral. Astra stands out:
•
Shortest, least compressible traces. Astra has the highest zlib ratio on all three benchmarks, meaning its output has less repetition and filler per token.
•
Narrower reasoning trees at similar depth. Median tree width 5.0 for Astra versus 12.0 (Sol), 22.0 (Opus 4.8), 28.5 (Sonnet 5); median node count 27 versus 60 / 96 / 136. Depths are comparable (~11–13). Astra converges more directly with less branching and backtracking.
•
Same episode repertoire. Astra still does Analyze, Plan, Verify, etc. It just verbalizes fewer intermediate steps per episode, especially routine arithmetic and background facts (e.g., writing 48+18+36=102 without first restating that C, H, O contribute 4, 1, 6 valence electrons).
The transfer experiment gives the sharpest result. When Astra’s traces are handed as context to a recipient model that then answers with native reasoning off, strong recipients recover nearly all of Astra’s accuracy while weaker ones (Claude Haiku 4.5, GPT-5.4-Nano) recover much less. In many failures, Astra’s trace explicitly states the correct answer and the weak recipient still returns something else. For Haiku 4.5, 15 of 18 wrong answers on transplanted Astra traces had the correct answer visible in the input. Traces from Sol and Opus, being less compressed, transfer with little loss to every recipient.
The authors’ proposed explanation, which they carefully mark as a hypothesis: compressed traces omit exactly the elementary steps a weaker reader cannot fill in, so trace explicitness is a variable distinct from teacher strength.
•
If you’re red-teaming a frontier API, this shows that disabling the reasoning channel doesn’t stop reasoning content from leaking. If your product relies on the provider’s claim that “reasoning is hidden,” you should assume a custom tool with forced initial selection can pull equivalent content out. The authors reported this to OpenAI and Anthropic; the newer Claude Opus 5 and Fable models rejected the protocol entirely, so the boundary is starting to close.
•
If you’re doing distillation from a strong teacher, the transfer result is worth taking seriously. A stronger teacher whose traces are heavily compressed may be a worse supervision source for a small student than a middling teacher who writes everything out. Worth testing: expand a compressed trace into its implicit steps before using it as supervision, and see whether student accuracy improves. The paper predicts this but does not measure it.
•
If you’re comparing frontier models beyond benchmark scores, the tree-width and episode-composition analyses give a concrete lens. Two models can score the same and reason very differently in terms of branching, revisiting, and explicit verbalization. The LCoT2Tree pipeline plus the seven-category episode taxonomy is a reusable recipe.
•
Prerequisite that changes the advice: the protocol needs an API that supports custom tools and forced named tool selection and (usually) disabling native reasoning. Endpoints without these controls, and newer Claude models that refuse the pattern, are out of scope.
The authors are explicit that behavioral similarity to native chain-of-thought does not prove the extracted text is the model’s internal reasoning. It may be a plausible reconstruction the model produces when forced to write into an alternative channel. Open-model validation covers only two models. The transfer experiment measures in-context reuse, not fine-tuning, and donor traces differ in correctness, content, and style, so “compression” is not causally isolated as the reason weak recipients fail. Prompt wording matters a lot: Sol responds to “maximal deliberation” wording by writing more, Astra by writing less, so “Forced” is not one fixed effort level. Finally, some Astra runs still show nonzero native reasoning tokens on the final-answer call, so the visible trace is not always the complete story.