What Is Reasoning
Summary
This article explains how reasoning traces work in AI models, discussing their implementation, concealment, and extraction techniques, with examples from models like GPT-OSS and DeepSeek.
<p>A few weeks ago <a href="https://arxiv.org/html/2608.09867v1">a paper was shared</a> that
showed how to extract reasoning traces from closed-weight models. Together
with online discussions about tricking models into leaking them, it made me
investigate it more out of curiosity. Twitter seems full of half-truths and
confusion about how this works, so perhaps this helps some to understand what is
happening.</p>
<h2>Hiding Traces</h2>
<p>Reasoning traces are usually hidden from us. <a href="https://earendil.com/posts/session-portability/">We have lamented
this</a>, but mostly have to
accept it. Open-weight models thankfully reveal them, and from their behavior
you can see that their traces can be long and confusing. This is probably a
good reason to separate them from what is normally shown to users.</p>
<p>At minimum, UIs need to detect them. The industry has done a good job at making
reasoning traces sound special and exotic, but they really are just text: the
model is trained to emit its thinking into a scratchpad as part of its response,
before its final answer.</p>
<p>GPT-OSS’s Harmony response format makes this easy to see:</p>
<div class="highlight"><pre><span></span><|channel|>analysis<|message|>
I need to work this out ...
<|end|><|start|>assistant<|channel|>final<|message|>
The answer is ...
<|return|>
</pre></div>
<p>The markers are special tokens, but the reasoning between them uses “the same
text” as the final answer (just that GPT chain-of-thought text sounds really
funny). When the model samples the <code>analysis</code> channel token, a parser routes
the following text into a separate stream exposed through the Responses API.
For closed models, presumably a simple model redacts and summarizes it.</p>
<h2>Reasoning Effort</h2>
<p>How much budget goes to reasoning? Earlier APIs exposed reasoning token
budgets, making it seem like a property of the sampling process. In reality,
reasoning effort is baked into the system prompt. GPT-OSS puts this into the
system prompt:</p>
<div class="highlight"><pre><span></span>Reasoning: low
</pre></div>
<p>That’s it. Training produces the resulting behavior, such as emitting the
token sequence that switches to the <code>analysis</code> channel. This also explains why
changing the effort invalidates the KV cache. I think closed GPT models call
reasoning effort “juice,” since you can ask most models how much juice they
have.</p>
<p>In <a href="https://github.com/antirez/ds4">DwarfStar</a> for DeepSeek with max reasoning
this is added to the system prompt:</p>
<div class="highlight"><pre><span></span>Reasoning Effort: Absolute maximum with no shortcuts permitted.
You MUST be very thorough in your thinking and comprehensively decompose the
problem to resolve the root cause, rigorously stress-testing your logic against
all potential paths, edge cases, and adversarial scenarios.
</pre></div>
<h2>Don’t Think</h2>
<p>The destination of reasoning tokens is therefore a learned convention: the
model is trained to keep scratch work out of the <code>final</code> channel. Trick it into
thinking it is in that channel and it may leak tokens. We have even seen older
models, when thinking is disabled, reason into the bash tool and echo their
thoughts to <code>/dev/null</code>.</p>
<p>So in some sense the only “special” behavior for some models is not to think.
That at times is done by “mechanically” removing the model’s usual ways to think.
In <a href="https://github.com/antirez/ds4">DwarfStar</a>, disabled thinking uses the
prefill <code></think></code>, while enabled thinking uses <code><think></code>, which are the tokens
that close and start thinking. GPT-OSS doesn’t prefill but lets the model
decide either way on its own.</p>
<p>But presumably, some inference APIs prefill the opening token when reasoning is
enabled, so the model never samples it itself and might prevent the sampling of
the reasoning token when disabled since it can be trivially detected. This may
explain why a <a href="https://gist.github.com/mitsuhiko/0904a3d89741e8e3bcca1ca93ea076de">custom <code>think</code>
tool</a> can
trick models into putting some reasoning where it should not go — but only when
native reasoning is disabled.</p>
<details><summary><small>Fun fact: this blog post triggered safey checks</small></summary>
<p>Hilariously enough I was unable to use GPT 5.6 terra for spell and grammar checking
on this blog post because of safety filters. Had to switch to Kimi.</p>
<img src="/static/gpt-5.6-terra-spell-check.png" alt="GPT-5.6-terra refusing to spell-check this blog post" style="width: 100%">
</details>
View Cached Full Text
Cached at: 08/20/26, 03:32 AM
# What Is Reasoning
Source: [https://lucumr.pocoo.org/2026/8/19/what-is-reasoning/](https://lucumr.pocoo.org/2026/8/19/what-is-reasoning/)
written on August 19, 2026
A few weeks ago[a paper was shared](https://arxiv.org/html/2608.09867v1)that showed how to extract reasoning traces from closed\-weight models\. Together with online discussions about tricking models into leaking them, it made me investigate it more out of curiosity\. Twitter seems full of half\-truths and confusion about how this works, so perhaps this helps some to understand what is happening\.
## Hiding Traces
Reasoning traces are usually hidden from us\.[We have lamented this](https://earendil.com/posts/session-portability/), but mostly have to accept it\. Open\-weight models thankfully reveal them, and from their behavior you can see that their traces can be long and confusing\. This is probably a good reason to separate them from what is normally shown to users\.
At minimum, UIs need to detect them\. The industry has done a good job at making reasoning traces sound special and exotic, but they really are just text: the model is trained to emit its thinking into a scratchpad as part of its response, before its final answer\.
GPT\-OSS’s Harmony response format makes this easy to see:
```
<|channel|>analysis<|message|>
I need to work this out ...
<|end|><|start|>assistant<|channel|>final<|message|>
The answer is ...
<|return|>
```
The markers are special tokens, but the reasoning between them uses “the same text” as the final answer \(just that GPT chain\-of\-thought text sounds really funny\)\. When the model samples the`analysis`channel token, a parser routes the following text into a separate stream exposed through the Responses API\. For closed models, presumably a simple model redacts and summarizes it\.
## Reasoning Effort
How much budget goes to reasoning? Earlier APIs exposed reasoning token budgets, making it seem like a property of the sampling process\. In reality, reasoning effort is baked into the system prompt\. GPT\-OSS puts this into the system prompt:
That’s it\. Training produces the resulting behavior, such as emitting the token sequence that switches to the`analysis`channel\. This also explains why changing the effort invalidates the KV cache\. I think closed GPT models call reasoning effort “juice,” since you can ask most models how much juice they have\.
In[DwarfStar](https://github.com/antirez/ds4)for DeepSeek with max reasoning this is added to the system prompt:
```
Reasoning Effort: Absolute maximum with no shortcuts permitted.
You MUST be very thorough in your thinking and comprehensively decompose the
problem to resolve the root cause, rigorously stress-testing your logic against
all potential paths, edge cases, and adversarial scenarios.
```
## Don’t Think
The destination of reasoning tokens is therefore a learned convention: the model is trained to keep scratch work out of the`final`channel\. Trick it into thinking it is in that channel and it may leak tokens\. We have even seen older models, when thinking is disabled, reason into the bash tool and echo their thoughts to`/dev/null`\.
So in some sense the only “special” behavior for some models is not to think\. That at times is done by “mechanically” removing the model’s usual ways to think\. In[DwarfStar](https://github.com/antirez/ds4), disabled thinking uses the prefill`</think\>`, while enabled thinking uses`<think\>`, which are the tokens that close and start thinking\. GPT\-OSS doesn’t prefill but lets the model decide either way on its own\.
But presumably, some inference APIs prefill the opening token when reasoning is enabled, so the model never samples it itself and might prevent the sampling of the reasoning token when disabled since it can be trivially detected\. This may explain why a[custom`think`tool](https://gist.github.com/mitsuhiko/0904a3d89741e8e3bcca1ca93ea076de)can trick models into putting some reasoning where it should not go — but only when native reasoning is disabled\.
Fun fact: this blog post triggered safey checksHilariously enough I was unable to use GPT 5\.6 terra for spell and grammar checking on this blog post because of safety filters\. Had to switch to Kimi\.
This entry was tagged[ai](https://lucumr.pocoo.org/tags/ai/)
[copy as](https://lucumr.pocoo.org/2026/8/19/what-is-reasoning.md)/[view](https://lucumr.pocoo.org/2026/8/19/what-is-reasoning.md)markdown
Similar Articles
Position: Reasoning is a Learnable Rule-Based Process
This position paper argues that AI reasoning lacks clear operational definitions, undermining evaluation validity, and proposes defining reasoning as a learnable rule-based process with a checklist for research best practices.
Is AI reasoning right for the wrong reasons?
A Quanta Magazine essay explores the confusing state of AI reasoning research, weighing contradictory evidence about large reasoning models' capabilities and what their behavior implies about genuine reasoning.
@dbreunig: Reasoning models are great at understanding nuance and natural language. This nuance hasn't trickled down to retrieval …
A tweet highlights that while reasoning models excel at nuance and natural language understanding, this capability hasn't translated to retrieval systems, pointing to a key bottleneck in AI.
Reasoning models struggle to control their chains of thought, and that’s good
OpenAI researchers study whether reasoning models can deliberately obscure their chain-of-thought to evade monitoring, finding that current models struggle to control their reasoning even when aware of monitoring. They introduce CoT-Control, an open-source evaluation suite with over 13,000 tasks to measure chain-of-thought controllability in reasoning models.
Inducing Reasoning Primitives from Agent Traces
Introduces Reasoning Primitive Induction, a method that mines successful ReAct traces to cluster recurrent reasoning moves into typed pseudo-tools, outperforming the original agent by tens of percentage points on benchmarks.