OpenAI Just Cut GPT Prices 80%. While Filing for Its IPO. Something Doesn’t Add Up.

I’ve been covering AI long enough to recognize when a story is being framed wrong. The big news this week — that OpenAI and Anthropic have slashed the cost of their flagship language models by up to 80% in the span of just a few months — is being covered as a win for developers. And it is. But the more interesting story is the one that sits quietly behind the price cuts, hiding in plain sight.

Both companies filed S-1 documents this year seeking multi-trillion-dollar valuations. Anthropic’s IPO, expected in November, values the company at $2 trillion on an annualized revenue run rate that only recently crossed $65 billion. OpenAI is targeting a similar window. And yet here they are, competing with each other to see who can charge less for the thing they spent billions of dollars building. This is not the behavior of companies with durable moats. It’s the behavior of companies racing to the bottom — and hoping you won’t notice until after they ring the bell.

What Actually Happened to Prices

Let me put the numbers on the table, because “80%” is an abstraction until you see what it means in practice.

OpenAI’s GPT-5.6 Luna dropped from $1.00 per million input tokens to $0.20 in July — a flat 80% cut. By September, GPT-6 Sol (the successor to GPT-5.6 Sol) launched at $2.00/$10.00 per million input/output tokens, down from $4.00/$20.00 just months before. Anthropic’s Opus 5.5 trimmed input from $5.00 to $4.00 and output from $25.00 to $20.00. Cache reads, which are the dominant cost in agentic deployments, fell even harder: Claude Fable 5.1’s cache reads dropped 75%, from $1.00 to $0.25 per million tokens.

The cumulative effect, if you’ve been running agentic workloads on GPT-5.6 Sol since June and migrated through each new model tier, is a 75% reduction in per-agent-request cost. Chat workloads dropped about 62%.

These are not rounding errors. This is a price war.

The Real Numbers for Your Budget

Here is what this means in practice, using published per-1,000-request cost estimates for a typical agentic workload (a task with a large cached system prompt, a few tool calls, and moderate output):

Now let me do the math that no one else is doing: what this means at real deployment scales.

• Small deployment (100,000 agent requests/month):
• Sonnet 5.5: $1,600/month, or $19,200/year
• Luna: $125/month, or $1,500/year
• Difference: $17,700/year — about the cost of one junior developer’s monthly compensation

• Medium deployment (1 million requests/month — a serious SaaS product):
• Sonnet 5.5: $16,000/month, or $192,000/year
• Luna: $1,250/month, or $15,000/year
• Difference: $177,000/year — enough to fund a full-time ML engineer

• Large deployment (10 million requests/month — enterprise at scale):
• Sonnet 5.5: $160,000/month, or $1.92 million/year
• Luna: $12,500/month, or $150,000/year
• Difference: $1.77 million/year — a material budget line for any AI team

The implications compound: if you have been defaulting to Sonnet or Sol tier for every workload because “it’s the best,” you have likely been overpaying by a factor of 10 to 13 for tasks where a smaller model would do just as well. Rippling, Replit, and DataCamp have already moved workloads from Anthropic to OpenAI’s cheaper tiers. The ones who haven’t yet are burning money for no reason.

The Decision Framework You Actually Need

Most teams have not built a model-routing strategy. Most teams use one model for everything because it’s operationally simpler. The 2026 price landscape makes that decision increasingly costly.

Here is the framework I’d apply, with specific thresholds:

• Use Luna/Haiku tier ($0.60–$1.29 per 1,000 chat requests) when the task is:
• Classification or categorization with a defined label set
• Routing (deciding which agent or tool handles a request)
• Extraction of structured data from a document
• Summarization with no creative or analytical component
• Any task where you can validate correctness automatically

At 100K–1M requests/month, routing these to Luna saves $17K–$177K/year with no quality degradation on the right tasks.

• Use Sonnet/Sol tier (~$12–16 per 1,000 requests) when the task requires:
• Nuanced instruction-following across a complex multi-step flow
• Code generation beyond boilerplate
• Synthesis of multiple sources with non-obvious conclusions
• Customer-facing text where tone and quality matter

• Use Opus/Fable tier ($24–61 per 1,000 requests) only when:
• The task has failed or produced poor output on Sonnet/Sol in testing
• The cost of a wrong answer exceeds several hundred dollars (legal, medical, financial)
• You need the highest available cache-read efficiency on enormous system prompts (Fable 5.1’s $0.25/MTok cache read is now its strongest selling point)

• Consider self-hosted open-source (DeepSeek V4.1 Flash at ~$0.73 per 1,000 requests on hosted inference) when:
• You are above 10 million requests/month and have the engineering capacity to manage deployment
• Data sovereignty or air-gap requirements rule out third-party APIs
• Your task is well-defined enough to fine-tune a smaller model

The crossover point where self-hosting beats API cost is roughly 20 million agent requests/month for a team with dedicated MLOps capacity. Below that, the engineering overhead exceeds the savings.

The Contrarian Take: This Is Not Good News for OpenAI or Anthropic

Every coverage I’ve read frames these cuts as generosity from the AI giants, competitive innovation benefiting developers, a golden age of accessible AI. That framing is wrong, and I think it’s worth saying clearly.

When a product’s price falls 80% in six months, one of two things is true: either the cost to produce it fell dramatically (efficiency), or the company is under pressure to retain customers it would otherwise lose. In this case, both are true — but the second is the more important signal.

DeepSeek’s open-weight models are closing the quality gap faster than anyone expected. Inference providers are piling onto the open-weight ecosystem: OpenRouter now lists 29 providers for a single DeepSeek model variant. The switching cost between Anthropic and OpenAI — which was already low — is effectively zero with routing layers like OpenRouter. Kimi K3.1 Pro launched at roughly half the price of comparable frontier models. The market structure of AI APIs is converging toward commodity pricing.

This matters enormously during IPO season. A business that cannot sustain price premiums does not have a durable moat. What Anthropic and OpenAI are discovering — and what their S-1s are forced to partially disclose — is that the model itself is not the moat. The moat is everything else: enterprise security certifications, integration depth, agent frameworks, safety audit trails, the cost of switching away from the tool your 3,000 engineers already have in their workflow.

So the companies racing to cut model prices are, in effect, training the market to treat models as interchangeable. That’s the right long-term strategic move — anchor customers on the ecosystem, not the model — but it’s a counterintuitive one when you’re asking investors to value you at $2 trillion based on proprietary AI technology.

The AI moat debate just went from theoretical to proven-empirically-in-the-pricing-sheet.

Dated Action Checklist

If you run AI-powered products or infrastructure, here is what I would do and when:

By November 1, 2026: Pull your last 30 days of token usage from your API dashboard. Categorize every request type by whether it requires reasoning/creativity (Sonnet tier) or is primarily extraction/classification (Luna/Haiku tier). For most companies, 40–60% of requests are in the second category.

By November 15, 2026: Run a 2-week parallel test: route your classification and routing workloads to Luna or Haiku while keeping creative/complex tasks on Sonnet. Measure accuracy on the routable tasks and calculate your projected monthly savings.

By December 1, 2026: Implement a model routing layer. OpenRouter, LiteLLM, and Portkey all support dynamic routing by task type with fallback logic. Budget 2–3 engineering days. The annual savings at any significant scale make this the highest-ROI infrastructure project your team will touch this year.

By January 1, 2027: Review your API contract with Anthropic or OpenAI if you have enterprise pricing locked in before October 2026. Several of the price cuts represent significant decreases from prior list prices — if you negotiated a discount from old list prices, you may now be paying more than new customers who pay list. Get this renegotiated before your next renewal.

By Q2 2027: Revisit self-hosting at scale. Kimi K3.1 Pro and the next generation of DeepSeek models are tracking toward quality parity with mid-tier API models at 30–50% lower inference cost. The economics of self-hosting become viable at lower thresholds than they were six months ago.

What This Means

I’ll be direct: the 80% price drop is real money that most AI teams are leaving on the table by not routing workloads to the right model tier. Fix that first — it takes a week of engineering time and saves six figures annually at any serious deployment scale.

But watch what happens to these prices over the next 12 months. If they continue falling, the AI companies’ investment thesis — and their IPO valuations — rests entirely on something other than proprietary model advantage. The model is becoming infrastructure. The question for every AI investment and every AI product strategy in 2027 is: what is the actual moat, and does the person you’re paying for it understand that the model isn’t it?