Model Prices Are Not Falling. They Are Moving.

In a single month, one provider cut a flagship model by more than 20%, another cancelled a scheduled 50% increase with three weeks’ notice, and a deprecation elsewhere left users paying roughly ten times more. Model switching has stopped being an optimisation. For thinner-margin products it is now a question of viability.

Why did three providers move prices in different directions within weeks of each other?

On 21 August, OpenAI cut API and credit pricing for GPT-5.6 Sol by more than 20%. Three weeks earlier it had taken GPT-5.6 Luna down to around $0.20 per million input tokens, currently the floor for mainstream models.

Tomorrow, 1 September, Claude Sonnet 5’s introductory rate of $2/$10 per million tokens was scheduled to revert to $3/$15 — a 50% increase with a calendar date attached. Anthropic made the introductory pricing permanent on 11 August, so it will not now happen. But the mechanism was real, published, and buyers had already costed against a rate carrying an expiry.

Meanwhile Google’s deprecation of Gemini 2.0 moved users onto Gemini 2.5 Pro, where token costs ran roughly ten times higher and throughput three to four times slower.

Three repricing events, in the same market, within weeks of each other, pointing in different directions.

Why is variability the real story, not decline?

The prevailing narrative is that model prices only ever fall, and across a long enough window that has been true. Frontier-class list prices are roughly 70 to 85% below their 2024 equivalents, and the median blended price for closed mid-tier launches has fallen from $6.00 in 2024 to $3.75 in 2026. GPT-4 launched in March 2023 at around $30 per million input tokens; by April 2026 Gemini 3.1 Flash was at $0.10 — a reduction of about 99.7% for a capability class that improved over the same period.

But the trend line conceals the distribution. What a buyer actually experiences is not a smooth glide downward. It is a sequence of discrete, unscheduled and occasionally sharply upward repricing events, any one of which can land on a product already costed, priced and sold.

Those three examples are the three mechanisms. Providers reprice directly. Introductory rates expire — Gemini 3.7 Flash is priced at $0.75/$3.75 per million tokens through the end of 2026, a repricing event with a date already attached. And deprecation, the most underrated, does not reprice you at all: it retires you, and someone else costs the migration. Gemini 2.0 users did not choose a tenfold increase; they chose not to be stranded on a dead model.

Why is there a rising hardware floor underneath falling API prices?

Underneath the API price list sits physical cost, and that is moving the other way. Memory manufacturers have shifted capacity toward enterprise HBM demand. Deloitte’s semiconductor analysts project AI-server DRAM prices could quadruple across 2026 if capital spending holds. Nvidia server pricing has risen on the memory crunch, and both Samsung and SK Hynix have warned the shortage may persist into 2027.

Set against that, competition continues to push API prices down, with some analysts forecasting a further 20 to 30% decline by the end of 2026. Others argue current pricing is substantially subsidised and that upward normalisation is a matter of when, not whether. Both positions are argued seriously by people who understand these economics better than most buyers will — which is the point. When the informed view is genuinely split, planning around either outcome is not forecasting. It is speculation with your gross margin as the stake.

As price variability increases, an architecture that permits model switching stops being an engineering nicety and becomes a core commercial control — the difference between optimisation and, for thinner-margin products, viability.

Why is this a margin question, not a tooling question?

Consider the ordinary case. You sell a fixed-price product — a per-seat subscription, a per-document fee, a managed service retainer — with a token cost inside every unit you deliver. Revenue is fixed by contract. Cost of goods is set by a supplier who can change it unilaterally, on their timetable, with no negotiation realistically available at typical volumes.

There are normally three responses to input-cost risk: negotiate it, hedge it, or substitute it. At ordinary volumes you have no negotiating leverage worth the name, and there is no hedging market for tokens. Substitution is the only lever available — and it exists only if the architecture already allows it.

The arithmetic is unforgiving at the thin end. A product at 70% gross margin, with inference at a fifth of delivered cost, absorbs a doubling without much drama. The same product locked to a model that deprecates into a tenfold increase does not absorb it at all. That is not a procurement inconvenience to be worked through next quarter. It is the end of the product, arriving with whatever notice the provider chose to give.

It is also why open-weight self-hosting matters commercially even to organisations with no intention of ever doing it: a credible alternative is the only leverage available when you cannot negotiate.

What does “switchable” actually require?

An abstraction boundary you own. Thin, not a framework. Provider-specific detail lives in one place rather than spread through the codebase.

An evaluation suite against your real task. The durable asset. It turns “could we switch?” from a debate into a measurement you can run in an afternoon.

Cost instrumentation per transaction, per model. You cannot manage an exposure you have never measured. Know what one unit of delivered work costs on each candidate model, not just last month’s aggregate bill.

Routing by task, and version pinning. Mature systems route rather than commit, escalating only where evaluation data justifies the cost — and pin versions, because providers deprecate and silently update.

A rehearsed switch. The capability is theoretical until exercised. Move one real workload to a second provider deliberately, before circumstances require it.

What’s the honest counter-argument?

Abstraction carries real costs. Provider-specific capabilities are where much of the practical value sits: prompt caching, structured output guarantees, tool-calling behaviour, context handling, batch pricing. A thin abstraction supporting only the intersection of every provider’s features delivers, reliably, the least capable version of whichever model you are running. That is a poor trade dressed up as good architecture.

The workable position is narrower than “abstract everything”. Abstract the call boundary and the evaluation harness; do not abstract away the features you are paying a premium for. Deliberate lock-in is defensible too, where a provider’s capability is central and the switching cost is understood and priced. The failure mode is not choosing a provider — it is discovering the depth of the commitment at the moment you need to leave.

What’s the honest summary?

Falling headline prices are the least useful part of this picture. The useful part is that the price of a core input to your product is set by third parties, changes without warning in both directions, and can move by an order of magnitude through a deprecation you did not initiate and cannot decline.

Businesses have managed volatile input costs for a very long time, and the standard answer has not changed: maintain a credible ability to substitute. In software, that ability is not a contract clause or a supplier assurance — it is an architectural property, and it either exists in the codebase or it does not. Building it in costs a modest amount of discipline during design. Retrofitting it costs considerably more, and the moment you discover you need it is, reliably, the moment you have no time left to build it.

Key takeaways

• LLM API pricing doesn’t move in a smooth downward line. It moves through discrete, unscheduled, occasionally sharply upward repricing events, any of which can land on a product already costed and sold.
• The three mechanisms are direct repricing, introductory-rate expiry, and deprecation. Deprecation is the most underrated because it doesn’t reprice you, it retires you.
• Hardware costs (DRAM, HBM demand, Nvidia server pricing) are rising even as API list prices fall, and informed opinion is genuinely split on which direction wins.
• Substitution is the only real lever against input-cost risk on a fixed-price product, and it only exists if the architecture already allows it.
• “Switchable” requires five concrete things: an owned abstraction boundary, a real evaluation suite, per-model cost instrumentation, task-based routing with version pinning, and a rehearsed switch.
• Abstracting everything is the wrong goal. Abstract the call boundary and the evaluation harness, keep the provider-specific features you’re paying for, and make lock-in a deliberate, priced decision rather than an accidental one.

FAQs

Are LLM API prices actually falling?
Over a long enough window, yes. Frontier-class list prices are roughly 70 to 85% below their 2024 equivalents. But that decline isn’t smooth. It happens through individual repricing events, some sharply upward, that can land on a product without warning.

What are the three mechanisms behind LLM price changes?
Direct repricing by the provider, introductory rates expiring on a scheduled date, and deprecation, where a model is retired entirely and users are moved to a replacement that can carry a much larger, unscheduled cost increase.

Why does deprecation matter more than a price increase?
Because it doesn’t ask you. A price increase changes a number on a model you’re still using. A deprecation removes the model, and the replacement can carry a materially different cost and performance profile, as happened when Gemini 2.0 users moved to Gemini 2.5 Pro at roughly ten times the token cost.

Does a switchable architecture mean abstracting away every provider’s features?
No. The recommended approach abstracts only the call boundary and the evaluation harness. Provider-specific features like prompt caching or structured output guarantees are often worth paying a premium for directly rather than flattening into a lowest-common-denominator abstraction.

Why are hardware costs rising while API prices are falling?
Memory manufacturers have shifted capacity toward enterprise HBM demand, and Deloitte’s semiconductor analysts project AI-server DRAM prices could quadruple across 2026 if capital spending holds. That’s pushing the underlying hardware cost up even as competition between providers keeps pushing list prices down.