What Is a Reasoning Model? How It Differs From a Normal LLM

A reasoning model is an AI model that spends extra computing time generating hidden, step‑by‑step "thinking" before it produces a final answer — rather than predicting the response in one pass the way a standard large language model (LLM) does. OpenAI's o‑series and GPT‑5.6/GPT‑6 "reasoning mode," Google Gemini's "thinking" models, Anthropic Claude's extended/adaptive thinking, and DeepSeek's R1 family are all reasoning models in this sense: each one generates internal reasoning tokens — sometimes a few hundred, sometimes tens of thousands — and that extra "inference‑time compute" is what lets them work through math, code, and multi‑step logic problems that trip up a plain LLM.

What is a reasoning model, exactly?

Every large language model predicts text one token at a time. A standard LLM is trained to go from your prompt almost directly to its answer. A reasoning model is the same basic transformer architecture, but it has been further trained — usually with reinforcement learning — to first generate a private, extended sequence of intermediate steps (OpenAI calls these "reasoning tokens") before it writes the answer you actually see. OpenAI's own developer documentation puts it plainly: reasoning models "use internal reasoning tokens before producing a response," and those tokens help the model plan ahead, break a problem into steps, and try different approaches before committing to one, which is especially useful for tool use and multi‑step tasks.

The industry also calls this family "large reasoning models" (LRMs). Wikipedia's entry on reasoning language models describes them as LLMs "trained to solve tasks that require several steps of logical reasoning," noting they tend to outperform standard LLMs on logic, math, and programming problems and can revisit and revise their own earlier steps mid‑answer — something a one‑pass LLM structurally can't do.

Reasoning model vs. LLM: what's actually different

Every reasoning model is an LLM, but not every LLM is a reasoning model. The distinction that matters in 2026 is really reasoning model vs. non‑reasoning model, since both are built on the same underlying architecture:

• A non‑reasoning (standard) LLM generates its answer directly from the prompt. It's fast and cheap, and for straightforward tasks — a summary, a quick lookup, simple formatting — that's all you need. OpenAI has described GPT‑4.5 as its "last non‑chain‑of‑thought model," a useful marker of where the industry drew the line between the two eras.
• A reasoning model inserts a hidden deliberation phase first. It can be wrong less often on problems with a clear right answer (math, logic puzzles, debugging, multi‑step planning), but it's slower and more expensive per answer, because you're paying for tokens the model generates before you see anything.

In practice, the two aren't always separate products anymore — which is where "hybrid reasoning model" comes in (more on that below).

Reasoning tokens and "inference‑time compute," demystified

The technical idea behind all of this is inference‑time compute (also called test‑time compute): instead of only making a model smarter by training it on more data, you make it smarter at answer‑time by letting it "think" longer before it responds. OpenAI's reasoning guide confirms the mechanics directly: reasoning tokens "still occupy space in the model's context window and are billed as output tokens," and a single query "may generate anywhere from a few hundred to tens of thousands of reasoning tokens" depending on how hard the problem is. You don't normally see that raw internal reasoning — OpenAI's API keeps it hidden and offers only an optional summary — but you do pay for it, and it does count against your context window, which is why OpenAI recommends reserving at least 25,000 tokens of headroom for reasoning plus output when you're starting out with these models.

Anthropic's Claude documentation uses the same underlying mechanic under a different name — "extended thinking" — and is explicit that it's a tunable resource: you set a budget_tokens target (minimum 1,024 tokens) for Claude's internal reasoning process on a given request, and "larger budgets can improve response quality by allowing more thorough analysis for complex problems." Google's Gemini thinking documentation describes "dynamic thinking," where the model automatically adjusts "the amount of reasoning effort based on the complexity of the request" — so a simple question gets a short thinking pass and a hard one gets a long one, without you having to ask for it.

How reasoning models show up in ChatGPT

When people search "what is a reasoning model in ChatGPT," they're usually running into OpenAI's o‑series (o1, o3, o4‑mini and successors) or the reasoning mode built into GPT‑5‑class and GPT‑6 models. OpenAI's developer docs describe a reasoning.effort parameter that controls how hard the model thinks, with supported values ranging from none or minimal up through low, medium, high, and on the newest GPT‑5.6/GPT‑6 models as high as xhigh or max. "Lower effort favors speed and lower token usage," the docs note — so ChatGPT users picking a faster vs. "thinks longer" mode are really just picking a point on that same effort scale. GPT‑5.6 and GPT‑6 also separately expose a standard vs. pro reasoning mode, where pro "does more model work," independent of the effort setting.

This lines up with OpenAI's original framing for the o1 line in its 2024 research post "Learning to Reason with LLMs": the model's accuracy on hard benchmarks rose as it was allowed to use more compute, both during its training and at the moment it answers a question — the founding example of inference‑time compute scaling in a shipping consumer product.

Gemini's "thinking" models

Google's equivalent is built directly into the Gemini API rather than offered as a separate product line. Per Google's own thinking documentation, thinking is on by default for current Gemini models, and you can control how much effort it spends with a thinking_level parameter (typical values: minimal, low, medium, high, depending on the model). Defaults vary by model — some default to medium, Google's higher‑end preview models default to high, and at least one lightweight model ships with thinking off by default. As with OpenAI and Anthropic, "when thinking is turned on, response pricing is the sum of output tokens and thinking tokens" — you're billed for the full internal reasoning the model generates, even though the API usually returns only a summary of it, not the raw transcript.

Claude's extended thinking — and what "hybrid reasoning model" means

Anthropic is the company that popularized the term hybrid reasoning model. When it launched Claude 3.7 Sonnet, Anthropic described it as a single model that can either answer near‑instantly or "think longer before answering," with the user (or developer) choosing per request — a genuine hybrid of a standard LLM and a reasoning model in one checkpoint, rather than two separate models. That thinking process was made visible to the user as a "scratchpad," and API developers could set a thinking budget of up to 128K output tokens to trade latency and cost for answer quality.

Anthropic's current API documentation shows this is still evolving: on older Claude 4‑generation models, you set a manual budget_tokens value; on Claude 4.7 and later, that manual mode is retired in favor of adaptive thinking, where Claude itself "determines whether and how much to think on each request," steered by an effort setting (low/medium/high) instead of a hard token count. At low effort, Anthropic's docs note, the model "might skip thinking entirely on easy inputs" — which is exactly the hybrid behavior the "reasoning vs. non‑reasoning" question is getting at: the same model moves between the two modes automatically.

DeepSeek‑R1: the reasoning model that's open enough to inspect

DeepSeek's R1 family, documented in the company's own GitHub repository and research paper, is the clearest public case study of how a reasoning model gets built, because DeepSeek published the recipe. DeepSeek‑R1‑Zero was trained with large‑scale reinforcement learning applied directly to a base model, with no supervised chain‑of‑thought examples at all — and the paper reports that behaviors like self‑verification, reflection, and long chain‑of‑thought generation emerged from the RL process itself. DeepSeek‑R1 then builds on that by adding a small amount of "cold start" chain‑of-thought data before running two further rounds of reinforcement learning (using DeepSeek's GRPO algorithm) and supervised fine‑tuning, specifically to fix R1‑Zero's rough edges: endless repetition, poor readability, and language mixing.

DeepSeek's own published benchmark table reports DeepSeek‑R1 scoring 79.8 on AIME 2024 (Pass@1) and 97.3 on MATH‑500 — describing performance "comparable to OpenAI‑o1" on math, code, and reasoning tasks. The full R1 model runs on a 671‑billion‑parameter mixture‑of‑experts architecture (37B active per token, the same approach Pandromeda has covered in our explainer on mixture‑of‑experts models), and DeepSeek also released six smaller distilled models — down to 1.5B parameters — trained on reasoning traces generated by the full R1, so some of that reasoning behavior survives in much cheaper models. R1 is released under an MIT license, making it one of the few flagship reasoning models anyone can download and run.

Non‑reasoning model vs. hybrid reasoning model: the short version

How the four vendors' reasoning controls compare

Why reasoning models cost more — and when that's worth it

Because reasoning tokens are billed as output tokens across every vendor covered here, a reasoning model's bill for the exact same question can be several times higher than a standard LLM's, even when the visible answer is the same length. That's the direct tradeoff the "effort," "thinking_level," and "budget_tokens" controls exist to manage: you're buying accuracy on hard problems by spending tokens the end user never reads. It's also why hybrid reasoning models matter commercially — they let one deployment serve both a quick customer‑support reply and a hard debugging request without maintaining two separate models or routing logic, with the context window absorbing both the hidden reasoning and the final answer.

This is also the control an AI agent builder has to get right: an agent that calls a reasoning model at every tool‑use step will reason — and pay — more than one that only escalates to high‑effort reasoning when a task actually needs it.

When you actually need a reasoning model

• Use a reasoning model (or high effort) for: multi‑step math, debugging non‑trivial code, planning a sequence of tool calls, verifying its own earlier output, or any task with a checkable right answer.
• Use a standard LLM (or low/minimal effort) for: drafting, summarizing, formatting, casual conversation, or any task where speed and cost matter more than squeezing out the last few points of accuracy.
• Let a hybrid model decide: if your traffic is a mix of both and you don't want to build routing logic yourself, a hybrid reasoning model with dynamic or adaptive thinking (Claude's adaptive mode, Gemini's dynamic thinking) is built to make that call per request. DeepSeek's smaller distilled R1 models are a budget option here, trading some accuracy for dramatically lower cost — useful background if you're also weighing something like our DeepSeek vs. Qwen comparison.

What to do next

If you're choosing a model for a specific task, start by checking whether the provider's own documentation lists an effort or thinking‑budget control for the model you're using — OpenAI, Google, and Anthropic all expose one, and it's the single biggest lever for balancing answer quality against cost and latency. For open, inspectable reasoning behavior, DeepSeek's published R1 recipe and distilled models remain the most transparent reference point in the field. And if you're building anything that calls these models programmatically, budget tokens for the hidden reasoning pass — not just the visible answer — when you're sizing context windows and API costs.

Written byTheo Park

Theo Park runs the AI desk at Pandromeda. He follows model launches from the frontier labs and the open-weight community, tracks the assistants and developer tools built on them, and explains what each release changes on pricing, capability and safety. His reporting leans on primary sources: model cards, technical reports, API documentation and the companies' own announcements.

More from Theo ParkAll AI coverage