Your model ranking survives a price shock. Your budget not
Floor prices can fall back to the standard tier. I repriced a routing plan 5 ways and checked what 260 calls billed. The ranking never moved. The budget broke, and the cheapest model on the list was the one everyone had written off.
Who should read it?
Independent professionals and technical readers who route work across several models and pay per token
Cross-linked article
What problem does this article solve?
This article solves 2 key problems:
- Budget fragility under price shocks
- Demonstrates that while model rankings survive uniform price changes (floor → standard, blends), the budget breaks
- Shows why you must budget for a 1.10× multiplier, not 1.00×, and that the only robust solution is endpoint selection, not model picking.
- Misunderstanding of floor reliability
- Explains that floor reliability is not a model property but a moment-to-moment routing outcome
- Terra held the floor 100% of the time, while Luna lost it 33% and Sol 17%, making the same pricing page behave very differently for different models
How to apply this analysis
- Recognize that model ranking changes rarely happen
- Uniform price changes (floor, standard, 50/50) cannot reorder the Pareto frontier; only tier luck differences matter
- Focus on the budget, not the model
- The only thing that changes when tiers change is your invoice, not the optimal model for your work
- Monitor realized price, not theoretical floor
- My volume-weighted realized price sits at 1.10 today
- It hits the cap at 1.235 → 1 number, 1 threshold, no per-call archaeology
- Endpoint pin the cheapest provider
- With a 16.6x spread inside a single model name, blind routing is exactly how a cheap model becomes expensive
- Pin or cap the endpoint, and check quantization (fp4 is cheapest)
The short answer
I priced a routing plan at the cheapest available endpoint, then asked what happens if that endpoint is not the one that serves the request. Twice the price, half the price, some blend of the 2:
- The model ranking came out identical every single time
Then I looked at the budget, and that did break.
The reason is simple once you see it, and it changes how you should treat every cost estimate you build from a price list.
What floor pricing actually is
OpenRouter sells model access through endpoints. Several providers can serve the same model, and they do not charge the same. The :floor variant sorts the eligible endpoints by price and sends your request to the cheapest one.
On the OpenAI models I use, that discount is precise:
- The floor endpoint costs exactly half of list
- Sol is $1 and $5 per million tokens at the floor against $2 and $10 at standard
- Terra is $0.50 and $2.50 against $1 and $5
- Luna is $0.05 and $0.25 against $0.10 and $0.50
Half price is worth having. But :floor is a routing preference, not a contract. If the cheap endpoint is saturated or unavailable, the request goes somewhere else and you are billed there.
What was actually billed
You cannot settle this from a cost column, because a cost column is what you are trying to verify. So I read the service tier the provider recorded for each request, which is ground truth rather than an inference.
I sampled 260 billed generations across my 3 OpenAI model families and asked each one which tier served it.
| Family | Floor calls | Floor share | Realised price | 95 percent interval |
|---|---|---|---|---|
| Terra | 200 / 200 | 100% | 0.50x list | 98 to 100% |
| Luna | 36 / 54 | 67% | 0.68x list | 53 to 78% |
| Sol | 5 / 6 | 83% | 0.60x list | 44 to 97% |
2 things stood out:
- The fallback is not the standard price
- Requests that fell back were served by Amazon Bedrock and billed at 1.05 to 1.09 times list, not 1.00
- So "worst case, I pay the standard rate" is wrong. The worst case I observed is slightly above the standard rate, because the backup provider carries its own margin. If you are sizing a budget, size it at 1.10, not 1.00.
- Floor reliability is not a property of the model, it is a property of the moment
- Terra held the floor price on every one of 200 calls
- Luna lost it a third of the time. Same company, same pricing page, very different odds.
Repricing the plan five ways
Now the actual question. My 2026 routing plan assigned about $21 per week, priced at floor rates.
"What if I reprice it at standard, and at a 50/50 blend?"
Because every OpenAI price component moves by exactly 2, repricing needs no new assumptions about token counts. A uniform multiplier does the work.
| Price base | OpenAI price | Frontier seats | Same as floor | Weekly plan |
|---|---|---|---|---|
| Floor only | 0.50x list | 10 | yes | $21.00 |
| Measured | 0.50 to 0.68x list | 10 | no, one seat swapped | $22.74 |
| 50/50 blend | 0.75x list | 10 | yes | $29.50 |
| Standard only | 1.00x list | 10 | yes | $38.00 |
| All fallback | 1.10x list | 10 | yes | $41.40 |
10 frontier seats before, 10 after. The same 10 configurations. The same order.
2 notes on what "10 seats" means here, because the framework article counts differently. That piece uses a 12-configuration shortlist and its Pareto line has 8 seats. This piece uses the full routing table, which has more configurations and 10 OpenAI seats. The number depends on the table. The property, that a uniform price change does not move the seats, does not matter.
Also, the 10 seats here are the OpenAI configurations. DeepSeek sits outside the group whose prices are being scaled, so it is not part of the invariance test. It is nonetheless on the frontier at floor prices, as the DeepSeek section shows.
Why a uniform price change cannot reorder a frontier
A Pareto frontier is built from 2 comparisons:
- Is this cheaper
- Is this smarter
Doubling every price in a group changes neither answer. If configuration A cost less than configuration B, it costs less after both are doubled. Order is preserved, so membership is preserved.
This is not a lucky feature of my particular numbers. It holds for any uniform change, upward or downward, and for any size of change, as long as the change is applied to all of them equally. I swept the multiplier from 0.5 to 1.38 and the 10 seats were identical at every step.
There is a boundary to that, and it is worth stating precisely, because it is where this claim ends. Scaling the OpenAI rows does not move the rows outside that group, so those can cross in at a large enough factor. In my data the first non-OpenAI row to arrive is DeepSeek at maximum effort. On the corrected DeepSeek figures it does not wait for a price shock at all:
- It is already on the frontier at floor prices, as the next section shows
Every realistic tier outcome lands between 0.5 and 1.1, so nothing else crosses in practice.
That has a practical consequence that surprised me:
The answer you already have is still correct. The only thing that changes is the invoice.
The one thing that does move a seat
"If uniform changes cannot reorder anything, what can?"
A price gap that applies to some families and not others. Sol and Terra are billed per token by the same providers, so if their tier luck differs, their relative price drifts, and relative price is what the frontier is made of.
2 configurations sit close enough for that drift to matter.
- Sol at low effort scores
34.8at $0.081 per benchmark task - Terra at medium effort scores
38.2at $0.084
Terra is smarter and only $0.003 more expensive than Sol, which should already disqualify Sol at low effort. The 2 prices are only 3 thousandths of a dollar apart. Any relative movement flips it.
The exact thresholds, solved from the price list:
- Sol at low effort keeps its seat only while Sol is less than 1.05 times the cost of Terra
- Terra at extra-high effort earns a seat once Sol is above 1.117 times Terra
My measured numbers put Sol at 1.197 times Terra, because Sol lost the floor price on 1 of 6 calls while Terra never lost it. Both thresholds are crossed, so the frontier swaps one seat:
- Sol at low effort drops out
- Terra at extra-high effort joins
I would not publish that as a finding, and I will not build a plan on it. 6 calls cannot resolve a 5% threshold. The 95% interval on Sol's floor share runs from 44 - 97%, which straddles the flip point entirely. What the sample can support is Terra's 100% out of 200 calls. What it cannot support is a claim about Sol.
The lesson that survives the sample size is different, and it is more useful:
Treat decisions between configurations that cost within a few percent of each other as unstable, no matter how carefully you priced them.At the 34 to 42 index band, default to the configuration that wins under both bases rather than the one that wins under your favourite one.
What broke: the budget
Here is the part that actually cost me money, in the sense that it would have.
The plan spent $21 of a $25 weekly cap. That is 84% of the cap. The headroom is $4, which is 16% of the cap. A full fallback to standard needs $41.40, which is $16.40 more than the plan and over the cap by $13.00.
The floor-based plan has only 1.19x headroom against the cap, while a full fallback to standard needs 100% more than the plan.

Here is the whole ladder:
| Price base | Plan per week | Against the $25 cap |
|---|---|---|
| Floor only | $21.00 | $4.00 headroom |
| Measured | $22.74 | $2.26 headroom |
| 50/50 blend | $29.50 | over by $4.50 |
| Standard only | $38.00 | over by $13.00 |
| All fallback | $41.40 | over by $16.40 |
The routing was robust and the budget was fragile, which is the opposite of what I expected. I had been treating the price assumption as a detail attached to the model choice. It is the other way round. The model choice is insensitive to it. The budget is an assumption.
How to apply this analysis with your own models
The price-shock method transfers directly to your own model list. Replace my 3 OpenAI families with yours:
- Price your own routing plan at the floor rate (cheapest endpoint for each model).
- Measure your real tier mix by checking the
service_tieron a sample of your own billed calls, not by assuming the floor always holds. - Reprice five ways (floor, measured, 50/50 blend, standard, all-fallback) and compare both the frontier and your weekly budget.
- Watch the ratio that matters: realised price divided by floor price. My trigger sits at 1.235, the point where my plan crosses the cap.
The ranking-stability result holds regardless of which models you use, as long as the price change is uniform across a group. What breaks is the budget, and that is what you need to size before a shock happens.
DeepSeek belongs on the line
The routing table includes DeepSeek, and it belongs there.
DeepSeek sat at index 32.6 and cost $0.602 per benchmark task, which made it worse and dearer than configurations already on the line. That number came from a repricing against an endpoint charging $0.40 per million output tokens.
Divide it out. $0.602 at $0.40 per million implies 1,505,000 output tokens for one benchmark task. Sol max, at $10 per million, implies 127,200 for the same task suite. A factor of 12 is not a token mix. That row was not measuring DeepSeek's cost per task, and the exclusion rested on it.
So I threw the row out and started from prices I could read directly, plus 150 billed calls of my own.
The 1st thing that showed up is that DeepSeek is not one price. I counted 48 active endpoints for the model I use. On a blended basis they run from $0.0904 to $1.50 per million tokens. That is 16.6 times. The entire OpenAI lineup, from Luna at the floor tier to Sol at the standard tier, spans 40 times.
The highest priced DeepSeek endpoint costs less than Sol at standard.
My own traffic makes the point concretely:
- In a single sample, my calls were served by 20 different providers.
"DeepSeek is cheap" is a property of the endpoint that answers, not of the model name.
Then the actual comparison, which depends entirely on the unit you pick:
| Basis | Terra / DeepSeek |
|---|---|
| Per call | 4.8 times cheaper |
| Per token | 4.8 times cheaper |
| Per session | 2.6 times cheaper |
The 2 families burn nearly identical tokens per call, 76,475 against 71,702, so the per-token ratio is correct. The advantage shrinks by the time you reach the unit that matters. DeepSeek takes more calls to finish the same job. Per session is the decision unit, and there it is 2.6 times.
On that basis, DeepSeek max costs about $0.032 per task. The per-call figure is $0.017, and I do not use it for planning. It assumes DeepSeek needs as many calls as Terra. At $0.032 it is still cheaper than Sol at low effort at $0.081, and better value than Terra at low effort, which costs $0.036 per task at an index of 29.4:
- About $0.0012 per index point, against $0.0010 for DeepSeek
That is a bigger change than anything the price tier did. The tier question moved my bill and left the ranking alone. A single wrong row moved the ranking.
What I changed
I stopped hedging price risk by downgrading models. Downgrading to protect against a price rise is solving the wrong problem. The ranking does not change, so a cheaper model is not a hedge, it is just a worse fit for the same relative cost.
I wrote the cut order down before I needed it. If prices rise, something gets cut, and that decision is much worse made in a hurry. Mine goes:
- Deep research first, then long-form writing, then technical writing, then cron jobs, and product development last
- The first 2 cuts free $7 per week, which covers the $6.50 I need to stay inside the cap if the measured tier mix keeps drifting upward.
I monitor 1 number. The volume-weighted realised price of my OpenAI spend, where 1.00 means floor. It sits at 1.10 today. It hits the cap at 1.235. 1 number, 1 threshold, no per-call archaeology.

I stopped treating a backup model as a price hedge and started treating it as a first-class option.
DeepSeek is on the frontier at index 32.6 for about $0.032 per task, so it is a real candidate for mid-weight work and not only a budget tool for mechanical edits.
I now choose the endpoint, not just the model. With a 16.6 times spread inside a single model name, letting a router pick blind is exactly how a cheap model becomes an expensive one. I pin the endpoint or cap it, and I check quantisation, because the cheapest listings are fp4.
Limits
The cost figures assume the benchmark's token mix, not my real agentic traffic with long prompts and heavy caching, so the absolute dollars are indicative. The task to model mapping is a reasoned hypothesis that I have not validated with a matched-task pilot. Sol's tier mix rests on 6 calls and I have flagged it as unresolved rather than reporting it as a result. Prices and endpoint lists change, and the frontier should be rebuilt when they do.
Limit one more:
DeepSeek's own cost per benchmark task is still not published, so the $0.032 figure is Terra's measured cost transferred through the measured price ratio, 4.8 times per call and 2.6 times per session. That is an estimate with a stated method, not a measurement, and the session ratio behind it rests on 16 sessions. The direction is safe, because it holds on both bases. The exact number is not.
Sources
[1] Artificial Analysis, Intelligence Benchmarking Methodology.
[2] OpenRouter, Floor variant.
[3] OpenRouter, Generation endpoint reference, which reports the service tier used for each request.
[4] OpenRouter model pages for GPT-6.1 Sol, GPT-6.1 Terra, and GPT-6 Luna, read 2026-11-13.
[5] DeepSeek, model pricing documentation.