# How Reasoning Traces Work in Language Models

DevFeed: [How Reasoning Traces Work in Language Models](<https://devfeed.tech/articles/what-is-reasoning-30732.md>)

Original publisher: [Read original article](<https://lucumr.pocoo.org/2026/8/19/what-is-reasoning/>)

Author: Armin Ronacher

Published: 2026-08-19T00:00:00Z

Content type: article

Language: en

Sources: [Armin Ronacher](<https://devfeed.tech/sources/armin-ronacher.md>)

Topics: [Chain-of-thought](<https://devfeed.tech/topics/chain-of-thought.md>), [gpt-oss](<https://devfeed.tech/topics/gpt-oss.md>), [Parser](<https://devfeed.tech/topics/parser.md>), [API](<https://devfeed.tech/topics/api.md>), [Cache](<https://devfeed.tech/topics/cache.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [api](<https://devfeed.tech/tags/api.md>), [chain-of-thought](<https://devfeed.tech/tags/chain-of-thought.md>), [gpt-oss](<https://devfeed.tech/tags/gpt-oss.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>), [token](<https://devfeed.tech/tags/token.md>)

## AI overview

The article explains reasoning traces as text emitted by a model into a scratchpad before its final answer. It discusses how GPT-OSS uses channel markers and a parser to route analysis into a separate stream, and argues that reasoning effort is shaped by system prompts and training rather than being solely a sampling-process property.

## Source excerpt

A few weeks ago a paper was shared 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, 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: Reasoning: low 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