Reasoning Models Explained: What Thinking Costs You

A reasoning model is one that pauses to work through a problem step by step before it writes its answer, instead of producing a response in a single pass. That pause — usually called extended thinking or test-time compute — makes it noticeably better at math, code and multi-step logic, and noticeably slower and pricier at everything else. Here's what actually happens in that pause, and how to tell when it's worth paying for.

What "thinking" actually means

A standard model reads your prompt and starts writing the answer immediately, token by token, in one forward pass. A reasoning model does something different first: it generates a block of internal reasoning — exploring an approach, checking it, sometimes backtracking — and only then commits to the final response. One glossary puts it plainly: a reasoning model is "trained to generate an internal chain of thought first — exploring, checking, and revising — before committing to a response, effectively spending more compute at inference time on harder problems."

Anthropic describes its own version of this the same way: the model "uses multiple, sequential reasoning steps before producing its final output, adding more computational resources as it goes." The useful part is that this isn't random extra effort — it's measurable. Anthropic has found that accuracy on tasks like math questions improves logarithmically with the number of thinking tokens the model is allowed to sample. More thinking helps, but with diminishing returns, which is exactly why unlimited thinking isn't the default setting anywhere.

The two-room way to picture it

Some beginners' guides use a simple image: a hidden thinking room where the model works out the problem with no output, followed by a presentation room where it writes the answer you actually see. A standard model only has the presentation room. That's the whole trick — reasoning models don't know more facts, they just check their own work before handing it to you.

What happens before the answer — and what it costs

The thinking step isn't free, even though you never read it. In API terms, those internal reasoning tokens are generated like any other output and counted that way. One pricing breakdown gives a concrete sense of scale: "o-series models generate internal reasoning tokens before producing the visible answer. They are billed as output but never returned. A 300-token answer can carry 2,000 reasoning tokens behind it." That七 ratio — a short visible answer sitting on top of a much longer invisible one — is the core reason reasoning-capable models cost more per message and take longer to respond. The wait you notice before a reasoning model replies is the thinking happening, not the app being slow.

This is also why reasoning isn't something you'd want turned on for every message. One comparison of reasoning versus standard models is blunt about the gap: "For high-throughput, simpler tasks, reasoning model costs can be three to ten times higher than standard LLM equivalents — making task-model matching an important architectural decision." Paying that premium makes sense when the task genuinely needs it, and is just waste when it doesn't.

The tasks it changes — and the ones it doesn't

This is the part worth remembering before you pick a model. Guides on the topic converge on roughly the same short list: math and logic see a clear win, coding sees significant improvement, creative tasks see minimal gain, and simple Q&A is overkill for a reasoning model. The same source adds two caveats that are easy to forget once a model starts "thinking" visibly: reasoning model hallucinations still occur, and the knowledge cutoff still applies. Extended thinking makes a model more careful, not more current and not immune to being wrong.

In practice, that breaks down like this:

Where reasoning earns its cost:

• Debugging a piece of code where the bug isn't obvious from reading it
• Working through a math or logic problem with several dependent steps
• Planning a multi-part task (a document structure, a project breakdown, a data analysis) before producing it
• Catching a subtle error a faster model would confidently get wrong

Where it's wasted:

• Looking up a fact
• Rewriting or summarizing a paragraph
• Casual conversation or quick creative brainstorming
• Anything you could check the answer to in two seconds anyway

Do it in Plurel

Plurel doesn't have a separate "thinking" switch buried in settings — which model you pick from the chat switcher is the toggle. Open the Chat tool (the row under the composer, or go straight to plurel.tech/?model=chat) and choose your model based on how hard the task actually is.

1. For the hardest research, coding or multi-step reasoning task, switch to Claude Opus 5.5 (1.5 credits/message, plurel.tech/?model=claude-opus-5-5) or GPT-6 Astra (2 credits/message, plurel.tech/?model=gpt-6-astra). Both can also read attached files, search the web, and run code as part of working through the problem.
2. Type the actual problem, not a simplified version of it — give it the full code block, the full dataset, the full constraint. Reasoning models do better with the complete picture to check against.
3. If the model's plan involves generating an image or video along the way (both Opus 5.5 and GPT-6 Astra can plan and trigger picture and clip tools), it will show you the plan and credit cost first — you approve before anything is spent.
4. For a routine coding or writing task that doesn't need deep checking, Claude Sonnet 5.5 (1 credit, plurel.tech/?model=claude-sonnet-5-5) or Kimi K3 (1 credit, plurel.tech/?model=kimi-k3) is usually enough and faster.
5. For a quick fact, a one-line rewrite, or anything you'd normally just Google, use GPT-5.6 Luna (0.1 credits) or DeepSeek V4.1 Flash (0.03 credits) — skipping the thinking step is the whole point of those two.

Picking the right model fast

For a closer look at what Opus 5.5 is good at specifically, the Claude Opus 5 prompts guide covers research, code and file tasks with working examples. If your reasoning task leans on live web results rather than pure logic, the Grok 4.6 vs 4.7 search guide explains when search-equipped models beat pure reasoning. And if the output of your reasoning session needs to become an actual file, the AI PDF generator guide shows how chat turns a prompt into a real PDF or spreadsheet.

Troubleshooting and tips

The model seems to be taking a long time to reply. That's expected for Opus 5.5 and GPT-6 Astra on a genuinely hard prompt — the hidden thinking step takes real time. If a short, simple question is taking just as long, switch to Sonnet 5.5 or Luna; you don't need the thinking budget for it.

The answer still has an error. Reasoning reduces certain mistakes but doesn't fix stale knowledge or guarantee correctness — if accuracy matters, ask the model to show its steps and check the one that looks off, rather than trusting the final line blindly.

You're burning credits faster than expected. This usually means a reasoning-capable model is being used for routine messages. Save Opus 5.5 and GPT-6 Astra for the task that actually stalls a faster model, and default to Sonnet 5.5, Luna or DeepSeek Flash for the rest of the conversation.

You want the model to plan a picture or video, not just answer. Ask it directly — Opus 5.5, Sonnet 5.5 and GPT-6 Astra can draft a plan using the image and video tools and will show you the credit cost before anything generates.

Reasoning isn't a smarter model, it's a slower, more careful one — match it to problems that actually have a checkable answer path, and let the fast models handle everything else.