Most people compare AI models the way they compare petrol prices: look at the number per unit and pick the cheaper one. For reasoning models, that instinct is wrong, and it can be wrong by a factor of five. The per-token sticker price tells you what a token costs. It does not tell you how many tokens a model will burn to answer your question — and on modern reasoning models, the tokens you never see are usually the biggest line on the bill. Understanding this one mechanic is the difference between a cost estimate that holds and one that triples in production.
This is the reasoning-token tax, and it is the single most misunderstood thing in AI pricing today. Here is how it works, how to measure it, and why GPT-5.6's approach to it is a genuine advance rather than a marketing line.
What you are actually paying for
When you call a normal language model, the billing is simple: you pay for the tokens you send (input) and the tokens it returns (output). What you see is what you pay for.
Reasoning models broke that clean model, for a good reason. Starting with OpenAI's o1 in late 2024, frontier models began doing extended internal reasoning before producing a visible answer. The model generates a long private chain of thought — working through the problem, considering options, checking itself — and only then writes the response you see. That hidden reasoning is real computation, and you are billed for it, at the output token rate. It simply does not appear in the response.
So a reasoning model's answer has two parts on your invoice: the visible output, which might be a 400-token summary, and the invisible reasoning, which might be 5,000 tokens. You pay the output rate on all 5,400. The 400 tokens you read are a rounding error next to the thinking you did not.
This is not a scam — it is the honest price of test-time compute, the technique of spending more inference computation to solve harder problems, which has driven much of the capability progress since raw model scaling slowed. But it means the published price per million tokens systematically understates what a reasoning workload actually costs, and the degree of understatement varies wildly between models.
Why the sticker price lies
Consider two hypothetical models. Model A charges $30 per million output tokens; Model B charges $20. On the sticker, B is 33% cheaper and the choice looks obvious.
Now add the reasoning. Suppose Model A is efficient and burns 1,500 reasoning tokens on a typical hard problem, while Model B is verbose and burns 6,000. For a task with a 500-token visible answer:
- Model A: (500 + 1,500) × $30/1M = $0.060 per task
- Model B: (500 + 6,000) × $20/1M = $0.130 per task
The "cheaper" model costs more than twice as much per answer. The sticker price pointed you at exactly the wrong choice, because it priced a token when the thing you actually buy is an answer. This is why comparing reasoning models on their headline rates is close to meaningless, and why two models with similar published prices can differ by 3–5x on your real bill.
How to measure your real cost
The good news is that the number you need is measurable, and most APIs now report it. When you call a reasoning model, the usage object in the response breaks out reasoning tokens separately from visible output tokens. If you are not logging that field, start — it is the single most useful cost metric you can capture.
Once you are logging it, compute your real cost per task as (input + visible_output + reasoning_tokens) priced at the correct rates, and track the reasoning-token ratio: how many hidden tokens the model spends per token of visible answer. That ratio is the number that actually distinguishes an expensive model from a cheap one on reasoning work, and it is the number to watch when a vendor ships a new version. A model that quietly doubles its reasoning verbosity has quietly doubled your bill, and you will only see it if you are tracking the hidden tokens rather than the sticker rate.
Where GPT-5.6 changed the maths
This is the context that makes GPT-5.6 interesting. Its headline price — $5 input, $30 output — is mid-tier and unremarkable next to Claude Fable 5's $10/$50. But its reasoning-token ratio is markedly lower, because it reasons in a compressed internal notation rather than verbose natural-language chain-of-thought. It reaches the same-quality answer with far fewer hidden tokens. We cover the mechanism in reasoning in a private language; the point here is what it does to the invoice.
On a reasoning-heavy workload, GPT-5.6's real cost per answer can be a third of a more verbose frontier model's, even when the sticker prices are within 2x — because it wins on both the rate and the token count. That is the advance: not a discount on the token, but fewer tokens per answer. And because it compounds with every future capability, it is the kind of progress that makes AI cheaper to deploy over time rather than more expensive. The needle moves in the buyer's favour.
The other lever: caching
Reasoning tokens are the biggest hidden cost, but there is a second one worth naming because it is free money most teams leave on the table: prompt caching.
Both OpenAI and Anthropic offer roughly a 90% discount on input tokens that repeat across calls. If your agent re-sends the same large system prompt on every step — which almost every agent does — caching turns that repeated input from full price to a tenth of it. On a chatty multi-step workload, cached input can be more than half your total input volume, so the effective input cost falls by a large fraction. Combined with a low reasoning-token ratio, caching is what turns a frontier-adjacent model into something you can afford to run at scale.
The batch-workload picture
The per-task numbers above are the right way to think about it, but the effect is easiest to feel at the scale of a monthly bill, so here is a fuller worked example.
Take a document-processing pipeline running 200,000 tasks a month. Each task sends 4,000 input tokens and produces a 600-token visible answer, and it is a reasoning workload, so the model thinks before answering. We will compare a verbose frontier reasoner against an efficient one, holding quality roughly equal.
The verbose model burns about 5,000 reasoning tokens per task and charges $40 per million output. Its output volume is (600 + 5,000) × 200,000 = 1.12B tokens, at $40 = $44,800, plus input of 800M at, say, $8 = $6,400, for a monthly total near $51,000.
The efficient model — GPT-5.6-style, reasoning in a compressed notation — burns about 1,800 reasoning tokens per task and charges $30 per million output. Its output volume is (600 + 1,800) × 200,000 = 480M tokens, at $30 = $14,400, plus input of 800M at $5 = $4,000, for a total near $18,400.
Same throughput, same quality bar, and the bill is roughly a third. Nothing about that gap is visible on the two models' pricing pages — it lives entirely in the reasoning-token ratio, which neither vendor puts in a headline. Multiply this across a year and the difference is the cost of a small team. This is why the reasoning ratio, not the sticker rate, is the number that belongs on your model-selection dashboard.
What to ask before you commit to a model
When you are evaluating a reasoning model, the pricing page will not tell you what you need to know. These are the questions that will.
What is the typical reasoning-token ratio on tasks like mine? Run your own representative workload and measure hidden tokens per visible token. Do not trust a vendor's average; measure yours, because the ratio depends heavily on your task mix.
Can I control the reasoning effort? Several models now expose a reasoning-effort setting — low, medium, high — that trades depth for cost. For easy tasks, forcing low effort can cut the bill sharply with no quality loss. If a model offers this, your cost is partly in your hands.
How does caching interact with reasoning? Confirm that your repeated input actually qualifies for the cached rate and structure prompts to maximise the cacheable share.
Does the reasoning ratio change between versions? A point release can quietly alter reasoning verbosity in either direction. Re-measure after every model update, because a "free upgrade" that doubles the reasoning ratio is a stealth price increase. The teams that get surprised by their AI bill are almost always the ones that measured cost once, at launch, and never again.
Controlling the tax in practice
Three moves, in order of leverage:
Measure the reasoning ratio, per model, on your real traffic. You cannot manage what you do not log. This alone will change which model you think is cheapest.
Match the model to the difficulty. Not every task needs a reasoning model at all. Routing easy work to a fast non-reasoning model and reserving the expensive reasoners for genuinely hard problems is the highest-leverage cost decision most teams can make. A gateway like Swfte Connect does this automatically — it classifies each request and sends it to the cheapest model that will get it right, so you stop paying reasoning rates on questions that never needed reasoning. We detail the pattern in intelligent LLM routing.
Turn on caching and structure prompts to exploit it. Put the stable, cacheable material first and the varying query last, so the maximum share of your input qualifies for the cached rate.
The bottom line
The price of an AI model is not the number on the pricing page. It is that number multiplied by how many tokens the model spends to answer you — and on reasoning models, most of those tokens are invisible. The models winning on cost right now are not winning with discounts; they are winning by thinking in fewer tokens, and GPT-5.6 is the clearest current example. Measure the hidden tokens, route by difficulty, cache aggressively, and the reasoning-token tax goes from a nasty surprise to a line you control.
For the model-versus-model view, see Fable 5 vs GPT-5.6; for the bigger shift this represents, the efficiency race.