DEV Community: Roman Shumyatsky

Frontier LLM prices didn't move for 5 months. In August, they moved three times, and one lab tripled its rate.

Roman Shumyatsky — Sat, 05 Sep 2026 18:36:33 +0000

On August 1 I published a report whose headline finding was that frontier LLM API prices are structurally sticky. Across 40 daily readings of an equal-weight index of ten flagship models — one per lab — not one lab had ever changed the price of an existing model. Every move in the index had come from a new model replacing an old one.

August made that sentence false in three weeks.

Here's what moved, why the index still ended the month lower, and what happened 72 hours after the cutoff that dwarfs all of it.

The month in one table

The index is the equal-weight average of ten flagships' blended price per million tokens (3 parts input to 1 part output, list prices as printed on the vendor's own pricing page).

Date	What happened	Index ($/Mtok)
Aug 1	Opening level	$4.39
Aug 4	Alibaba's slot: Qwen3.7-Max → Qwen3.8-Max ($3.75 → $3.00 blended)	$4.32
Aug 16	DeepSeek V4 Pro repriced: flat $0.435/$0.87 → peak $1.32/$3.96 (+264% blended)	$4.46
Aug 21	GPT-5.6 Sol repriced: $5/$30 → $4/$20, labelled promotional (−29%)	$4.14
Sep 1	Closing level	$4.14

Net for the month: −5.7%. Since the first reading on February 23: −9.4%.

Three other flagship handovers happened in August (Muse Spark 1.1 → 1.2, Grok 4.5 → 4.6, GLM-5.2 → 5.3) and moved nothing, because each successor kept its predecessor's list price. That's the pattern I described in August. The two bolded rows are the pattern breaking.

Move 1: DeepSeek turned "list price" into a schedule

Until 16:00 UTC on August 16, DeepSeek V4 Pro billed a single flat rate: $0.435 in / $0.87 out. Then the pricing page split it in two:

Peak (01:00–04:00 and 06:00–10:00 UTC): $1.32 / $3.96
Off-peak (every other hour): exactly half — $0.66 / $1.98

The index tracks the peak rate as the list price. Two reasons. DeepSeek defines off-peak as a discount from peak, not the other way round, so peak is the published number. And a caller who doesn't schedule around the clock needs a ceiling, not a floor. But note that even the off-peak rate ($0.99 blended) is 82% above the old flat price. This wasn't a discount scheme layered on the old price. It was a 3x increase with a discount window attached.

If you run DeepSeek workloads and can batch them: 10:00–01:00 UTC is a long off-peak window. If you can't, your V4 Pro bill roughly tripled in mid-August and the vendor did not send you an email about it.

Move 2: OpenAI's cut, with an asterisk

On August 21 GPT-5.6 Sol went from $5/$30 to $4/$20 — $11.25 → $8.00 blended, −29%. It's the first list-price cut by any constituent in the index's history.

The asterisk is a sentence that appeared on the pricing page the same day: "GPT-5.6 Sol's promotional pricing is available at least through November 21, 2026."

That's a floor, not a reversion date. OpenAI publishes no date on which the price goes back up. The index takes list prices as printed, so the cut is in — but if you've modelled Sol at $4/$20 past November 21, that input is contingent on a sentence, and the sentence can change.

Two of the ten flagships now publish a list price that's really the top of a range: one has a time-of-day schedule under it, the other has a promo clock over it.

Why the cheapest GPT-4-class model didn't get more expensive (yet)

The other line I track is the floor: the cheapest model that clears a fixed capability bar (GPQA Diamond ≥ 70, externally measured — roughly GPT-4-class reasoning). It's the deflation story; it fell 17x between March and July.

In August it did not move. It stayed at $0.113 per million tokens, set by DeepSeek V4 Flash since July 25.

Here's the thing. On August 16 DeepSeek also raised its own V4 Flash peak rate, from $0.14/$0.28 to $0.44/$1.32 — $0.175 → $0.66 blended, 3.8x. The model setting the floor got nearly four times more expensive from its maker, and the floor didn't budge.

That's because the floor reads the cheapest listed price for a base model across every host that serves it, and DeepInfra kept serving V4 Flash at $0.09/$0.18. So the cheapest GPT-4-class token on September 1 was priced not by the lab that trained the model but by a third party hosting it, 5.9x below the lab's own peak rate.

That's a new kind of floor, and a more fragile one. A lab's list price is a policy; a reseller's list price is a margin. On September 1 GPT-4-class capability was 37x cheaper than the flagship ceiling. How much of that gap is one host's pricing decision is a question I didn't have to ask in July.

The spread narrowed from both ends

"Frontier flagship" spanned a 21x price range on August 1 ($0.544 to $11.25 blended). On September 1 it spanned 13x ($0.75 to $10.00) — and it narrowed from both directions at once. Sol's cut brought the top down to Claude Opus 5's $10.00. DeepSeek's move to peak pricing lifted the bottom off V4 Pro and onto Mistral Large 3's $0.75.

One casualty of the month's launches: with GLM-5.3 arriving API-first (open weights announced, not yet released), Kimi K3 is the basket's only open-weights constituent. The "proprietary premium" comparison I ran in August is now nine numbers versus one, so I'm not running it.

Then September 3 happened

This report is dated September 1. I need to tell you about the following 72 hours anyway, because the live index no longer says $4.14.

On September 3 OpenAI released GPT-6 Astra at $10/$50 — $20.00 blended — and named it the default flagship. It took the OpenAI slot in the basket from GPT-5.6 Sol on September 4, and the index went from $4.14 to $5.34 in a day. That's +29.0%, the largest single move in the index's history, and the first time the index has been above its February 23 first reading (+16.8%).

The spread that had narrowed to 13x reopened to 27x. At a published benchmark score of 96, Astra costs $0.208 per point of measured intelligence, 3.5x the September 1 frontier average.

Two days earlier, on September 1, Anthropic had launched Claude Fable 5.1 at the same $10/$50, with cached input at $0.25 — 2.5% of the input rate, the deepest cache discount on any flagship card I track.

Two $10/$50 flagships in 72 hours, at the end of a month in which the ceiling fell 5.7%. I'm not going to call a turn on one reading. But "the frontier price never moves" was August's finding, and September's first four days have already had a reprice up, a reprice down, and the biggest step up on record.

What I'd do with this if I were paying the bills

Write the tier next to the price, not just the date. Peak or off-peak. Standard or promotional. Short-context or long-context. Two of ten flagships now have a list price that means "up to."
Check the UTC clock on DeepSeek workloads. Off-peak is 17 hours a day and exactly half price. If your pipeline runs at 08:00 UTC, you're paying double for no reason.
Treat Sol's $4/$20 as expiring November 21 until OpenAI says otherwise. Model the reversion; be pleasantly surprised.
Know who's actually pricing your cheapest model. If it's a host and not the lab, check that the host still lists it at that price before you renew the budget. The lab's own rate for the same model may be several times higher.

Every figure above is as of September 1, 2026, and is fixed in the dated report at modelpricewatch.com/reports/state-of-llm-pricing-2026-09. The live index is at modelpricewatch.com/price-index, with the methodology and the full price history dataset on Hugging Face (CC-BY-4.0). Every price links to the vendor page it came from, with a capture timestamp.

Disclosure: I maintain ModelPriceWatch.

If you run DeepSeek in production: did you notice the August 16 change, and when? I'm trying to work out how many teams found out from the invoice.

OpenAI cut a model's price 80% and told nobody. It took me 23 days to notice — and I run a price tracker.

Roman Shumyatsky — Mon, 03 Aug 2026 13:30:02 +0000

Sometime after July 9th, OpenAI changed the price of GPT-5.6 Luna from $1.00/$6.00 per million tokens to $0.20/$1.20.

That's an 80% cut on a current frontier-tier model. There was no announcement. No changelog entry. No email. The pricing page just quietly said something different one day.

I run a site that tracks LLM API pricing across every major provider. I didn't notice for 23 days. My own tracker kept publishing the old, higher numbers that entire time.

I want to talk about why, because the reason is more interesting than the mistake.

What actually moved

Two models in the same family, caught in the same sweep:

Model	Input (was → now)	Output (was → now)	Blended	Change
GPT-5.6 Luna	$1.00 → $0.20	$6.00 → $1.20	$2.25 → $0.45	−80%
GPT-5.6 Terra	$2.50 → $2.00	$15.00 → $12.00	$5.63 → $4.50	−20%
GPT-5.6 Sol	$5.00 (unchanged)	$30.00 (unchanged)	$11.25	—

Blended figures are 3 parts input to 1 part output, which is roughly what a real chat or RAG workload looks like. Straight input/output averages make cheap-input models look worse than they are.

Three things convinced me this was a genuine vendor change rather than me misreading a page:

Batch and Flex tiers moved in exact lockstep — both landed at precisely half the standard rate, the same relationship they had before. A scraping error doesn't preserve internal ratios.
Sol didn't move at all. A parsing failure would have mangled all three rows in the family, not two.
The old numbers were themselves two-source verified on July 9th. The before-state wasn't a guess.

So: a real cut, silently shipped.

Why nothing caught it

This is the part worth your attention if you're building anything that depends on someone else's pricing.

There is no changelog for API pricing. Not at OpenAI, not at Anthropic, not at Google. There's a pricing page, it renders a number, and the number is whatever it is today. No version history, no RSS feed, no webhook, no deprecation notice. If you want to know what changed, you have to have written down what it was before.

In my case three separate safety nets all failed at once, and they failed in an instructive way:

The community datasets didn't have it. LiteLLM — which a huge amount of tooling quietly depends on for pricing — has never carried gpt-5.6-* entries at all. If your cost estimates come from a community price map, understand that absence looks exactly like nothing changed.
My weekly verification sweep never selected it. The sweep re-checks a rotating basket of models against first-party pricing pages. Luna wasn't in the basket. Nothing was wrong with the sweep; it just wasn't looking there.
The one system that knew, told me uselessly. I had a coverage tripwire that correctly emitted "a wrong price here would be invisible" for exactly this model. It printed that inside a 375-line wall of warnings, and then suggested I fix it by mapping the model in a LiteLLM ID file — for a model LiteLLM does not carry. A warning whose suggested remedy is impossible is not a warning. It's noise with a guilty conscience.

The lesson I actually took from this: a signal that already exists and gets ignored is an enforcement problem, not a detection problem. I didn't need a better detector. I needed the existing one to fail loudly instead of logging politely. That fix — a tripwire that breaks the build rather than adding a line to a log nobody reads — is what shipped alongside the corrected prices.

What six weeks of tracking actually shows

Since I've been recording every price across every provider daily, I can say some things about the market that aren't obvious from any single pricing page.

Frontier intelligence currently costs $4.66 per million tokens.

That's an equal-weighted, chain-linked index across nine frontier models from nine different labs — OpenAI, Anthropic, Google, xAI, DeepSeek, Alibaba, Mistral, Z.AI, and Moonshot. It's down 3.7% since late February, and it has been completely flat for the last 7 days.

Three findings from that basket surprised me:

1. The cheap end is absurdly cheap, and it isn't bad. DeepSeek V4 Pro sits at $0.544 blended — roughly one twentieth of GPT-5.6 Sol at $11.25 — while scoring 71.5 on the Vellum leaderboard against Sol's 83.8. Normalize that to cost per benchmark point and DeepSeek costs $0.0076 per point versus an index average of $0.0637. It is about eight times more cost-efficient than the average frontier model. Whether the last 12 benchmark points are worth a 20× price premium is a real engineering decision, and most teams never explicitly make it.

2. Open weights are cheaper, but not by much. Open-weight models in the basket average $4.08 blended; closed models average $4.83. That's a spread of 75 cents per million tokens — far narrower than the open-source-is-basically-free intuition suggests. If you're choosing open weights, do it for the portability and the fine-tuning, not the token price.

3. The frontier turns over shockingly fast. In two weeks the basket had five model successions: GPT-5.5 → GPT-5.6 Sol, Grok 4 → Grok 4.5, Claude Opus 4.8 → Opus 5, Qwen3-Max → Qwen3.7-Max, plus Kimi K3 entering as a new constituent. Five of nine slots changed in fourteen days. Any cost model you built a month ago is describing models that are no longer the current ones.

Prices move in both directions too, which people forget. Over the same window Mistral raised Mixtral 8x7B Instruct 29.6% ($0.54 → $0.70) and Mistral Small 3.2 24B 36.4% ($0.08/$0.20 → $0.10/$0.30). Nobody announced those either.

What to actually do about it

Concrete, in rough order of effort:

Pin the price in your cost model, with a date. Not "GPT-5.6 Luna costs $1" but "GPT-5.6 Luna cost $1.00/$6.00 as of 2026-07-09." A cost estimate without an as-of date is a number pretending to be a fact. This is the single highest-value habit here and it costs you nothing.

Re-verify before anything that depends on the number. Budget approvals, model-selection decisions, customer-facing pricing. Five minutes on the vendor's own pricing page beats a three-week-old cached figure — as I demonstrated the hard way.

Don't trust a community price map as a source of truth. They're genuinely useful and they're maintained by good people, but coverage gaps are silent. A model that isn't listed doesn't look like a gap, it looks like nothing to report.

Compute blended cost with your real ratio. A summarizer that reads 50k tokens and writes 500 has completely different economics from an agent loop that generates constantly. The advertised "cheap" model flips depending on which one you are.

Check whether prompt caching changes the answer. For anything re-reading the same context — agents, RAG, long chats — cached input rates can move the ranking more than the headline price does. It's the most commonly ignored variable in these comparisons.

The uncomfortable conclusion

I built a tool specifically to catch this class of problem, and it still took me 23 days to spot an 80% price cut on a current model from the largest provider in the space.

That's not a story about my tool being bad. It's a story about how much of this ecosystem runs on numbers nobody is actually watching. If a dedicated tracker with daily snapshots and a verification sweep can carry a wrong price for three weeks, the spreadsheet where you modeled your unit economics in June is not in better shape.

Write down the date next to the price. That's the whole takeaway.

The index numbers above are live at modelpricewatch.com/price-index, with the full methodology and a monthly State of LLM Pricing report. Every price links to the vendor page it came from, with a capture timestamp.

Disclosure: I maintain ModelPriceWatch.

What's the oldest price still sitting in your cost model? Go check it — I'd genuinely like to know how many of you find a stale one.

Sonnet 5 vs GLM-5.2 vs everyone: how to pick the cheapest LLM API in 2026

Roman Shumyatsky — Sat, 04 Jul 2026 05:10:24 +0000

Two frontier-class models just launched weeks apart — Anthropic's Claude Sonnet 5
(closed, $2/$10 per 1M launch pricing) and Z.AI's GLM-5.2 (open-weight, MIT, ~$1.40/
$4.40 across hosts) — and the first question everyone asks is "which is cheaper?"
The honest answer: it depends on your token mix, your tier, and whether cached
input matters. Here's a repeatable way to answer it for your case, using live,
verified pricing.

1. Normalize everything to $/1M tokens

Providers quote prices in incompatible units — per-1K, per-1M, sometimes per-image
or per-character — and split input, output, and cached-input. Before you can
compare anything, convert all of it to dollars per 1 million input tokens and
per 1 million output tokens. (This is the single biggest source of "wait, that's
cheaper than I thought" errors.)

2. Separate the question by tier

Comparing a frontier flagship to a budget model on price alone is meaningless.
Bucket first, then compare within a bucket:

Flagship / frontier: the spread is real. The cheapest flagship-class model right now is about $1 / $2 per 1M (in/out); the priciest frontier tier runs up to $30 / $180. Same nominal tier, a 30-90x spread — which is exactly why you bucket first. Sonnet 5 lands mid-tier on price despite frontier capability; GLM-5.2 is the cheapest open option at that level.
Budget / fast: the floor is far lower than most people assume — ~$0.017-$0.05 / 1M input for capable small models.
Embeddings: a near-commodity at ~$0.02 / 1M across several providers.
Open-weight, multi-host: the same open model (GLM-5.2, DeepSeek, Qwen) is often served by several providers at different prices — compare hosts, not just models.

3. Weight by your actual token ratio

A summarizer is input-heavy; a code generator is output-heavy. Output usually
costs 3-5x input, so a model that looks cheap on input can lose on a
generation-heavy workload. Multiply each rate by your real volume — don't eyeball
the sticker price.

4. Don't forget cached input

For RAG and agent loops you re-send the same context constantly. Cached-input
pricing is often a huge discount — Sonnet 5's cache hits are 90% cheaper than
fresh input ($0.20 vs $2.00 /1M) — and it can flip the ranking entirely. If your
workload is cache-heavy, rank by cached-input price, not raw input. (There's a
live ranking of caching-capable APIs
if you want the current order.)

5. Use live data, not a blog post's snapshot

Prices move — Sonnet 5's own launch pricing reverts from $2/$10 to $3/$15 on Sep 1,

A table you screenshot today is wrong next month. I maintain Model Price Watch, which tracks 159 models across 24 providers and re-verifies prices against each provider's official pricing page 3x a day. If you'd rather script it, there's a free no-key JSON API: https://modelpricewatch.com/api/v1/models.json.

Worked example: for a chat product doing ~2M input / 0.5M output tokens a day, run
those numbers through a cost calculator across your shortlist — and if you re-send
a big system prompt each call, add the cached-input rate. The difference between
Sonnet 5 with caching and a naive flagship default can be the majority of your bill.

Disclosure: I build and maintain Model Price Watch. The method above works with
any pricing source — I just happen to keep one current.