In the summer of 2025, roughly two thirds of all tokens on OpenRouter — the router developers use to send requests to different models — went to models built in the US, chiefly by Google, OpenAI, and Anthropic. Tokens are the unit a model’s workload is measured in. A year later that share was down to about 40%. In late March 2026, Chinese-built models passed American ones in weekly volume for the first time, and they have stayed ahead since.
The models at the top got noticeably stronger over that year. Demand moved the other way.
Six weeks ago, in «AI Is Turning Into Expensive Infrastructure», we argued that access to the strongest models was getting pricier and splitting into tiers, and that knowing which model to use for which job would become a skill of its own. That was a forecast then. Now it shows up in the numbers, and the shift is running faster than we expected.
But explaining it through price alone misses the point. Cheap models existed a year ago, and two years ago, and demand didn’t move. What changed isn’t that a cheap option appeared. What changed is that “which model should we use” became a question worth asking not about a company, or even a product, but about a single step of work. It used to have one answer for everyone. That’s what this piece is about.
Where the Demand Went
The turn came fast. In January 2025, Chinese-built models (DeepSeek, Tencent, Alibaba, MiniMax, Xiaomi, Moonshot) accounted for under 5% of tokens on OpenRouter. By the summer of 2025 they touched 30% for the first time, by January 2026 they held around a third, in late March they overtook American models, and by July they were approaching 60%. DeepSeek alone is ahead of every other provider at roughly 17% of total volume.
Don’t read those numbers too literally. OpenRouter is a slice of developer traffic, not the whole market: enterprise contracts with Microsoft, Google, and Anthropic never show up in it, and in revenue terms the picture looks different, because cheap tokens deliver volume, not income. Shares are counted by the country a model was built in, so the American share covers more than the three companies named above. And most importantly, “Chinese model” long ago stopped being a synonym for open, or for cheap. Chinese labs reached the top tier and raised their prices right along with it — Kimi K3, their newest flagship, costs roughly what Western top-tier models cost, and some Western ones cost less than it does.
So the line doesn’t run between countries, or between licenses. It runs between tiers and their prices, and the gap there is serious: a cheap tier runs about $0.14 per million input tokens, a flagship $5 for that same million. More than thirty times the cost for the same request. Geography is a consequence here: it happens that Chinese labs have been the ones filling out the low and middle tiers most aggressively this past year.
What Changed: the Middle Became Usable
The top didn’t get cheaper — the middle grew up. GPT-4-level capability, the ceiling in 2023 at around $30 per million tokens, now sits in every provider’s budget tier and costs under a dollar.
But price isn’t the interesting part. For businesses and agents, what matters more is the thing benchmarks barely capture. The boring capabilities got better — the ones everything used to fall apart on:
- following instructions. A weak model a year ago would drift off-format by the third paragraph. A mid-tier model today holds the frame;
- structured output. Returning data against a given schema without breaking it became the norm rather than a lucky break;
- tool calls. An agent is mostly a loop: think, call a function, look at the result. A year ago a correct function call from a cheap model was a coin flip. Today it’s table stakes.
Agent work isn’t made of olympiad problems — it’s careful execution of well-defined steps, many times over. As long as mid-tier models kept breaking on that routine, the choice was settled in advance: flagship everywhere, or nothing runs. Once they stopped breaking, every step got its own answer — and the question about the model broke apart into a lot of small questions.
Why a Step, Not a Product
Our agent for as-built construction documentation reads site paperwork, checks it for completeness, and drafts acceptance certificates. It sounds like one big task that needs one model picked for it. In practice it’s a chain: identify what kind of document arrived, pull the fields out of it, check them against a list of requirements, draft the certificate, and ask a question wherever the data is missing.
Half those steps are recognition and shuffling, where a strong model and a cheap one give the same answer and the bill differs several times over. Difficulty isn’t spread evenly along the chain — it’s concentrated in two or three places: where you have to interpret an ambiguous phrase, reconcile conflicting data, or decide what happens next. Picking one model for the whole process means paying your most expensive step’s rate for all the others.
Harvey, the legal AI company — high cost of error, not a place anyone cuts corners on cheap tooling — landed in the same spot. They built a hybrid setup: heavy tasks go to a flagship model, routine work to a cheap open-weight one. The bill for processing requests dropped threefold with no loss of quality. Their framing is sharper than ours: the definition of quality moved from “use the most powerful model for everything” to “use the one that gets to the right answer most efficiently.”
How to Choose at the Step Level
The parameter that matters most here isn’t task difficulty — it’s the length of the stretch an agent covers without a human. When it runs a chain of dependent steps, the probabilities multiply. A step that’s 95% accurate, repeated ten times, gets you to about 59% end-to-end. At 90% per step you land at 35%. At 85% you’re at 20% — the chain completes once in five attempts. A model gap that looks like “eh, slightly worse” on a single step turns into “doesn’t work” across a long chain.
Hence the rule: the longer the autonomous stretch where nobody checks the intermediate result, the more expensive your model needs to be.
| Stretch of work | Who catches the error | Safe to economize? |
|---|---|---|
| Single step, a human reviews the output | the human, immediately | Yes. The gap between models is barely visible |
| Chain of 3–5 steps, checked at the end | the human, at the end | Partly: yes on recognition and data transfer, no on decisions |
| 10+ steps with no stops | nobody | No. Errors compound |
| Free-form input — a document everyone fills in their own way | nobody, until the very end | No |
| Long context that has to be held in full | nobody | No |
| Cost of a mistake exceeds a year’s difference in spend | depends on the process | No — tokens aren’t the number to optimize |
The flip side of the rule is friendlier: wherever review is genuine, your requirements on the model get a lot softer. We wrote about that separately when we looked at the human-plus-AI pairing — a mid-tier model with review regularly beats a flagship without one.
The approach has a price of its own. A router that decides where to send each request is code: you write it, debug it, and maintain it, plus a second provider, a second key, a second failure mode. At volumes where the monthly bill is measured in tens of dollars, that work will never pay for itself — there the right answer is one model for everything, and no further thought.
At Some Steps It Isn’t the Model at All
Breaking the process into steps got us to something uncomfortable. Torgi, our tender agent (still a pilot), worked unevenly: sometimes it produced a solid breakdown of a procurement, sometimes it lost half a document or mixed up the client. A stronger model came out, we plugged it in, and waited for quality to lift on its own. What we got was slightly smoother phrasing and exactly the same missing documents. The model had nothing to do with it — half the text never reached it in the first place.
While the middle was weak, that distinction didn’t matter, because model choice decided everything. Now that the middle has evened out, at plenty of steps the gap between models is smaller than the gap between what’s been built around them.
Around the model sits the scaffolding: how context gets assembled, which tools are available, what happens on an error, where it stops and asks a human, what persists between runs, how the result gets checked. The model determines how smart an answer is possible at all. The scaffolding determines whether the right question reaches the model and what happens to the answer afterward.
This completes the question about the step. At each one you’re asking not only “which model” but “is the model even the bottleneck here.” The test is simple: when an agent performs badly, go through the failures one at a time. If the model had everything it needed and still answered stupidly, that’s on the model, and it’s worth replacing. If it answered badly because it got half a document, contradictory instructions, or no tool to ask for clarification, no model swap will save you. In our experience the second case is far more common.
The good news is that scaffolding that works survives a model change. You write it once, and after that you can swap providers to fit the task and the budget — which is exactly what a market demands when the best choice goes stale within a quarter. The mid-tier segment moves fastest of all: what was the obvious pick in March has been displaced by July.
What to Do About It
Revisit any decision older than a year. If you picked your model in 2025, you picked it in a different market, where betting on a flagship was right because the alternatives didn’t work. Today the same bet can cost several times more with nothing to show for it.
Break the process into steps and measure. Don’t argue in a meeting about which model is smarter. Take fifty real cases, run every step through a mid-tier model and a flagship, and compare both against a reference. Usually it turns out the two differ on two steps out of seven — and you also see which steps aren’t the model’s fault at all.
Perimeter first, price second. If you’re handling personal data, medical records, financial data, or anything under critical-infrastructure rules, where that data is legally allowed to be processed gets settled before price does. The shortlist narrows itself and half the arguments disappear.
Cost your operations. One analyzed tender, one document package, one customer reply — and what happens to that number when volume grows tenfold.
Instead of a Conclusion
A year ago the main question was whether we’d get access to the strongest model. It made sense as long as there was one answer for everything.
That question is gone now. In its place are a couple of dozen small ones — one per step of the process — and most of them don’t need the top tier. The top tier hasn’t gone anywhere and is irreplaceable for the jobs it’s meant for; there just turn out to be few of those jobs in an ordinary company’s ordinary work.
The headlines go to the top. The work gets done by the middle. And where exactly to put it isn’t decided at the level of a company, or a product, but at the level of a step.