Reasoning Models Explained – RLVR, Thinking Budgets and Real Cost

Why nearly every frontier model now thinks before answering, how reinforcement learning with verifiable rewards made it work, and how to stop hidden reasoning tokens wrecking your budget.

September 7, 2026 • 9 min read

reasoningRLVRcost

Two years ago, “reasoning model” described a specific product tier you chose deliberately. In 2026 it describes almost every frontier model — thinking is on by default, and in some cases cannot be turned off at all. That is a meaningful change in how you budget and how you architect, and it is worth understanding why it happened.

Why models started thinking

The technique behind the shift is RLVR — reinforcement learning with verifiable rewards. The idea is straightforward: train on problems where correctness can be checked mechanically. Maths has a right answer. Code either passes the tests or does not. A formal proof either verifies or does not.

That verifiability is what makes the training loop work. Instead of a human rating which of two answers reads better, the model gets an unambiguous signal about whether its chain of reasoning arrived somewhere true. Run that at scale and models learn to spend inference-time compute productively — to work through a problem rather than pattern-matching to an answer.

The results were substantial on exactly the domains you would predict: competition maths, scientific reasoning, and multi-step coding. They were far less dramatic on tasks with no verifiable ground truth, like writing quality or summarisation. That asymmetry is still visible in current benchmarks, and it should shape where you deploy reasoning models.

The billing surprise

Here is what catches teams out. Those reasoning tokens are real tokens, and you pay for them at the output rate — the expensive side, typically five to six times the input rate.

The consequence is that sticker price stops predicting your bill. Consider two models:

	Model A	Model B
Output price per 1M tokens	$20.00	$6.00
Tokens spent on a typical task	2,000	15,000
Cost per task	$0.040	$0.090

Model B looks 70% cheaper and bills more than twice as much. This is not a contrived example — token efficiency between frontier models genuinely varies by several multiples on the same task, and providers have started competing on it explicitly. One vendor’s pitch for its 2026 flagship was that it matched a rival’s intelligence score while completing tasks in 61% less time at roughly half the estimated cost.

The practical rule: benchmark cost per completed task on your own workload. Cost per token is a component of that number, not a proxy for it.

Controlling the spend

Three levers, in rough order of impact.

1. Effort settings

Most providers now expose a thinking-budget or effort parameter. OpenAI’s current family accepts effort from none through low, medium, high, xhigh, and max. Anthropic ships adaptive thinking that scales with detected problem difficulty.

Tuning this per request is usually a bigger saving than switching providers, and it is far less work. Most requests in a real application are easy; sending them all at maximum effort is the most common form of waste.

Note the exception: some models have always-on thinking that cannot be disabled. Those are excellent for hard problems and poor choices for latency-sensitive paths like autocomplete or live chat suggestions, regardless of price.

2. Routing

Do not standardise on one model. Send easy requests to a cheap tier, verify the result cheaply, and escalate only on failure. The price spread within a single provider’s family is often 20x or more, so even a crude difficulty classifier pays for itself.

3. Caching

Cached input bills at roughly a tenth of the base input rate. For anything that resends a large stable prompt each turn — chat, agents, coding assistants — this is frequently the single largest available saving. Structure your prompts so the stable prefix stays byte-identical.

When not to use a reasoning model

Reasoning helps on multi-step problems and actively hurts elsewhere. Skip it for:

Classification and extraction. A structured-output call does not benefit from deliberation, and you pay latency plus tokens for nothing.
Content moderation at volume. Throughput matters more than depth; use a cheap non-reasoning tier.
Anything user-facing and instant. Thinking adds seconds. For autocomplete or live suggestions that is disqualifying.
Simple retrieval-grounded answers. If the answer is in the retrieved context, the model needs to read, not reason.

How to read the benchmarks

Treat published reasoning scores as directional. Two specific cautions:

Single-shot metrics overestimate reliability. A score reflects whether a model solved a problem once, not whether it solves it consistently across varied attempts. This is why the field is shifting toward reliability frameworks that measure consistency and robustness under production-like stress. For anything you plan to run unsupervised, consistency matters more than peak capability.

Independent indices lag and disagree. Providers publish self-reported numbers first; independent evaluations arrive weeks later and sometimes contradict them. Where we list benchmark scores on model pages, we label the source — and we would still recommend twenty examples from your own domain over any public leaderboard.