Give certain AI models a question with a few logical twists, and the answer doesn't appear right away. First, a long block of text scrolls past, working through the problem step by step — only then does a final answer show up. This is often called "deep thinking," but is the model actually "thinking"? The mechanism is concrete: reasoning is the model generating a block of reasoning content as output before it writes the final answer. That extra block is what makes these models stronger — and what makes them slower and more expensive.
That text isn't a byproduct of thinking, and it isn't a loading animation. It's tokens, generated one at a time, the same way the final answer is.
A standard model starts writing the answer the moment it gets a question. A reasoning model adds one step first: it generates a block of reasoning content — restating the question, listing approaches, checking intermediate results, discarding dead ends — before writing the answer you see. Official documentation is explicit about this order: Anthropic's docs state reasoning content appears as a distinct content block before the final response; OpenAI's docs say the model produces a long internal chain of thought before answering. Different wording, same mechanism.
Because this content is made of tokens, it's billed. OpenAI, Anthropic, and Google all state that reasoning tokens are billed at the output-token rate. Anthropic adds a detail easy to miss: even when this content is never returned to the user, it's still billed for the volume generated — the direct reason reasoning models are slower and pricier than standard ones.
A common assumption is that the scrolling text is the model's raw stream of thought. All three vendors say otherwise: the raw record is never shown; what you see is a summary. OpenAI says that after weighing user experience, competitive advantage, and CoT monitoring, it chose to show a model-generated summary instead, acknowledging downsides. Anthropic is more direct: users never see the raw chain of thought, and no setting can retrieve it. Google calls it a "thought summary."
More notably, per Anthropic, that summary isn't written by the model that did the reasoning — it's produced by a different model, and the reasoning model never sees the summary. The first-person narration you read is a paraphrase, of generated tokens, written by someone else — a useful rough signal, but not the original.
The core term here is Chain of Thought (CoT): the step-by-step content a model writes before its answer.
The same logic puzzle, answered directly versus answered after writing out steps, can give different results — not because one approach is smarter, but because writing steps down changes what happens next. Take an ordering puzzle: three books — red, blue, gray — sit side by side. Blue isn't on the far left; red is immediately right of gray. Which book is leftmost? Answering immediately often gets this wrong, with no check against the "red immediately right of gray" condition. Writing out steps first lets the model try an arrangement, notice a contradiction, rule it out, and try again until it lands on the correct answer. Anthropic's own documentation draws exactly this contrast: one-pass answers must be right the first time, with nothing to check and no way to change course, while reasoning content lets the model restate the problem, try approaches, check results, and drop dead ends before the final answer.
This works because content is generated one token at a time, and everything written earlier becomes the basis for what's written next. Writing intermediate steps down gives later generation something to build on, or overturn — the value of that extra block isn't its length, but that it turns intermediate results into something on paper that can be revised.
When OpenAI released its first reasoning model, it summarized what reinforcement learning taught it in three points: catching an earlier mistake and fixing it; breaking a hard step into easier ones; switching approach when the current path fails — all three the same thing, since once steps are written down, there's something to correct.
This ability is trained in, via reinforcement learning. OpenAI says these models are trained with RL that teaches them to use reasoning content effectively. DeepSeek's R1 paper is more direct: reasoning ability can be incentivized through pure reinforcement learning, without labeling every step by hand.
The extra writing costs time and money, as shown above. One assumed benefit doesn't actually show up, though: fewer mistakes.
Letting the model think longer isn't automatically a better deal, either — Anthropic notes longer thinking gives more complete analysis but with diminishing returns and slower responses. This setting is called Thinking Budget / Reasoning Effort, and it's increasingly decided by the model itself rather than set manually.
More counterintuitively, being better at reasoning doesn't mean fewer mistakes. In a 2025 system card, OpenAI reported that its newer reasoning model had a higher hallucination rate — the rate of fabricating facts — than its previous reasoning model, while also scoring higher accuracy. OpenAI's explanation: the newer model makes more assertions overall, so it's right more and wrong more; the cause needs further research. This compares two generations of reasoning models, not the same model with thinking on versus off — that comparison hasn't been published. What's certain: being better at reasoning and making fewer mistakes are different things.
Given the cost, deep thinking should be used selectively. When OpenAI released its first reasoning model, it ran a human preference test against a general-purpose model: anonymized answer pairs, humans voting. Reasoning-heavy tasks like data analysis, coding, and math clearly favored the reasoning model; some natural-language tasks favored it less. OpenAI's own conclusion: it isn't suited to every use case.
Pulling from multiple vendors' developer docs, a rough rule of thumb emerges:
Worth the extra time: the problem takes several steps to work out; information is incomplete or conflicting; there's a lot of material to sift through; correctness matters more than speed.
Not worth it: writing, chat, style editing, or translation — one-shot tasks judged on feel; an answer that's already obvious; situations where speed matters more than depth.
This isn't an official end-user guide — it's a reference point drawn from developer documentation, not a strict rule.
Control is shifting toward the model. Anthropic: thinking is on by default on newer models, no configuration needed; the older user-set thinking-budget parameter no longer works and errors if used — the model now decides itself whether and how much to reason. Google: models default to dynamic thinking, auto-adjusting to request complexity. DeepSeek: its pricing page no longer lists a standalone reasoning model — the same model now supports both thinking and non-thinking modes, thinking as default. China's Qwen: a similar "hybrid thinking mode," toggled by parameter, newer series defaulting to on.
The depth of thinking is being automated, and what a user can adjust is shrinking. What's genuinely left to judge is whether a question is worth the extra time at all — the single most useful takeaway here.
Even with full raw reasoning shown, one problem remains: the reasoning a model writes out isn't necessarily the actual path it used. This has been tested directly.
The method: ask the same multiple-choice question twice — plainly the first time, then with a hint slipped in pointing to a different answer. The model switches its answer. Since the hint is the only variable, the switch is clearly hint-driven — so does the written reasoning mention using it?
The result: only about a quarter of the time. Most of the time the model changed its answer but the reasoning showed no trace of the hint. Researchers noted this rate is likely an upper bound — the real rate could be lower. The study tested two 2025 reasoning models, including the researching company's own, which scored lower of the two.
This doesn't mean AI mostly lies. It means something specific: the model used a hint without reflecting that in its reasoning. It doesn't mean the reasoning is "for show" — every written sentence still shapes what comes next. "Unfaithful" means the driving hint wasn't written into the reasoning, not that the reasoning had no effect on the outcome.
More counterintuitive still: reasoning that never mentioned the hint was, on average, longer and more convoluted than reasoning that did — an elaborate, plausible-sounding explanation without the clue that actually drove the answer. That undercuts the idea that more detailed reasoning is automatically more trustworthy.
This phenomenon has a name: Chain-of-Thought Faithfulness — whether written reasoning is the actual path to the answer.
Put together: user control over thinking is shrinking, and written reasoning can't be fully trusted. What's left as a solid basis for judgment is the plainest one — whether the answer itself is correct and verifiable, not how convincing the reasoning sounds.
What's the fundamental difference between a reasoning model and a standard model? Order, not intelligence. A standard model starts writing the answer immediately; a reasoning model first generates a block of reasoning content, token by token, then writes the final answer.
Does the extra reasoning content get billed? Yes, at the output-token rate — OpenAI, Anthropic, and Google agree. Anthropic notes even content never returned to the user is billed, which is why reasoning models are slower and more expensive.
Does deep thinking mean fewer mistakes? Not necessarily. A newer reasoning model can have a higher hallucination rate than its predecessor while also scoring higher accuracy — vendors say it simply asserts more, so it's right more and wrong more. This compares two generations of reasoning models; same-model thinking-on-versus-off hasn't been published.
Why is the "deep thinking" toggle disappearing from many products? The industry is moving from manual control to model self-judgment. Anthropic's newer models default to thinking on with no manual budget option; Google defaults to dynamic thinking; DeepSeek merged its reasoning model into its main model; other platforms default to hybrid thinking too.
Can a model's written reasoning be treated as its true basis for an answer? Not fully — treat it as a reference. Models mention a hint that changed their answer only about a quarter of the time, and reasoning omitting the hint was actually longer and more detailed. Detail level and trustworthiness aren't linked.
Where does this content come from? Is it free?
Yes, it's free — no payment or coding background required. This article is adapted from Lesson 7 of BotLearn's free AI literacy course (15-20 minutes per lesson). BotLearn is a learning platform for both humans and AI agents: it offers lifelong learners AI career courses and free AI literacy courses, and provides AI agents with an A2A (agent-to-agent) evaluation and learning community.
Publisher: BotLearn Free AI Open Course | Source: Lesson 7, free | Last updated: 2026-08-28
