What Are Reasoning Models? Extended Thinking, Explained
Reasoning models think before they answer, spending extra compute on hard math, code, and planning. Here is when that thinking earns its keep and when it just burns time and money.
Ask a normal model a hard question and it starts typing almost immediately. Ask a reasoning model the same thing and it pauses, sometimes for ten or twenty seconds, working through the problem in a scratchpad you usually never see. That pause is the whole point. What are reasoning models? They are models that spend extra compute thinking before they answer, and on the right kind of problem that thinking is the difference between a confident wrong answer and a correct one.
The catch is that the same pause makes them slower and more expensive. The question worth asking is practical: does the problem in front of you actually reward the extra thinking, or are you paying for a model to stew over something it would have nailed on the first pass anyway?
What is a reasoning model, exactly
A reasoning model generates intermediate "thinking tokens" before it produces the visible answer. Instead of predicting the response in one shot, it works through the problem step by step, checks itself, sometimes backtracks, and only then writes the reply. The industry term for this is test-time compute, also called inference-time compute: the model does more work at the moment you ask, rather than relying purely on what it learned during training.
That extra work measurably strengthens performance on math, code, and multi-step planning, at the cost of being slower and pricier per answer. The thinking tokens are real tokens that get generated and billed, even when they are hidden from you. Output tokens are the expensive part of any model call, so a model that quietly writes two thousand tokens of reasoning before a three-sentence answer is doing far more billable work than the answer alone suggests.
It helps to separate two things. A regular model gives you fast pattern-matched output. A reasoning model gives you a deliberate chain of work first. Most frontier providers now ship reasoning as a mode or a tier rather than a separate product, which is why you increasingly see one model that can run with thinking turned up or turned off.
Extended thinking and Deep Think, decoded
The vocabulary varies by vendor, which makes the whole category sound more mysterious than it is. "Extended thinking" generally means letting a model spend a larger budget of reasoning tokens on a single response. More budget, more room to work through a tricky derivation or trace a bug across several files.
"Deep Think" style modes go a step further. Rather than following one chain of reasoning, they explore several hypotheses in parallel and compare them before settling on an answer. Google markets a Deep Think tier on its Gemini Pro line built around this parallel-exploration idea. The promise is that a problem with multiple plausible paths gets several of them tried at once instead of the model committing early to the first route that looked good.
Both ideas trade time and money for depth. Extended thinking widens a single lane. Deep Think opens several lanes. Neither makes an easy question easier, and that is the part people miss.
When reasoning actually helps
The honest answer is that the payoff is concentrated. Reasoning effort helps most on hard math and coding benchmarks, where accuracy climbs noticeably as the model is allowed to think more. On simpler tasks and many other domains, the gain is small or negligible. Think of it as buying depth on a narrow band of genuinely hard problems rather than a smarter model across the board.
Reach for a reasoning model when the work looks like this:
Hard, multi-step math where one slip early ruins the final answer. Proofs, derivations, word problems with several constraints.
Multi-step or cross-file code: tracing a bug through several modules, refactoring with dependencies, or reasoning about edge cases a quick pass would skip. This is where extended thinking earns its slot in a coding workflow.
Planning and decomposition: breaking an ambiguous goal into ordered steps, weighing tradeoffs, or sequencing work where the order matters.
Reasoning over long documents: pulling a conclusion from facts scattered across a large input, not just retrieving a single line.
That last case deserves a flag. A big input does not guarantee good reasoning over it. Artificial Analysis built a long-context reasoning evaluation across multiple documents of ten thousand to a hundred thousand tokens, and even frontier models score well below their headline numbers, with the hardest subset sitting far lower still. Their stated rationale is blunt: a large context window does not guarantee that a model can reason effectively over long documents. So reasoning effort helps on long, hard tasks, but do not assume the model has it handled just because everything fit in the window. The mechanics of why that breaks down live in our explainer on the AI context window.
When it just burns time and money
Here is where the measured view matters. Turning thinking up is not free, and on the wrong task it is pure waste. A reasoning model asked to reformat a list, classify a sentence, or answer a factual lookup will generate a pile of unnecessary reasoning tokens, take longer, and hand back the same answer a fast model would have given instantly.
Worse, more thinking can actively hurt. "Overthinking" is a documented failure mode: at high reasoning budgets a model can talk itself out of a correct answer, with diminishing and sometimes negative returns. Researchers have written up cases where extended reasoning leads a model to abandon a previously right conclusion. So the curve is not "more thinking, more accuracy, forever." It rises, flattens, and on some problems bends back down.
Skip the deep reasoning when the task is:
Latency-sensitive, like a back-and-forth chat or a voice turn where a slow reply kills the flow.
Simple and pattern-based: summaries, rewrites, classification, formatting, quick factual answers.
High volume, where every extra second and every extra thousand tokens multiply across thousands of calls.
How reasoning effort controls map to all this
Most reasoning models expose a dial rather than an on-off switch. OpenAI's reasoning-effort control, for example, supports values that can include none, minimal, low, medium, high, and an xhigh setting on some models. Lower effort favors speed and fewer tokens. Higher effort buys deeper, higher-quality responses on problems that can use them.
OpenAI's own guidance is a clean rule to borrow. Treat medium as the balanced default. Reserve none or minimal for latency-critical work that does not need reasoning at all, like fast retrieval, classification, or lightweight voice turns. Push up to high or xhigh only when your own testing shows a measurable quality gain worth the extra latency and cost. Start in the middle and move with evidence, rather than defaulting to maximum thinking and hoping.
Effort | Good for | Tradeoff |
|---|---|---|
None / minimal | Chat, classification, fast lookups, voice | Fastest, cheapest, weak on hard problems |
Medium | Most real work, the safe default | Balanced speed and depth |
High / xhigh | Hard math, gnarly bugs, complex planning | Slowest, priciest, risk of overthinking |
MultiChats puts this dial right in the chat on paid plans. The reasoning effort control offers Auto, Low, Medium, High, and Off, so you can match the setting to the task without leaving the conversation. Drop it to Low for a quick rewrite, push it to High when you hand a model a real proof or a cross-file refactor. We go deeper on the practical settings in our guide to reasoning effort control.
Because you can switch models mid-conversation, the workflow gets even simpler. Plan a hard task with a top reasoning model at high effort, then drop to a fast model for the routine follow-ups. If your main use is shipping code, the same logic drives our picks in the rundown of the best AI app for coding.
Which models do this well
Reasoning is now table stakes at the frontier. Claude Opus 4.8 leads the Artificial Analysis Intelligence Index at 61.4 as of late June 2026, with strong gains in scientific reasoning and on hard coding benchmarks like Terminal-Bench Hard. GPT-5.5 at its xhigh setting sits just behind at 60.2 on the same index. Anthropic has since released Claude Opus 5, and it is available on MultiChats alongside Opus 4.8. Google also ships a Deep Think parallel-exploration mode for Gemini, though that lives in Google's own paid tier. When reasoning effort decides the outcome, the Opus models and GPT-5.5 are the names to reach for.
The numbers are close enough that the better question is which one fits your task rather than which one tops a leaderboard by a point. We break down the two front-runners head to head in Claude Opus 4.8 vs GPT-5.5. The practical advantage of a multi-model app is that you do not have to pick once. You run the same hard prompt through Opus and GPT, compare the reasoning, and keep the better answer.
Frequently asked questions
What is a reasoning model?
A reasoning model is one that generates intermediate thinking tokens before its visible answer, spending extra inference-time (test-time) compute to work a problem through step by step. That deliberate process strengthens results on math, code, and multi-step planning, at the price of being slower and more expensive than a standard model that replies in one pass.
Are reasoning models always better?
No. The benefit is concentrated on hard math and coding tasks, where accuracy climbs with more thinking. On simple or pattern-based work the gain is small or zero, and at very high reasoning budgets a model can overthink and abandon a correct answer. For easy and latency-sensitive tasks, a fast model is the better tool.
When should I use extended thinking?
Use it when one early mistake would ruin the result: hard derivations, cross-file debugging, complex planning, or reasoning over a long document. Start at a medium setting, then raise it only when your own testing shows a clear quality gain worth the added wait. For quick chat, rewrites, and lookups, keep effort low or off.
Do reasoning models cost more?
Generally yes, because the hidden thinking tokens are real output tokens that get generated and billed, and output tokens are the costly part of any model call. A reasoning answer can burn many times the tokens of a direct one. On MultiChats there is no per-token provider bill, and turning up the effort dial (a paid-plan control) adds no extra charge: the call simply draws on your plan's message credits like any other.
The short take
Reasoning models are a real upgrade on a specific class of problem and a slow, costly detour on everything else. Treat the thinking as a tool you point at hard math, multi-step code, and genuine planning, and keep it off the easy stuff. Medium effort as your default, high when the answer has to be right, low or off when speed wins. Get that mapping right and the wait pays for itself only when you actually needed it.
MultiChats gives you the top reasoning models, GPT-5.x, Claude, and Gemini among 25+ models, plus a built-in reasoning effort dial, for one subscription. Run your hardest problems through MultiChats and let the results decide which model earns the slot.