In 2024, the fact that a Chinese open-weight model matched a US frontier model at a fraction of the price was an interesting research result. By mid-2026 it is a line item that finance will ask you about. When one option costs $0.28 per million output tokens and another costs $30, and both score in the high 80s on the same coding benchmark, "we use the best model" stops being a strategy and starts being an unexamined default.
This guide covers what has actually changed, where the cheap options genuinely fall short, why self-hosting is the most over-recommended idea in the field, and how mature teams are structuring their stack.
Where Prices Landed
The spread is now wide enough to change architecture decisions. Approximate rates per million tokens (input / output) as of August 2026:
- DeepSeek V4-Flash: $0.14 / $0.28 — after a permanent 75% price cut in May 2026.
- DeepSeek V4-Pro: $1.74 / $3.48, with promotional rates seen near $0.435 / $0.87.
- GLM 5.2: roughly $1–2 / $3–6, landing between the two DeepSeek tiers.
- Kimi K3: $3.00 / $15.00, with cached input at $0.30.
- Standard GPT-5.5: around $30 per million output tokens.
That is roughly a 100x range between the cheapest and most expensive credible option. On capability, DeepSeek V4-Pro reportedly matches GPT-5.5 and Claude Opus 4.7 on most agentic benchmarks at 10–13x lower output cost, and posts SWE-bench Verified scores in the high 80s. On the Artificial Analysis Intelligence Index v4.1 (June 2026), GLM 5.2 scores 51 and ranks fifth overall, ahead of MiniMax M3 and DeepSeek V4-Pro at 44 each.
The metric that matters is cost per accepted result, not cost per token. A US government CAISI evaluation found DeepSeek V4-Pro ranged from 53% cheaper to 41% more expensive than a US frontier model per correctly solved task, depending on the benchmark. If a model needs two attempts and a human correction, its token price is fiction. Measure on your workload.
Where the Cheap Models Genuinely Fall Short
The benchmarks compress a lot of nuance. Three gaps show up repeatedly in real deployments:
- Complex multi-constraint instructions. Give a model eight simultaneous requirements — format, tone, length, forbidden topics, required citations, a schema, an edge case, a fallback — and the frontier models hold all eight more reliably. Cheaper models drop one or two.
- Long-horizon agentic reliability. Over a 40-step task, a small per-step failure rate compounds. This is where the leaders still separate, and it is exactly the profile of the agent workloads most companies want to build.
- Multimodal depth. Improving fast, still uneven, particularly on dense documents, charts, and low-quality scans.
None of this makes cheap models unusable. It means the gap is concentrated in the hardest 10–20% of requests — which is precisely why routing works so well.
The Non-Price Factors That Decide Real Deals
In our experience these kill more deals than benchmark scores do.
Licensing is not a formality
"Open weight" covers wildly different terms. GLM 5.2 ships under permissive MIT. Kimi K3 uses an MIT-derived license with revenue-tiered commercial terms. MiniMax M3's custom license requires attribution, demands prior written authorization above $20M annual revenue, and bans military use. And for EU teams, the Llama EU restriction can eliminate a model before price ever enters the conversation.
Have someone read the actual license before the model reaches a product roadmap. Discovering a revenue threshold after launch is an expensive way to learn this.
Compliance documentation is a real product feature
Closed providers retain a structural advantage in guaranteed content filtering, detailed compliance documentation, and SOC 2 certification on the provider side. If your enterprise customers send security questionnaires, "we self-host an open-weight model" means you are the one who must answer them. That is sometimes fine and sometimes a deal-breaker.
Model origin is not the same as data location
A common confusion worth stating plainly: data sovereignty depends on deployment, not on where the model was trained. Calling a Chinese-developed model's hosted API sends your data to that provider. Running the same weights on your own EU infrastructure does not. Conversely, a US model's API still sends your data off-premises. Evaluate the deployment path, not the flag on the model card.
Two failure modes to avoid. One camp dismisses Chinese open-weight models on geopolitical grounds without ever running the numbers. The other celebrates the cost savings while ignoring data-handling exposure. Both are shortcuts around the same work: evaluating workload by workload. A public-repo code assistant and a system touching patient records are not the same decision.
Self-Hosting: The Most Over-Recommended Idea in AI
Downloading a checkpoint is the easy part. Serving it at production quality is where teams underestimate cost by an order of magnitude.
The core trap is architectural. Modern large open models are Mixture-of-Experts, which means total parameters drive your hardware bill, not active parameters. DeepSeek V4-Pro is 1.6 trillion total parameters. Kimi K3 is 2.8 trillion, shipping as a 1.56 TB download with 64+ datacenter accelerators recommended. The comfortable "only 104B active" number describes compute per token; it does not reduce what you must hold in memory.
Beyond hardware, the ongoing costs are the ones that surprise people: inference optimization, batching and throughput tuning, quantization quality trade-offs, monitoring, failover, capacity planning for spikes, and the engineering time to keep all of it working while your team also builds the actual product.
Self-hosting is right when all three of these hold:
- Data must stay on hardware you control for regulatory or contractual reasons.
- Workload is predictable enough that fixed infrastructure cost beats variable API cost.
- Your team can absorb the operational weight — or you are paying someone who can.
If only the first holds, look at hosted deployments in your own cloud tenancy before buying GPUs. If you are drawn to local deployment for privacy at a smaller scale, that is a genuinely different and much more tractable problem — see running LLMs locally with Ollama.
The Emerging Consensus: A Portfolio, Not a Winner
Serious AI stacks in 2026 are not standardizing on one model. They run four tiers:
- Closed frontier models for the hardest, highest-risk, and most ambiguous work.
- Hosted open-weight APIs for high-volume work where capability is sufficient and price dominates.
- Local or self-hosted models for privacy-constrained workloads and as a vendor-independence fallback.
- Task-specific small models for narrow jobs — classification, routing, extraction — where a large model is pure waste.
Practical routing guidance from teams running this in production: GLM 5.2 for repo-scale coding agents; DeepSeek V4 for high-throughput, multimodal, or cost-bound API work; Kimi K3 for front-end generation and long-horizon agent runs; a closed frontier model for everything hard or high-stakes.
One billing detail worth knowing
GLM offers a Coding Plan (Lite/Pro/Max/Team) with a predictable monthly bill. DeepSeek has no equivalent. That difference matters more than the per-token gap for bursty internal usage — one engineer burning 50 million tokens on a Friday-afternoon refactor is a budget event on metered pricing and a non-event on a flat plan. If your usage is spiky and internal, flat-rate pricing can beat a cheaper per-token rate outright.
How to Actually Run the Evaluation
A repeatable process, in order:
- Build a golden set. 50–200 real requests from your workload with known-good outputs. This is the single highest-leverage artifact you will create, and it keeps paying off every time a new model launches.
- Segment by difficulty. Separate easy, typical, and hard cases. Aggregate scores hide the fact that cheap models often handle 80% of traffic perfectly.
- Measure cost per accepted result. Include retries, human review time, and failure cleanup — not just the token bill.
- Check the licenses on every finalist before you build.
- Route, then verify. Send each segment to the cheapest model that passes, with a stronger model behind it as escalation.
- Re-run quarterly. Prices dropped 75% in a single move this year. Your optimal routing table has a shelf life.
Build the abstraction layer early. Keep model selection behind a single interface in your codebase so swapping providers is a config change, not a refactor. In a market where a competitive model launches every few weeks, the ability to switch cheaply is worth more than picking correctly today.
The Bottom Line
The open-weight vs closed question no longer has a general answer, and anyone offering one is selling something. What is true: capability is broadly available, price differences are enormous, licensing and compliance decide more deals than benchmarks, self-hosting is harder than it looks, and the winning architecture routes work across several models instead of betting on one.
The practical takeaway for most businesses is that the model is no longer the expensive or risky part of an AI project. Integration, data quality, evaluation, and governance are — which is where your attention and budget should go. Our mid-2026 industry reality check covers what the adoption data says about that, and the AI readiness checklist turns it into a pre-build to-do list.