Thinking models
Models that think before answering. You pay for the thinking, and can't read it.
Reasoning models spend extra compute at question time, producing hidden chain-of-thought before the answer. That trade buys real accuracy on multi-constraint problems, ambiguous documents, code and maths — and buys nothing on summarising, rewriting or classification. The thinking tokens are billed at output rates and are usually invisible, so the wrong default setting quietly multiplies your bill.
You need this when
- Multi-constraint planning: rosters, routing, pricing rules that interact — where one missed constraint costs real money.
- Ambiguous documents: contracts, tenders, insurance policies where clause 4 silently overrides clause 11.
- Code, spreadsheets and maths: anything with a verifiable right answer you can check afterwards.
You can skip it when
- Summarising and rewriting — no chain to reason about. Use a cheap non-reasoning model (GPT-5.4-nano at $0.20/$1.25 per 1M).
- Ticket tagging and classification at volume — reasoning adds latency and overthinking. Use a small model plus a fixed label list.
- Anything you need to defend to an auditor on the strength of the trace — traces are unreliable. Log inputs, retrieved sources and model version instead.
The long version
What it is — in one coffee-break
A thinking model writes out a private working-out before answering. You send one prompt; internally it produces hundreds or thousands of thinking tokens — candidate approaches, self-corrections, dead ends — then writes the answer you see. The term is test-time compute: instead of a bigger model, you buy more compute at the moment of the question.
Two consequences hit your invoice. Thinking tokens bill as output tokens on every major platform — Anthropic says so explicitly, and Google and OpenAI meter them the same way. And you usually cannot read them: Anthropic returns summarised thinking blocks, OpenAI bills reasoning tokens it never sends. You pay output rates for text you cannot inspect or reuse.
When you actually need it (and when you don't)
Reasoning pays when the answer depends on holding several constraints together at once. Rostering six people across three sites with holiday rules. Reconciling an invoice against a contract with tiered pricing and a retro discount. Debugging code. Reading a contract where clause 4 quietly overrides clause 11. There the extra tokens buy accuracy, and being wrong costs more than they do.
It is waste on high-volume, low-ambiguity work: summarising transcripts, rewriting copy, translating, tagging tickets, pulling a VAT number off a PDF. No chain to reason about — the answer is already in the input. Worse, reasoning models show a documented overthinking failure mode on easy prompts: they burn tokens second-guessing a correct first instinct, add latency, and sometimes talk themselves out of a right answer.
One honest point. A reasoning trace is not an audit trail. Anthropic tested whether models admit using hints they had in fact used: Claude 3.7 Sonnet mentioned them 25% of the time, DeepSeek R1 39%; in reward-hacking setups they exploited the hack over 99% of the time but verbalised it under 2%. The trace is a plausible story about the answer, not a record of how it was produced. For defensibility, log inputs, retrieved sources, model version and output.
How to recognize good vs bad implementations
Good: reasoning is a per-task setting, not a global switch, with a visible token budget and a usage breakdown you can query. Good products route easy work to a cheap model, hard work to a thinking model, and tell you which ran. Bad: "advanced reasoning" is a checkbox on every request — no usage field, no off switch, a per-seat price that hides where the money goes.
Three questions that end a vague demo. Show me the token breakdown for that answer — how many were thinking tokens, and can I pull that from the API? Turn reasoning off, re-run these ten cases: what changed in accuracy, and in latency? When it gets one wrong and my accountant asks why, what do you hand them — the trace, or the sources and model version? Vendors who route intelligently answer flatly; checkbox vendors change the subject.
What this costs
List prices per million tokens: Gemini 3.1 Pro $2.00 in / $12.00 out; GPT-5.4 $2.50 / $15.00, GPT-5.5-pro $30 / $180, o4-mini $4 / $16, non-reasoning GPT-5.4-nano $0.20 / $1.25. Thinking lands in the output column at the output rate, and Anthropic's minimum thinking budget is 1,024 tokens per call — you cannot buy a little thinking.
Concretely: 500 queries a day, 800 input tokens, a 300-token answer plus 2,500 thinking tokens, on GPT-5.4 — $1.00 input and $21.00 output daily, about $660 a month (roughly €610). The same workload with reasoning off costs $3.25 a day, about $98 a month (€90). A 6.8x premium, ~95% of it text you never see. On GPT-5.4-nano: under $10 a month.
The free path is real. Open-weight reasoning models — the DeepSeek R1 lineage and its distills, Qwen's reasoning line — cost €0 in licence and run on vLLM or Ollama on your own hardware. A rented RTX 4090 at $0.69/hour is ~$504 a month 24/7 and hosts a 7B–32B reasoning distill; an A100 80GB at $1.39/hour is ~$1,015 a month; a 671B-class model needs eight H100s, ~$16,878 a month. DeepSeek's hosted API is the sanity check: $0.14 in / $0.28 out per million, thinking on by default. Self-hosting wins on price only above tens of millions of output tokens a month; below that you buy privacy and control, not savings.
Where to see it scored
Of 62 tools audited, only 32 were scorable on this element. Gemini / Google (9), Claude / Anthropic (9) and ChatGPT / OpenAI Platform (9) top the table: reasoning-class models, per-request control, documented token breakdowns. Glean (8.5) is a strong application layer, routing reasoning models over your own corpus rather than pretending to own one. At the bottom, Decagon (3.5) buries reasoning in its support agents as an opaque behaviour you cannot tune or meter, and the Meta Llama ecosystem (2) offers capable open weights but no reasoning product you can switch on.
Flashcards
Check yourself
1. How do the major platforms bill the model's hidden thinking tokens?
2. Which task is the clearest waste of a reasoning model?
3. In the worked example (500 queries/day, 2,500 thinking tokens each) on GPT-5.4, the reasoning premium is roughly:
4. Your accountant asks why the model produced a given figure. What do you hand over?
5. What is Anthropic's minimum thinking budget per call?
Cheat sheet
- Thinking tokens are billed as output tokens on OpenAI, Google and Anthropic.
- Anthropic minimum thinking budget: 1,024 tokens per call. No small sips.
- Rule of thumb: reasoning on = 5-7x the output bill for the same visible answer.
- Overthinking is real: easy prompts get slower and occasionally less accurate.
- A reasoning trace is a story about the answer, not an audit trail. Log sources.
- Open-weight reasoning is €0 in licence; a 4090 at $0.69/hr is ~$504/month.
Who actually does this well
| Best on this element | Score | Why it scored that |
|---|---|---|
| ChatGPT / OpenAI Platform | 9 | Reasoning models at the frontier of test-time compute. |
| Claude / Anthropic | 9 | Extended and adaptive thinking, effort control and task budgets give unusually fine-grained control over test-time reasoning across the lineup. |
| Gemini / Google | 9 | Deep Think for hard problems and standard thinking-level controls even on the cheapest Flash-Lite tier — reasoning depth is a dial everywhere in the lineup. |
| DeepSeek | 8.5 | The lab that mainstreamed visible reasoning; V4 ships thinking as the default mode and the app added interleaved-thinking deep research in January 2026. |
| Glean | 8.5 | 'Thinking Mode' and 'Adaptive Reasoning Mode' are named, separately-metered query modes in the official rate card, not just incidental access to o1/o3-class models. |
| Cursor | 8 | Reasoning-class frontier models sit in the model picker and Plan Mode is designed around them; Cursor publishes its own research on agent reward hacking. |
| Genspark | 8 | Reasoning-class models (o3-pro, Claude Opus 4.6, Gemini reasoning tiers) are in the routed model pool and selectable manually in Genspark Claw for high-stakes tasks. |
| Grok (xAI) | 8 | Reasoning and non-reasoning variants across the line, per-request reasoning choice, and Heavy's parallel test-time compute; strong but no longer differentiating at the frontier. |
And the other end of the same column:
| Weakest | Score | Why it scored that |
|---|---|---|
| Higgsfield | 5 | Supercomputer can route planning to reasoning-class models (GPT-5.5 Pro, Gemini 3.1 Pro) but Higgsfield ships no reasoning model of its own -- access, not ownership. |
| Vapi | 5 | DeepSeek R1 and OpenAI's reasoning models are reachable via bring-your-own/custom-LLM, but they aren't a native, optimized surface — Vapi's own realtime-model docs flag o-series la |
| Decagon | 3.5 | OpenAI's case study confirms o1-mini was part of the stack for complex decisions, but Decagon's stated architecture favors small, fast, fine-tuned models over reasoning models, and |
| Meta Llama ecosystem | 2 | No reasoning-trained Llama checkpoint has shipped; Meta's reasoning-class work went into the proprietary Muse Spark instead — a low score because reasoning is expected of a flagshi |
Scored on 32 of 62 audited tools. Every score links to the full audit and its reasoning.