Price per Token Is the Wrong Column: What AI Models Actually Cost in 2026

On September 1, Claude Sonnet 5 was supposed to get 50% more expensive. It won't. Anthropic quietly turned the launch discount into the list price — $2 per million input tokens, $10 per million output, permanently — which puts it at 40% of what Opus 4.8 charges. That's a real price cut on a real frontier model, and it tells you almost nothing about what Sonnet 5 will cost you. The number on the pricing page isn't your cost. It's one factor of it. Your bill is price × tokens, and the second factor — the one no vendor prints — is where this whole year's story lives.

The Column That Isn't on the Pricing Page

Artificial Analysis runs every frontier model through the same nine-evaluation index at maximum effort, and — unusually — publishes what each run cost and how many tokens it took. That's the closest thing to a controlled experiment on inference cost that exists in public, so read it the way you'd read a lab notebook, not a scoreboard:

Two rows break the model everyone carries in their head. Sonnet 5 is the cheapest per token of anything Anthropic sells above Haiku — 40% of the Opus rate. It also generated 300 million output tokens to get through the index, two and a half times what Opus 4.8 needed for the same tasks. Multiply the two and the "cheap" model finished the run costing $4,010 against Opus 4.8's $3,752. The 60% price cut arrived as a 7% price increase.

GPT-5.6 Sol runs the trick in reverse. At $30 per million output it has the highest blended price of the $5-input tier — dearer per token than Opus 5, Opus 4.8, or anything else in the class. It also emitted 70 million tokens, the fewest of any model on the board, and finished the index for $2,823: the cheapest run in its tier, a quarter under the Anthropic flagships, while scoring within two points of the top. The most expensive token in the class bought the cheapest task.

The usual caveats apply and none of them rescue the price table. This is one lab's harness, at max effort, on a benchmark that isn't your workload; drop the effort setting and every row moves. But that's the point — the ranking by price is fixed on a web page, and the ranking by cost is a function of things the web page doesn't mention. Price and cost don't even sort the same way.

A price cut on a model that talks twice as much is a price increase. The vendor gets to announce the first half.

Three Things Set the Tokens Column, and You Control Two of Them

If cost is price × tokens and the price is public, everything interesting is in tokens per task. Three things decide it.

The model's appetite. Some models think longer, retry more, call more tools, and explain more, and none of that appears in the price. Sonnet 5 at max effort took roughly three times the agentic turns of Sonnet 4.6, by Artificial Analysis's count — that's the 300M tokens. Then there's the tokenizer, the sneakiest line in any pricing doc: Anthropic's models from Opus 4.7 onward use a new tokenizer that produces "approximately 30% more tokens for the same text." Opus 4.7 launched at the same $5/$25 as Opus 4.6. Same price per token, 30% more tokens per document — a 30% price increase on input that never touched the price table. You can't control appetite, but you can measure it: the usage block on every response is the only honest cost signal you will ever get, and almost nobody logs it.

The effort dial. The same weights at two effort settings are two different products with two different bills. On Artificial Analysis's index, Opus 5 at max cost $2.34 per task; at xhigh, $1.80 — 23% cheaper for a drop of less than a point. Anthropic's own docs say it plainly: max "adds significant cost for relatively small quality gains," and lower effort doesn't just shorten thinking, it makes fewer tool calls. The API default is high, which means the most consequential cost setting in your stack is one you may never have set. Not choosing an effort level is choosing one.

The harness. This is the one that actually runs your bill, and it's the one you own. An agent doesn't send a prompt; it re-sends the entire conversation on every turn — every file it read, every tool result, every prior message. Claude Code's own docs describe it exactly that way, and then note that agent teams run about 7× the tokens of a normal session. Anthropic puts the enterprise average at $13 per developer per active day, with 90% of users under $30. What separates the $13 day from the $130 day is mostly not the model. It's whether the re-reads hit the cache.

Do the arithmetic once, and you'll never look at the price table the same way. Hold a Claude Code session at 150K tokens of context for 40 turns on Opus 5:

Input price:            $5.00 / 1M        cache read: $0.50 / 1M (0.1×)
                                          5-min cache write: $6.25 / 1M (1.25×)
 
Uncached:   40 turns × 150K tokens = 6.0M tokens × $5.00      =  $30.00
Cached:     1 write  × 150K × $6.25                            =   $0.94
            39 reads × 150K × $0.50                            =   $2.93
                                                                  $ 3.87   →  7.8× cheaper
 
One cache miss (re-write the whole context):                   =   $0.94

Output tokens are the same in both columns; this is input alone. A fully cached session costs an eighth of an uncached one, and every miss re-bills a quarter of the entire cached session. What causes a miss? The cache expiring — five minutes by default on the API, so a coffee break is a full re-write. Changing the effort level mid-conversation — the docs are explicit that this invalidates the cached prefix. A timestamp or request ID in your system prompt, which rewrites the first byte of every request and takes the whole prefix with it. None of those are model decisions. All of them are yours.

Tokens Are Getting Cheaper. Bills Aren't.

Zoom out and the same arithmetic runs the whole industry. The price side is the best-documented deflation in the history of computing: a16z measured the cost of a fixed level of capability falling roughly 10× per year, and the cheapest "good enough" model today lists at about 300× less per token than GPT-4 did at launch. If cost were price, AI spend would be collapsing.

It's doing the opposite, and the tokens column explains why. OpenRouter — a routing layer that sees traffic across every vendor — went from 5 trillion tokens a week to 25 trillion in six months, about 100 trillion a month by May. Its own 100-trillion-token study shows what's inside the growth: the average prompt roughly quadrupled from ~1.5K tokens to over 6K in two years; programming went from 11% of all tokens to over half; reasoning models — the ones that bill you for thinking — now carry over half of all tokens. And here's the number that kills the "cheaper tokens drove adoption" story: a 10% price cut moved usage by only 0.5–0.7%. Demand is nearly deaf to price. It's ferociously responsive to capability. Every capability step — reasoning, tool use, agents, teams of agents — multiplies tokens per task by more than the price falls per year, and the bill follows tokens.

Call it Jevons if you like; Jevons is what cheap coal did to Britain's coal consumption. The honest version for 2026 is narrower and more useful. Per-token deflation is real and it will keep coming — Anthropic just made a 33% cut permanent, OpenAI cut Luna by 80% on July 30, DeepSeek halves its rates off-peak. None of it will lower your bill, because your bill was never denominated in tokens. It's denominated in tasks, and the token cost of a task is climbing faster than the token price is falling.

Self-Hosting Won't Save You Either

The homelab reflex is to route around the whole problem with a GPU in the rack. Run the electricity, not the vibes. A 5090-class card pulling ~450 W under sustained load, at $0.15/kWh, burns about 7 cents an hour. Single-user inference on a 30B-class model at ~40 tokens a second is ~144K tokens an hour, which puts the electricity alone at roughly $0.47 per million output tokens — before you amortize a card that costs as much as running the entire Artificial Analysis index on Luna eleven times over. Luna's output list price is $1.20; DeepSeek V4 Flash off-peak is $0.66; both bill cached input at fractions of a cent per million, a figure no home box can approach on power. So the local card roughly ties the cheapest APIs on electricity and loses once it has to pay for itself — and the models at the top of that index table are trillion-parameter-class mixtures of experts that a homelab can't load at all. My cluster has no GPU. This math is why. Self-host for data locality, for offline, for the principle of the thing; don't self-host for price and expect the spreadsheet to agree.

What to Read Instead

The price table is a fine place to start and a terrible place to stop. Five habits, in order of how much money they've saved me.

1. Measure cost per task, on your task. Ask a vendor for tokens per task and watch them change the subject. Then run your own eval — twenty representative jobs, every model, effort held constant — and total the usage blocks. That number is the only price that's true for you.

2. Log cache_read_input_tokens. If it's zero across a session, you are paying 10× on input, and the fix is in your harness, not your model choice. This is the highest-leverage line in any inference stack.

3. Set effort explicitly, and hold it for the session. The default is high. Sweep medium and xhigh against your eval; the delta is often 20–30% of the bill for under a point of quality. Never flip it mid-conversation.

4. Learn where the cliffs are. The tokenizer version, the context tier, the cache TTL. Each one is a step function your bill will find before you do.

5. Budget in tasks, not tokens. A million tokens is not a unit of work. "Fix this issue" is. The vendors know this — Anthropic now ships an advisory task budget that tells the model how many tokens the whole job may spend. Use the same unit on your side of the ledger.

For three years a per-token price was a reasonable proxy for cost, because a request was a prompt and a reply and the token count barely moved between models. Agents broke that. Today the price is the stable, public, marketed number, and tokens per task is the volatile, private, unmarketed one — and the bill is their product. The next launch will lead with a price cut. Let it. Then find the tokens.

Read the tokens column.