The $1T Question:
How Do Frontier Models Get Priced?
How Do Frontier Models Get Priced?
From GPU clusters to your API invoice — every decision between them shapes the number you pay per million tokens.
⚡ Token Economics
🏗️ Architecture Cost Drivers
🌍 Regional Variation
🟢 Open Source Pressure
🚀 Startup Strategy
🔮 Future Trends
⚡ TL;DR — 60-second summary
- Tokens are the billing unit — roughly 0.75 words each. Parameters are the model's internal weights — they determine capability, not your invoice line item directly.
- Architecture drives the cost floor — model size (parameters), context window, inference hardware, and training amortization all set a minimum below which no company can survive.
- Input vs. output tokens are priced asymmetrically — outputs cost 3–5× more than inputs because they require sequential autoregressive generation; inputs can be processed in parallel.
- Open source has destroyed the mid-tier — Llama 4, Qwen 3, and Mistral Large can be self-hosted for ~$0.10/MTok compute cost, forcing commercial APIs to differentiate on reliability, speed, and ecosystem.
- Regional pricing is real — API prices in India and Southeast Asia are 20–40% lower for local providers; US frontier prices reach India at full cost plus FX markup.
- Startups building on LLMs should never pay list price — credits programs, committed use discounts, and batching can cut effective costs by 60–80%.
Tokens vs. Parameters — The Most Confused Terms in AI
Every conversation about LLM pricing collapses into confusion at exactly one point: someone mixes up tokens and parameters. They are completely different things that happen to sound related. Let's fix that once and for all.
Token
A token is a unit of text — the piece of text the model reads or generates one step at a time. Think of it as a building block of language, roughly equivalent to 0.75 English words on average.
Hello
,
world
!
How
are
you
📊 Billing unit — this is what you pay for
"Hello, world! How are you?" = 7 tokens ≈ $0.0000021 at GPT-4o rates
Parameter
A parameter is a learned weight inside the model — a number adjusted during training to encode knowledge. A 70B model has 70 billion such numbers. They determine capability and memory cost, not your bill.
Analogy: Parameters are the trained neurons in a brain. Tokens are the words you speak to it. You don't pay per neuron — you pay per word processed.
📊 Capability signal — affects price indirectly
More parameters → larger GPU memory footprint → higher serving cost → higher token price
🔑 The critical link: Parameters influence pricing indirectly — they determine how much GPU VRAM is needed to serve the model, which sets the compute cost per forward pass, which sets the floor for token pricing. A 405B model costs roughly 6× more to serve per token than a 70B model, all else equal.
The Tokenization Math
Understanding tokenization is essential to predicting your bills accurately:
📐 Tokenization Quick Reference
English text
~750 words per 1,000 tokens
Average: 4 chars/token
Code
~500–600 "words" per 1,000 tokens
Symbols count as tokens; whitespace is expensive
Non-English (CJK)
~250–350 characters per 1,000 tokens
Chinese/Japanese/Korean tokens cover fewer characters → higher per-word cost
⚠️ Non-English users pay more per word. A 1,000-word Chinese article uses ~3,000 tokens vs ~1,350 tokens for English. This is a structural economic disadvantage baked into BPE tokenizers trained on English-heavy data.
How Architecture Sets the Price Floor
No pricing team picks numbers out of thin air. Every price-per-token has a technical floor below which the company would lose money on every API call. Understanding that floor requires tracing the compute chain from research lab to your HTTP request.
Model Size
Parameters → VRAM
→
Context Window
KV cache memory
→
GPU Cluster
H100/B200 cost
→
Inference Cost
$/token at load
→
Training Amortization
CapEx spread over lifetime
→
List Price
$/MTok + margin
The Key Cost Drivers Explained
Model Size (Parameters)
Larger models require more GPU VRAM just to load. A 70B model needs ~140GB VRAM at FP16 — that's two H100 80GB GPUs minimum. A 405B model needs 8+ GPUs. Serving cost scales roughly linearly.
70B → ~$0.5/MTok floor · 405B → ~$3/MTok floor
Context Window
Longer context = larger KV cache. Processing a 200K-token context window requires holding the attention keys/values for all prior tokens in memory. This balloons VRAM requirements mid-request.
128K context → 2× memory vs 8K context at same model size
Training Amortization
Training a frontier model costs $50M–$1B+. Companies must recover this cost over the model's commercial lifetime through API revenue. This creates a pricing floor independent of per-token inference cost.
GPT-4-scale training: ~$100M over 3-year lifetime → $33M/year fixed overhead
Infrastructure Overhead
Load balancers, redundancy, failover, security, compliance, support, and data-center operations add 40–80% on top of raw GPU compute cost. Enterprises demand 99.9%+ SLAs.
Typical ops multiplier: 1.5–1.8× on raw compute
Output Token Generation
Output tokens are autoregressive — each token is generated one at a time, serially. Input tokens can be processed in a parallel forward pass. This is why outputs are 3–5× more expensive than inputs.
Claude Sonnet: $3/MTok input · $15/MTok output (5× ratio)
Quantization & MoE
INT8/INT4 quantization halves memory at small quality cost. Mixture-of-Experts (MoE) activates only a subset of parameters per token — Mixtral 8×7B is effectively a 47B dense model but only uses 12B per token. Cost disruption incoming.
MoE efficiency: 2–4× lower serving cost vs equivalent dense model
The Pricing Parameters — What Appears on Your Bill
Different companies use different unit economics, but they all decompose to the same underlying structure. Here are every dimension that affects your actual invoice:
📊 Input vs Output Token Price Ratio — Major Models (June 2026)
GPT-5 (OpenAI)
$5 / $40 per MTok
Claude Opus 4.8
$15 / $75 per MTok
Bar = input price relative to most expensive; right = input/output price
Claude Sonnet 4.6
$3 / $15 per MTok
Gemini 2.5 Pro
$1.25 / $10 per MTok
Gemini 2.5 Flash
$0.15 / $0.60 per MTok
Llama 4 Maverick (API)
$0.20 / $0.60 per MTok
Mistral Large 2
$2 / $6 per MTok
* Prices as of June 2026. Output tokens are 3–8× input price across all providers.
Every Pricing Dimension You'll Encounter
Input Tokens
Your prompt, system message, tool definitions, and any injected context. Processed in a single parallel forward pass — cheapest dimension.
Typical range: $0.10–$15 per million tokens
Output Tokens
Every token the model generates. Autoregressive: serial, one-at-a-time, latency-sensitive. Always more expensive. Drives the majority of API cost for generation-heavy workloads.
Typical range: $0.40–$75 per million tokens
Cached Input Tokens
Prompt caching lets repeated prefixes (system prompts, RAG context) be stored server-side and reused. A cached input token costs 80–90% less than a fresh one.
Anthropic: $0.30/MTok cached vs $3/MTok uncached (Sonnet)
Batch API
Submit thousands of requests asynchronously; results returned within 24 hours. The provider can optimize hardware utilization. Typically 50% discount vs real-time API.
OpenAI Batch API: 50% off. Anthropic: same.
Image / Multimodal Tokens
Images are "tokenized" at a fixed cost per image (or per tile for large images). A 512×512 image typically costs ~170 tokens; a 2K×2K image ~1,000 tokens.
GPT-4o image: ~$0.002–$0.01 per image depending on resolution
Reasoning / Thinking Tokens
Extended thinking models (o3, Claude Sonnet extended) generate internal chain-of-thought that is billed separately, often at output token rates. Can 10–100× your inference cost on complex tasks.
o3: thinking tokens billed at output rates; capped with thinking budget
The Full Commercial Model Pricing Table
All prices in USD per million tokens as of June 2026. "Context" = maximum supported window.
| Model | Input $/MTok | Output $/MTok | Context | Cached Input | Tier | Strengths |
|---|---|---|---|---|---|---|
| GPT-5OpenAI | $5.00 | $40.00 | 1M | $1.25 | FrontierReasoning | General SOTA, coding, long-context |
| Claude Opus 4.8Anthropic | $15.00 | $75.00 | 200K | $1.50 | FrontierReasoning | Safety, long-form, agentic tasks |
| Claude Sonnet 4.6Anthropic | $3.00 | $15.00 | 200K | $0.30 | FastCode | Best-in-class coding, balanced cost |
| Claude Haiku 4.5Anthropic | $0.80 | $4.00 | 200K | $0.08 | Fast | High-volume, latency-critical |
| Gemini 2.5 ProGoogle DeepMind | $1.25 | $10.00 | 1M | $0.31 | FrontierVision | Multimodal, long context, Google integration |
| Gemini 2.5 FlashGoogle DeepMind | $0.15 | $0.60 | 1M | $0.04 | FastVision | Cheapest production-grade multimodal |
| GPT-4oOpenAI | $2.50 | $10.00 | 128K | $1.25 | VisionFast | Proven workhorse, broad capability |
| o3OpenAI | $10.00 | $40.00 | 200K | $2.50 | Reasoning | Advanced math, science, STEM reasoning |
| Mistral Large 2Mistral AI | $2.00 | $6.00 | 128K | — | Strong | EU-based, GDPR-compliant, multilingual |
| Llama 4 Maverick (API)Meta / Groq / Together | $0.20 | $0.60 | 1M | — | OpenFast | Price leader, open weights available |
| Qwen3-235B-A22B (API)Alibaba / Together | $0.15 | $0.60 | 128K | — | OpenMoE | Strong multilingual, Chinese-first |
| DeepSeek-V3 (API)DeepSeek | $0.27 | $1.10 | 128K | $0.07 | OpenCode | Best open-source code model, MoE architecture |
Open Source Models — The Self-Hosted Alternative
When you self-host, you pay only compute. The model weights are free. Here's what the major open models cost to run on cloud GPU:
| Model | Parameters | License | Est. Self-Host $/MTok | Min GPU Setup | API Equivalent Cost |
|---|---|---|---|---|---|
| Llama 4 ScoutMeta AI | 17B active (109B total MoE) | Llama 4 | ~$0.05 | 2× A100 40GB | ~$0.20 on Groq |
| Llama 4 MaverickMeta AI | 128B active (400B total MoE) | Llama 4 | ~$0.15 | 8× H100 80GB | ~$0.20 on Together |
| Qwen3-72BAlibaba Cloud | 72B dense | Apache 2.0 | ~$0.12 | 4× A100 80GB | ~$0.30 on Together |
| DeepSeek-V3DeepSeek | 671B (37B active MoE) | MIT | ~$0.18 | 8× H100 80GB | ~$0.27 on DeepSeek API |
| Mistral Small 3.1Mistral AI | 24B dense | Apache 2.0 | ~$0.06 | 2× A100 40GB | ~$0.10 on Mistral API |
| Gemma 3 27BGoogle | 27B dense | Gemma | ~$0.07 | 2× A100 40GB | ~$0.12 on Vertex |
💡 The Self-Host Crossover Point: If your monthly token volume exceeds ~50M tokens, self-hosting a Llama 4 Maverick or DeepSeek-V3 on cloud GPUs typically breaks even vs the cheapest managed APIs. At 500M tokens/month, the savings approach $50K–$70K/month vs commercial frontier APIs.
The Naming Zoo: Tokens, Credits, Messages, and Units
Every provider chose a different word for "the thing you pay per." Here's the full taxonomy:
Tokens
Used by: Anthropic, OpenAI, Mistral, Cohere, Together
Input tokens (prompt)
Output tokens (completion)
Cached tokens (stored prefix)
Reasoning tokens (internal CoT)
Credits
Used by: Runway, Midjourney, ElevenLabs, Stability AI, Pika
1 image generation = 4 credits
1 minute video = 40 credits
Credits expire monthly
Often bundled in subscription tiers
Messages / Calls
Used by: ChatGPT Plus (old), Perplexity Pro, some copilots
X messages per day (hard cap)
Fast messages vs slow messages
Pro = unlimited (rate limited)
Consumer-facing abstraction over tokens
Compute Units
Used by: Google Vertex AI, AWS Bedrock
Model Units (Vertex)
On-demand vs provisioned
Character-based (older APIs)
Dimension-based for embeddings
Subscriptions
Used by: ChatGPT Plus/Pro, Claude Pro/Max, Gemini Advanced
Flat monthly fee ($20–$200)
Hides token mechanics from users
Rate limits instead of token limits
Includes access to latest models
Enterprise Seats
Used by: Salesforce Einstein, Microsoft Copilot, ServiceNow
Per-user per-month licensing
Token pools shared across org
Volume discounts at scale
Often includes compliance add-ons
How Companies Differentiate Beyond Raw Price
In a market where open-source models are free and managed API prices converge toward compute cost, labs must differentiate on non-price dimensions to maintain margins:
Speed & Latency SLAs
Time-to-first-token, throughput guarantees
Enterprises will pay 2–5× more for guaranteed sub-200ms TTFT and 99.9% uptime SLAs. Real-time applications (chatbots, voice, copilots) are latency-bound, not cost-bound. Groq's LPU architecture achieves 800+ tokens/second — 10× GPU speed.
GroqCerebrasOpenAI Realtime API
Data Privacy & Compliance
SOC2, HIPAA, GDPR, FedRAMP
Healthcare, finance, and government pay 30–50% premiums for zero-retention data policies, on-premises deployment options, audit logs, and regulatory certifications. Anthropic's Claude for Enterprise and Azure OpenAI's compliance tier are priced accordingly.
Azure OpenAIAnthropic EnterpriseMistral (EU)
Ecosystem Lock-in
Tooling, SDKs, integrations
OpenAI's Assistants API, function calling spec, and DALL-E integration create switching costs that justify pricing premiums. Once your product is built around an API's specific features (structured outputs, vision, tool use syntax), migration is expensive.
OpenAI AssistantsClaude Tool UseVertex AI Agents
Fine-tuning & Custom Models
Domain-specific capability jumps
Fine-tuning a GPT-4o-mini on proprietary data can outperform GPT-4o on that specific domain at 10× lower inference cost. Fine-tuned models are charged per custom-model token (typically 2–4× base model price) plus a training cost.
OpenAI Fine-tuneTogether Custom ModelsVertex AI Tuning
Safety & Moderation
Constitutional AI, built-in guardrails
Anthropic's Constitutional AI and built-in safety layers mean enterprises spend less on external moderation pipelines. This "safety tax" is priced into Anthropic's higher rates but delivers measurable downstream savings for high-risk deployments.
Claude Constitutional AIOpenAI Moderation API
Multimodal & Native Features
Vision, audio, code execution, search
GPT-4o's native voice, Gemini's native multimodal training, and Claude's computer-use capability command premiums because they eliminate the need for stitched-together pipelines. Integrated is worth more than assembled.
GPT-4o VoiceGemini VideoClaude Computer Use
ROI for Model Companies — The Unit Economics
The AI lab business model is unlike typical software. Marginal cost is non-zero (unlike SaaS), training cost is massive upfront, and competitive dynamics force price cuts even as quality improves. Here's how the economics actually work:
📊 Estimated Unit Economics — GPT-4-class Model (illustrative)
List Price (output)
$15.00
− GPU Compute Cost
−$5.00
− Ops & Infra
−$3.00
− Training Amortization
−$2.00
− Safety/RLHF/Evals
−$1.00
= Gross Margin
$4.00
* Illustrative model. Actual margins vary widely. OpenAI reportedly ~45% gross margin. Input tokens are much cheaper to serve. Volume discounts compress margins further.
Why Companies Chose Specific Price Points
The $15/MTok output price for mid-tier models wasn't arbitrary. Several forces anchored the market:
📉 Price has fallen 150× in 3 years for comparable capability. GPT-4's $30/MTok input in June 2023 vs Llama 4 API's $0.20/MTok today for similar quality. This is not a sustainable loss leader — it's the combination of hardware efficiency gains (H100 vs A100), software optimization (FlashAttention, speculative decoding), and scale economics hitting simultaneously.
Regional Pricing — It's Not a Global Flat Rate
The global frontier AI market has significant regional price variation — both from local providers optimizing for their markets and from the structural cost disadvantage of non-English tokenization.
🇺🇸
United States
Price benchmark: 1.0× (reference)
Major APIs: OpenAI, Anthropic, Google, AWS Bedrock
Currency: USD, no FX overhead
Regulatory: No special restrictions. EO on AI compute in effect.
Note: All frontier models available. GPT-5, Claude, Gemini all direct.
🇪🇺
Europe (EU)
Price benchmark: 1.05–1.15× (data residency premium)
Major APIs: Azure OpenAI EU, Mistral (Paris), Google EU
GDPR: Data must stay in EU — triggers EU-region routing
EU AI Act: Compliance overhead starts 2025, adds ~10% ops cost
Mistral advantage: Native EU provider, no cross-border data transfer risk
🇨🇳
China
Price benchmark: 0.3–0.5× for domestic models
Major APIs: Qwen (Alibaba), Ernie (Baidu), DeepSeek, Zhipu
US frontier: Not available directly (export controls)
Competition: Intense domestic price war — Qwen3 at ¥0.5/MTok
Note: Cheapest frontier-quality APIs globally for Chinese users
🇮🇳
India
Price benchmark: 1.0× for US APIs + FX markup
Major APIs: Sarvam AI, Krutrim, AWS/Azure India regions
IndiaAI Mission: Subsidized GPU compute for startups
Local models: Sarvam-1 at ~$0.05/MTok for Hindi/Indic languages
Challenge: INR/USD FX adds 2–5% effective cost; talent cost advantage offsets
🇯🇵 🇰🇷
Japan / South Korea
Price benchmark: 1.1–1.3× (CJK tokenization overhead)
Japan: SoftBank + OpenAI joint venture with local pricing
Korea: Naver HyperCLOVA X provides KRW-denominated pricing
CJK penalty: Japanese/Korean text uses 2–3× more tokens per word
Note: Local models necessary for cost efficiency in these languages
🌍
Global South
Price benchmark: 1.0–1.2× USD + FX overhead
Challenge: USD pricing + weak local currencies = effective 1.3–2× real cost
Access: OpenAI + Anthropic full pricing, no purchasing parity programs
Opportunity: Open-source self-hosting most viable here
Note: Africa, SE Asia, LATAM underserved by frontier lab PPP programs
The Open Source Economy — How Free Models Shape Commercial Pricing
Open-source LLMs are the most powerful deflationary force in the API market. Meta's decision to release Llama weights changed the competitive dynamics permanently. Here's how the open-source economy works and what it means for commercial pricing:
🔄 The Open Source → Commercial Pricing Feedback Loop
Meta releases Llama weights (free)
→
Inference providers (Groq, Together, Replicate) offer cheap managed Llama APIs
→
Price floor for "good enough" drops to ~$0.20/MTok
↓
OpenAI / Anthropic forced to cut GPT-4o / Sonnet prices
→
Margin pressure → labs focus on frontier capability + enterprise features
→
Free tier + subscription model subsidizes API usage
Net effect: Open source eliminated the "capable but expensive" mid-tier. Commercial APIs must now be either (a) frontier quality (GPT-5, Claude Opus) or (b) enterprise-grade infrastructure (compliance, SLAs, support). The generic "good enough" API is dead.
The Capability Tiers — Where Open Source Wins and Loses
Model Capability Pyramid
🥇 Frontier Reasoning (GPT-5, Claude Opus 4.8, Gemini 2.5 Pro) — Commercial onlyOpen source can't yet match · $15–75/MTok output
⚡ High-capability fast (Sonnet, GPT-4o, Gemini Flash) — Commercial, narrowing gapSome open parity emerging · $3–15/MTok
🟡 Strong general (Llama 4 Maverick, Qwen3-72B, DeepSeek-V3) — Open = CommercialOpen source matches commercial · $0.15–0.60/MTok
🟢 Efficient small (Llama 4 Scout, Gemma 3 27B, Qwen3-8B) — Open wins on costOpen source self-host beats all commercial · <$0.10/MTok
🔵 Edge / Local (Phi-4-mini, Gemma 3 4B, Qwen3-1.7B) — Open onlyOn-device, zero API cost · runs on laptop
Startup Pricing Playbook — How to Think About This
🚀 The Startup LLM Pricing Playbook
For founders building AI-native products — how to structure your model economics before you scale.
1
Never pay list price in prototype phase
Every major lab has a startup credits program. Anthropic credits for startups, OpenAI startup program (via partner VCs), Google for Startups, AWS Activate. These provide $5K–$100K in free credits.
💡 Apply before you write a single line of product code. Credit programs have rolling windows — you can often get multiple batches if you time them correctly.
2
Model your cost-per-request from Day 1
Calculate: average input tokens per request × input price + average output tokens × output price. If your average call uses 2,000 input tokens and 500 output tokens at GPT-4o prices, that's $0.005 + $0.005 = $1.00 per 100 calls. At 10K daily users doing 5 calls each = $500/day = $15K/month.
💡 Track token ratios per product feature. Some features are 90% input (search, classification); others are 90% output (generation, code). Price each separately.
3
Build on the cheapest model that meets your quality bar
Don't default to the frontier model. Most classification, extraction, and summarization tasks can be handled by Haiku (0.8¢/MTok) or Gemini Flash (0.15¢/MTok) with careful prompting. Reserve frontier models for tasks where quality provably matters.
💡 Run an A/B eval between frontier and small models on your actual use case. The quality gap is often 5–10%, not 30–50% as marketing implies.
4
Use caching aggressively for repeated prompts
If your system prompt is 2,000 tokens and you call it 100K times/day, you're spending $600/day on identical tokens. Prompt caching (Anthropic, OpenAI) stores repeated prefixes server-side at 80–90% discount. This single optimization can cut your bill by 40–60% for many apps.
💡 Structure your prompts: system prompt first (cache this), then user message. Cache duration: Anthropic = 5 min, OpenAI = 1 hour sliding window.
5
Use Batch API for non-real-time workloads
If users don't need instant results — report generation, data enrichment, content processing, document analysis — the Batch API gives you 50% off. For background jobs running at night, this is pure margin improvement with zero UX impact.
💡 Move background processing (analytics, content indexing, email summaries) to batch mode. Real-time is for interactive UI only.
6
Know your open-source crossover point
At what monthly token volume does self-hosting beat managed APIs? The answer is roughly: when your monthly spend on a given model exceeds ~$5K–$10K/month, a dedicated self-hosted Llama 4 Maverick or Qwen3 instance on cloud GPU breaks even within 2–3 months.
💡 Don't self-host at <$5K/month. Ops overhead (reliability, scaling, updates, security) costs more than the API savings. The crossover is real but it's not at $500/month.
7
Price your product around value, not your API cost
The biggest pricing mistake: charging per-token to your customers. Your users don't know what a token is — and shouldn't. Price on value metrics: per document processed, per user per month, per insight generated. This decouples your growth from your cost, and your margins improve as models get cheaper.
💡 Example: A contract analysis tool charges $0.50 per contract reviewed. At current API prices, that costs $0.02 in tokens. 96% gross margin — and as LLM prices fall, margins expand without a price change.
8
Hedge your provider dependency
Never be 100% dependent on a single API. Price drops, model changes, outages, and policy shifts happen. Design your architecture to support model swapping — use a unified interface (LiteLLM, OpenRouter, or your own router) that lets you switch Claude ↔ GPT ↔ Gemini with a config change.
💡 Multi-provider routing also lets you do real-time cost optimization: if GPT-5 drops its price 30%, your router immediately shifts traffic without an engineering sprint.
The Future of Model Pricing — What's Coming
Continued Price Collapse
Hardware efficiency (B200/GB300 over H100), software optimization (speculative decoding, MoE, quantization), and competition will continue to push prices down 2–5× per year. What costs $3/MTok today will cost $0.60/MTok in 2028.
↓ Prices falling
Reasoning Token Inflation
As thinking/reasoning models become standard, average cost-per-task rises even as cost-per-token falls. A task that took 500 tokens with GPT-4 may take 5,000 tokens with o3 (and get better results). Users pay more overall for harder tasks.
↑ Task costs rising
Outcome-Based Pricing
The frontier: Cognition (Devin), Anthropic, and OpenAI are experimenting with "pay-per-task" — charging for completed coding tasks, resolved tickets, generated reports — not tokens consumed. This aligns provider and customer incentives perfectly.
→ Emerging model
Speculative Pricing & MoE
Mixture-of-Experts and speculative decoding change the cost model entirely — not all tokens cost the same to generate. Dynamic pricing per "token difficulty" is technically possible and may emerge as a premium optimization layer for sophisticated buyers.
→ Technical frontier
Sovereign Pricing Tiers
As sovereign AI policies mature, expect localized pricing in EUR, INR, JPY with regional data residency guarantees. EU AI Act compliance costs will be passed through as a visible line item. Purchasing power parity models may emerge for Global South access.
→ Policy-driven
Open Source Floor Effect
Llama 5, Qwen 4, and Mistral V3 will match or exceed today's GPT-4o by 2027. This creates a hard floor: no commercial API above those quality tiers can charge more than ~2–3× the self-host cost without enterprise features justifying the premium.
↓ Commercial pressure
Best Videos to Watch on This Topic
The Bottom Line
Frontier model pricing is not arbitrary. Every number on every API pricing page is the output of a chain: model size → hardware requirements → serving cost → amortized training → ops overhead → competitive dynamics → list price. Understanding that chain lets you predict price movements, choose models strategically, and build products whose economics improve automatically as the underlying infrastructure gets cheaper.
For companies: the mid-tier is dead. You are either a frontier lab charging for capability that open source cannot replicate, or an infrastructure provider charging for reliability, compliance, and ecosystem that self-hosting cannot match. There is no sustainable business in the middle.
For startups: your competitive advantage is not choosing the right model today — it is building an architecture that lets you swap models cheaply tomorrow. The model that wins the next benchmark round will be 3× cheaper and 20% better than the one you're using now. Build for the swap, not the lock-in.
Token prices are falling 2–5× per year. The question isn't which model to use today — it's whether your product is architecturally ready to capture the value as costs collapse toward zero.