Reasoning Models Compared

Intermediário

A reasoning model spends extra compute thinking before it answers — generating a private chain of intermediate steps, then the final reply. It's the single biggest lever on hard-problem accuracy across every major AI today. The catch: every provider exposes the same idea with a different knob, and overspending wastes money and latency for zero gain. This lesson maps the knobs side by side so the skill transfers across Claude, GPT, Gemini, DeepSeek, and Qwen.

What you'll learn

Explain what test-time compute (thinking) buys you and what it doesn't
Map each provider's reasoning control: Claude effort, OpenAI reasoning.effort, Gemini thinkingBudget/thinkingLevel, DeepSeek reasoner, Qwen enable_thinking
Pick a thinking depth by task instead of defaulting everything to maximum
Read back the reasoning trace correctly on each API without feeding it back as input
Avoid the common traps: overthinking, the can't-disable models, and treating effort as a quality fix

The one idea: thinking is a dial, not a switch

Every reasoning model sits on the same trade-off:

Less thinking → faster, cheaper. Right for extraction, formatting, simple Q&A.
More thinking → better on genuinely hard problems (multi-step math, tricky debugging, careful proofs), at higher latency and cost.

The trap that trips people up: extra thinking does nothing for a task that was already easy — you just pay the latency and cost. The skill is spending depth where it changes the answer. That truth is identical on every model below; only the dial's name changes.

This is the cross-AI sibling of the Claude-specific Extended Thinking & Effort lesson — read that for the Claude Messages API details.

Step 1 — Classify the task before you touch a knob

Guided walkthrough1 of 3

Extraction, reformatting, classification, short factual lookup → minimal or no thinking. Thinking won't help and adds latency.

Pro tip

Start at the provider's medium/dynamic default and raise effort only where quality visibly demands it.
Higher effort is not a fix for a vague prompt — a clearer spec usually beats more thinking.

Step 2 — The knob, provider by provider

Same dial, five different control surfaces. This is the table to keep open when you port a workload between models.

Provider / model	Control	Values	Disable thinking?
Claude (extended thinking)	`effort` tier (newer models adapt depth; older expose `budget_tokens`)	Low / Medium / High	Yes, on most — use a low tier or omit thinking
OpenAI GPT‑5.5 / o‑series	`reasoning.effort`	`minimal`, `low`, `medium` (default), `high`, `xhigh` (GPT‑5.5 / Codex‑Max)	`minimal` emits few/no reasoning tokens
Google Gemini 2.5	`thinkingBudget`	token count; `0` disables; `-1` = dynamic (caps ~8,192); 2.5 Pro requires 128–32768 or `-1`	`0` on most 2.5 models
Google Gemini 3	`thinkingLevel` (don't combine with `thinkingBudget`)	tiered levels	No — Gemini 3.1 Pro can't disable
DeepSeek R1 (`deepseek-reasoner`)	dedicated reasoner — always thinks	n/a (open weights, runs locally)	No — it's a thinking-only model
Qwen3	`enable_thinking` (hybrid) + `/think` · `/no_think` soft switches	on / off, toggled per turn	Yes — `enable_thinking=False` or `/no_think`

Watch out

Some models REMOVE the off switch: Gemini 3.1 Pro and DeepSeek R1 always think. Plan latency/cost for that — you can't dial them to zero.
On Gemini 3, setting both thinkingLevel and thinkingBudget in one request is an error. Pick one.
Gemini's dynamic mode (-1) caps thinking at ~8,192 tokens — fine for most work, but a hard ceiling on the very hardest problems.

The two families

Reading the table top to bottom, models split into two kinds — knowing which you're holding tells you what to expect:

Hybrid / switchable (Claude, OpenAI, Gemini 2.5, Qwen3): one model, you dial thinking up or down — or off — per request. Best for mixed traffic where some calls are trivial and some are hard.
Dedicated reasoners (DeepSeek R1; Gemini 3.1 Pro in practice): the model always reasons. Don't route formatting and extraction here — you'll pay the thinking tax on every call. Keep a cheap non-thinking model in the rotation for the easy traffic.

Step 3 — Read the reasoning trace correctly

Every provider returns the thinking separately from the answer — and the universal rule is don't paste the reasoning back in as input on the next turn. Feed back only the final answer (plus, on Claude, the signed thinking blocks the API hands you for tool loops).

Guided walkthrough1 of 4

The reply arrives as a thinking block followed by the text block. Iterate message.content and branch on block.type.

Same task, three dials — pseudo-config you can adapt

# Claude — balanced
thinking = {"type": "enabled", "budget_tokens": 8000}   # keep < max_tokens

# OpenAI — balanced
reasoning = {"effort": "medium"}

# Gemini 2.5 — let the model decide
thinking_config = {"thinking_budget": -1}   # dynamic; 0 to disable

# Qwen3 (local) — turn thinking OFF for a trivial call
chat_template_kwargs = {"enable_thinking": False}

Step 4 — When NOT to spend thinking

The expensive mistake is defaulting everything to maximum. Skip or minimize thinking when:

The task is mechanical (extract, reformat, classify, translate a known string).
You're under a tight latency budget (chat UIs, autocomplete) — use minimal/0//no_think.
The prompt is underspecified — more thinking on a vague task produces confident wandering, not a better answer. Fix the spec first.
You're doing high-volume batch work where a few points of accuracy aren't worth multiplying the token bill across millions of calls.

Pro tip

Rule of thumb: thinking pays off when the problem has a verifiable correct answer that requires several dependent steps. It pays little on open-ended generation where there's no single right path.

Quiz

Check yourself

0/4

What does extra thinking buy you on a task that was already easy?
Which model effectively cannot have its thinking turned off?
In Gemini 2.5, what does thinkingBudget = -1 mean?
What should you NOT do with a model's reasoning trace?

Flashcards

Reasoning-control vocabulary across models

Pressione Enter ou Espaço para virar o cartão. Use as setas esquerda e direita para navegar entre os cartões.Termo exibido.

1 / 7

The one idea: thinking is a dial, not a switch​

Step 1 — Classify the task before you touch a knob​

Step 2 — The knob, provider by provider​

The two families​

Step 3 — Read the reasoning trace correctly​

Same task, three dials — pseudo-config you can adapt

Step 4 — When NOT to spend thinking​

Quiz​