The reasoning dial nobody touches: why your thinking-model bill is so high

Your LLM bill climbs, so you reach for the obvious fix: a cheaper model. Usually that’s the wrong dial. The biggest lever on a 2026 bill isn’t which model you pick. It’s how hard that model thinks. Frontier models reason before they answer, and that reasoning lands on the expensive side of the invoice. Most of them think by default. Almost nobody turns it down. The whole fix is one parameter.

Why thinking models are expensive by default

A reasoning model doesn’t answer your prompt directly. First it generates a chain of thought (sometimes a few hundred tokens, sometimes tens of thousands), then it writes the answer you actually see. You pay for all of it. OpenAI’s docs say so plainly for the o-series:

“While reasoning tokens are not visible via the API, they still occupy space in the model’s context window and are billed as output tokens.”

— OpenAI reasoning guide

Output is the expensive side of the bill, usually 4 to 6 times the input rate (I went through that and nine other surcharges in the hidden-costs post). So your thinking tokens get billed at the priciest tier, and you can’t even see them to check the count. Anthropic admits the billed number won’t match what it shows you:

“You’re charged for the full thinking tokens generated by the original request… The billed output token count will not match the count of tokens you see in the response.”

— Anthropic extended thinking docs

Concretely: one GPT-5.5 call at the highest effort can run around 20,000 reasoning tokens. At GPT-5.5’s $30/M output rate, that’s 60 cents of pure thinking before the answer costs anything. On every call, whether the task needed it or not.

The default trap: they think unless you stop them

Here’s what turns this into a silent bill-inflator instead of an opt-in feature: reasoning is usually on by default, and those defaults skew expensive.

The same pattern holds across the frontier, just with different defaults:

• Gemini 3.5 Flash defaults to medium thinking, and you can’t switch thinking fully off, only down to minimal. (Google renamed the old integer thinkingBudget to a thinking_level enum at I/O 2026 and quietly dropped the default from high to medium.)
• Claude Opus 4.8 defaults to high effort. Anthropic even states that high is “equivalent to not setting the parameter,” which means the default is the second-most-expensive setting on the menu.
• GPT-5.5 defaults to medium reasoning effort.

If you’ve never set a thinking parameter, you’ve accepted the vendor’s default. And that default is tuned for the model’s capability, not for your budget.

The dial every vendor gives you

Every major provider exposes one parameter to control this. Here’s the full map, checked against each vendor’s docs:

Sources: OpenAI, Anthropic effort docs, Google, DeepSeek. It’s one line in each SDK:

# OpenAI — minimal reasoning for a classification task
client.responses.create(model="gpt-5.5", reasoning={"effort": "none"}, input=...)

# Anthropic — low effort, skips thinking on simple problems
client.messages.create(model="claude-opus-4-8", max_tokens=1024,
                       output_config={"effort": "low"}, messages=[...])

# Google — minimal thinking on Gemini 3.5 Flash ("minimal" is the floor; no full off)
genai.generate_content(model="gemini-3.5-flash",
                       config={"thinking_config": {"thinking_level": "minimal"}}, ...)

# DeepSeek — turn off thinking mode (on by default)
client.chat.completions.create(model="deepseek-v4-flash",
                       extra_body={"thinking": {"type": "disabled"}}, messages=[...])

One asymmetry is worth knowing. Anthropic defaults to high, OpenAI to medium. Claude is the more eager thinker out of the box, so setting effort explicitly on Opus 4.8 usually saves you more than the same move on GPT-5.5.

What it actually costs

The reasoning dial doesn’t change the per-token price. It changes how many of those expensive, output-rate tokens a single call burns. The dollar impact rides on two things: how much the model thinks, and how often you call it.

Take a high-volume task that needs no reasoning at all: classifying support tickets, extracting fields, reformatting JSON. Run it at 10,000 calls a day. Say that, left on its default, each call quietly triggers a modest 3,000 reasoning tokens:

Set reasoning_effort: "none", or effort: "low", or thinking: disabled, and most of that spend just evaporates. The output quality doesn’t move, because the answer was never going to benefit from deliberation in the first place. That’s the whole gap between a default and a decision. DeepSeek’s row looks tiny per token, but it’s the same trap at a smaller scale, and it’s on by default on the very model people pick to save money.

The xhigh end is where it gets ugly. One GPT-5.5 call at xhigh on a long prompt can run ~20,000 reasoning tokens, which is 60 cents of thinking per call. Leave that switched on for a workload that should sit at none, and a few thousand calls a day becomes a five-figure monthly line item for reasoning a classifier never asked for.

More thinking is not more accuracy

The instinct that stops people from turning the dial down is “but won’t quality drop?” On genuinely hard problems, sometimes. On most tasks, the research says no. And past a point, more thinking actively makes things worse.

A 2026 benchmark, Do LLMs Overthink Basic Math Reasoning? (arXiv 2507.04023), found that reasoning models burn roughly 18x more tokens while sometimes scoring lower accuracy, with a non-monotonic relationship between thinking budget and correctness. Two findings worth pinning down:

• On basic math, GPT-5 and o-series models showed zero accuracy gain moving from low to medium to high effort. You paid 2-3x the tokens for identical answers.
• Push one model’s average thinking from 1,100 to 15,980 tokens and accuracy fell from 87.3% to 70.3%. The extra deliberation introduced contradictions and stacked up errors across long chains.

This isn’t a fringe result. A run of 2025–2026 papers (Does Thinking More always Help?, arXiv 2506.04210; When More Thinking Hurts; and a survey, Don’t Overthink It, arXiv 2508.02120) all land in the same place: extended reasoning has sharply diminishing, then negative, returns. Even Anthropic’s own effort docs warn that max effort “adds significant cost for relatively small quality gains, and on some structured-output or less intelligence-sensitive tasks it can lead to overthinking.”

Setting the dial per task

The move isn’t “disable thinking everywhere.” It’s matching effort to the task, the way you’d match a model tier (the logic we used in the cheapest-by-use-case roundup). A practical mapping that travels across vendors:

Anthropic’s docs land in the same place. low is “for simpler tasks that need the best speed and lowest costs, like subagents,” while xhigh/max is for “long-running agentic and coding tasks.” The point: this is a per-call decision, not a global setting you flip once and forget.

This is also where the old “orchestrator delegates by complexity” idea lands in 2026. You no longer need an external router cascading between a smart model and a dumb one. That pattern was built for the pre-reasoning era. The modern version is the same idea moved inside the model: run the hard planning step at high or xhigh, and the mechanical sub-steps at low or with thinking off. Same task decomposition, one parameter instead of a whole routing framework.

When to leave it high

The discipline cuts both ways. Turn the dial down on the wrong task and you hit the failure mode that actually bites: a subtly worse answer, a missed edge case, a shallow read of the problem, the kind of thing nothing in your dashboards flags. Anthropic’s guidance here is blunt:

“If you observe shallow reasoning on complex problems… raise effort rather than prompting around it.”

— Anthropic effort docs

So the rule is right-sizing, not starving. Set effort by task type, then measure quality on your own evals before you widen the cuts, exactly as you’d validate any other cost change. Drop the obviously-easy traffic to low or none first, confirm the eval holds, then climb the difficulty ladder one notch at a time.

Do that and you’ll find what every team that touches this dial finds: a big chunk of your reasoning spend was buying nothing. The model wasn’t too expensive. It was thinking on your dime about a problem that didn’t need the thought. For how I check every figure on this site, see our methodology.

All figures verified on 2026-06-03 against vendor documentation: OpenAI reasoning and GPT-5.5, Anthropic effort and extended thinking docs, Google Gemini thinking, and DeepSeek thinking mode docs. Research citations: arXiv 2507.04023, 2506.04210, 2508.02120.