Problem Solutions
AI Prices Fell Up to 80% Since June — So Why Is Your Bill Still High?
OpenAI and Anthropic quietly cut inference prices by up to 80% between June and September — and plenty of developers noticed nothing in their bills. An October 26 analysis that reached 194 Hacker News points and 218 comments puts the puzzle plainly: lower price per token changes the unit economics, but it does not automatically lower the production bill. The reason is that the headline input price is only one of five things you pay for, and the other four moved in the opposite direction. If your bill did not fall, it is probably not a billing error. It is the gap between the price list and the way your product actually uses models.
What actually got cheaper
The cuts are real, and they are large. OpenAI's July 30 announcement says GPT-5.6 Luna fell 80%, to $0.20 per million input tokens and $1.20 per million output tokens, while Terra fell 20%, to $2 input and $12 output. Anthropic's Opus 5.5 page reports $4 input, $20 output and $0.20 cache reads per million tokens, versus $5, $25 and $0.50 for Opus 5 — and Anthropic says its own tests show a 40% lower typical-workload cost, a vendor-reported result, not a promise for your workload. One analysis of the June-to-September collapse attributes it to three forces: Chinese competition, with DeepSeek's Flash V4 reportedly earning $38 per GPU-hour at $0.60 per million output tokens; better inference efficiency; and the simple fact that GPU capacity is perishable like airline seats — an unsold GPU-hour is gone forever, so providers would rather cut prices than leave capacity idle. IBM's CEO added a different pressure from the other side, telling investors that open-weight models now do routine jobs like email summarization and contract review at 10% of the cost on-prem, with 2–3 rack deployments. Multiple Hacker News commenters confirmed from personal rigs that they have not paid for a frontier model in months — while others noted that IBM is obviously talking its book, since it would like to sell you the accelerators to run those models.
Why your bill did not follow the price list
Production spend depends on cache reads, output length, routing, retries, and how many tasks your product now runs — not just the headline input price. Start with cache reads, which matter disproportionately for agentic coding: one commenter pointed out they can be 70–75% of total cost, because every tool call re-reads the conversation. A cut in fresh input price barely touches a bill dominated by cache reads. Then output length: output tokens cost several times input tokens, and agentic workflows generate far more of them — long reasoning traces, tool-call transcripts, retries. Routing matters too: if your product still defaults to a flagship model for every task, you are paying flagship rates for work a smaller model would do, and the price list does not fix a routing decision you never made. Retries are the silent multiplier: a failed tool call that retries twice costs three times, and nothing on the invoice labels it as a retry. And finally, volume: cheaper tokens mean your product now runs more tasks, for more users, more often. That is success, not waste — but it shows up on the same invoice as the price cut, and it can easily outrun it.
How to find out where your money actually goes
Do not switch models from a single blended price. First, separate your own logs into five buckets: fresh input, cached input, cache writes, output, and task success. The split will tell you which lever matters. If cache reads dominate, the fix is prompt caching discipline and shorter contexts, not a cheaper model. If output dominates, the fix is shorter responses, tighter instructions and fewer retries. If routing dominates, the fix is a smaller model for routine tasks and the flagship only where it earns its price — the AICC enterprise analysis from August found that teams routing across providers cut effective inference costs by up to 80% while holding benchmark scores flat, though that figure comes from a vendor's own aggregated data and should be read as a ceiling, not a promise. If retries dominate, the fix is better error handling, not cheaper tokens. And if volume dominates, the honest answer is that your bill is high because your product is busy — in which case the right question is cost per completed task, not cost per token. One developer's self-hosted playbook makes the point concretely: moving a RAG app from OpenAI to a single Hetzner GPU box cut a $490 monthly bill to $195, but at the price of slower latency, one locked-in model, occasional crashes and 3am pages. The cheapest token is not always the cheapest system. Measure cost per task, fix the biggest bucket first, and let the price list be the last thing you optimize — it has already done most of its falling.