The Bottom Line: Open-Source Model Spending Shifted
US enterprises spent roughly $176.8B on generative AI in 2026, and about 69% went to three leading proprietary vendors. Spending on open-source models flowed in the opposite direction: about 89% went to Chinese model providers. This article examines what is driving the shift. It covers falling prices, the surging token consumption of AI agents, the control that open weights give enterprises, and corporate migration case studies. It also offers a method for calculating task-level AI costs, with Python code and a step-by-step model replacement process, so enterprises can cut AI spending without compromising quality.
1. The Bottom Line: Open-Source Model Spending Is Reversing Direction
Start with the conclusion: spending on proprietary and open-source models is becoming concentrated in two nearly opposite ways.
Drawing on research from several industry research and consulting firms, US enterprise spending on generative AI in 2026 is projected at about $176.8 billion. Roughly 69% of that flows to three leading proprietary model vendors. Spending on open-source models goes the other way: about 89% is paid to Chinese model providers.
Breakdown by share:
- One Chinese vendor’s model family accounts for 61%, ranking first
- Other Chinese open-source models together account for about 21%, with individual shares of 15%, 11%, and 3%
- An open model series from a major US social media company accounts for just 7%
In other words, for every $10 US enterprises spend on open-source models, roughly $9 goes to Chinese companies.
The boundaries of this data matter. The survey was conducted from September 8 to 26, 2026, and drew responses from 400 AI business leaders at US enterprises. These leaders oversee combined AI budgets of more than $4 billion. This is a survey of enterprise spending, not an official statistic. It reflects paying customers’ actual behavior in the surveyed companies and should not be directly extrapolated into a conclusion about the entire industry.
So the real question is not “what share do they hold?” but “why does the money flow this way?”
2. Price Is the First Driver, but Not the Whole Story
2.1 Price Cuts Have Reset the Cost Baseline
As of September 2026:
| Model type | Average price per call (per million tokens) | Relative to open-source average |
|---|---|---|
| Open-source models | About $0.13 | 1x |
| Proprietary models | About $0.70 | About 5.4x |
A year ago, open-source models averaged around $0.45 per million tokens. Today they cost only a small fraction of that. The price gap has widened. Proprietary models are now relatively expensive, and the benefits of switching to open-source models are easy to see.
Price cuts are a double-edged sword, though. Lower prices can actually shrink open-source models’ share of spending: usage keeps growing, but bills don’t grow at the same pace. The share of money going to open-source models then ends up shrinking. When analyzing spending trends, enterprises should account separately for price effects (unit price) and scale effects (usage growth). Otherwise, cost reduction is easily misread as contraction.
2.2 Unit Price Is Not the Only Decision Factor
If enterprises chose models by unit price alone, you would expect the cheapest option to win. Yet the Chinese vendor with the largest share doesn’t price all of its models at the lowest market level. Its share is still about four times that of the runner-up (15%).
In reality, vendor selection weighs four factors:
- Whether quality is good enough
- Whether inference is stable
- Whether throughput and latency meet requirements
- Whether the engineering ecosystem is mature
Price is just one of them.
3. AI Agents Are Rewriting the Token Consumption Structure
3.1 Agents, Not People, Now Drive Consumption
The same survey shows that on one model aggregation routing platform, agent applications account for roughly 80% of token usage. The platform’s own monthly figure is about 76%. The difference likely comes from different measurement weeks or scope.
In practice, an enterprise’s bill is now driven less by how many employees use AI than by how much work agents execute automatically.
3.2 How Token Consumption Gets Multiplied
Agents work in a loop: understand the goal → plan the steps → call tools → read the results → decide again. The loop repeats until the task is done, and token consumption multiplies along the way:
- Every turn resends the task instructions, conversation history, and tool results (such as web page content, code, and logs), so the context keeps growing.
- Failed tool calls or unexpected output trigger retries, and the failed attempts still consume tokens.
- Multi-agent collaboration and long-running workflows stack these loops on top of each other.
For example, one Q&A from an employee may use only a few thousand tokens. One agent completing a multi-step research task can easily consume hundreds of thousands.
3.3 Why Advantages Concentrate Among a Few Leaders
As the consumption structure changes, the selection focus shifts from “is a single answer good enough?” to “can the model reliably complete long-chain tasks?” That includes:
- Stability across multiple tool calls
- How well structured output follows the JSON Schema
- Ability to retain information in long contexts
- Instruction following and format controllability
Models that excel on these dimensions get amplified as enterprises integrate them. This also explains why market share is concentrating among a few leading vendors.
4. The Underrated Factor: Control
Most leading Chinese open-source models release open weights, which gives enterprises a level of control that proprietary APIs can’t offer:
- Deep customization: Enterprises can run continued pre-training or domain fine-tuning on the weights. This adapts the model to their terminology, documents, and business processes.
- Private deployment: Inference can run in the enterprise’s own environment. This makes it easier to handle sensitive data, meet compliance requirements, and reduce single-vendor risk.
- Technical autonomy: Enterprises can handle quantization and compression, inference engine tuning, and batch scheduling themselves. They can then keep optimizing unit token cost.
- Reproducibility: Model versions can be pinned and rolled back, and evaluation results can be traced over the long term.
For enterprises that rely on AI capabilities over the long term, making a model an asset of their own often matters as much as a lower bill.
5. The Economics of Switching Have Changed
The survey also highlights two corporate cases with clear timelines and actors:
- In June 2026, an AI startup in San Francisco with about 25 employees moved all of its traffic from a proprietary model to the flagship model of a Chinese vendor. The CEO told the media that inference costs fell about 95%, saving several million dollars a year in infrastructure. Call success rates held steady, and latency rose only slightly. The company’s engineering blog cites about 90%. The public statements and the internal review differ slightly, but point in the same direction.
- Around the same time, the CEO of a large cryptocurrency trading platform said publicly that the company had made two Chinese vendors’ models the default for its engineers. It paired the switch with routing optimization and cache reuse. As token usage grew exponentially, AI spending was cut nearly in half.
Both cases are self-disclosures by the companies, not industry-wide estimates. Don’t treat them as general conclusions. Still, a few practices stand out:
- Flat success rates despite a steep cost drop show that, in these enterprises’ scenarios, the new models’ quality is now in the “acceptable” range.
- In the second case, usage surged while total spending fell. That’s because total cost ≈ unit cost × call volume. When usage is growing fast, unit cost becomes a powerful lever with an amplified effect.
- Engineering measures like routing optimization and cache reuse matter just as much as the model switch itself.
This is the conclusion of the article being analyzed: once model quality enters the “acceptable” range, cost beats brand preference.
6. Calculating AI Costs: From Token Price to Task-Level Cost
6.1 Formulas and Code
An enterprise’s real cost is not the per-token price. It is how much it costs to complete one successful task:
effective task cost = (input tokens × input price + output tokens × output price + retry and failure consumption) / successful taskscache savings = cached input tokens × (original price − cache price)
Python implementation:
from dataclasses import dataclass@dataclassclass Route:"""Pricing details for a class of models"""name: strin_price: float # input price: USD per million tokensout_price: float # output price: USD per million tokenscache_price: float # cached input price: USD per million tokens# Illustrative values: input prices use the open-source average of 0.13 and the proprietary average of 0.70# Other values are assumptions, shown only to demonstrate the calculation logicROUTES = {"strong": Route("High-capability model", in_price=0.70, out_price=2.80, cache_price=0.07),"mid": Route("General-purpose open-source model", in_price=0.13, out_price=0.52, cache_price=0.013),"light": Route("Lightweight open-source model", in_price=0.03, out_price=0.12, cache_price=0.003),}def choose_route(task: dict) -> Route:"""Choose a route based on task features; adjust thresholds using business experience"""if task["needs_tools"] or task["needs_long_context"]:return ROUTES["strong"] # multi-step tool calls, long-document reasoningif task["type"] in ("rewrite", "extract", "classify"):return ROUTES["mid"] # rewriting, information extraction, classificationreturn ROUTES["light"] # simple Q&A, template fillingdef task_cost(route: Route, stats: dict) -> float:"""Estimate the lifecycle cost of a task, including multi-turn loops and retries"""uncached_in = stats["in_tokens"] - stats["cached_tokens"]raw = (uncached_in * route.in_price+ stats["cached_tokens"] * route.cache_price+ stats["out_tokens"] * route.out_price) / 1_000_000# Adjust by success rate: failed tasks consume tokens tooreturn raw * stats["attempts"] / stats["success_rate"]# Illustrative: cost of the same task across different routesstats = {"in_tokens": 60_000, "out_tokens": 4_000, "cached_tokens": 40_000,"attempts": 1.2, "success_rate": 0.96,}print({r.name: round(task_cost(r, stats), 4) for r in ROUTES.values()})
6.2 Key Points
- Prioritize cache hits: Put stable prefixes such as system prompts, tool definitions, and knowledge base snippets at the front of the context and enable caching. Adding multi-turn agent conversation history incrementally can greatly reduce repeated computation.
- Adjust for success rate: Account for tokens consumed by failed tasks so you don’t underestimate real spending by counting only successful requests.
- Make cost observable: Add unified tracking at the application layer. Record request volume, input and output tokens, cache hits, task duration, success rate, and failure reasons. Use logging services and monitoring alerts to aggregate data by business line, scenario, and version into daily cost reports.
7. How to Replace a Model in Practice
7.1 A Four-Step Evaluation Process
- Build a business evaluation set: Sample real traffic and cover both typical and long-tail scenarios. Have humans label answer quality.
- Set a quality gate: Run the evaluation set on candidate models. Only models that clear an acceptable quality threshold move on to the cost comparison.
- Compare with shadow traffic: Let candidate models process the same requests in parallel with the production model. Compare success rate, latency, and output stability.
- Roll out gradually: Increase traffic from 5% → 20% → 50% → 100%. Monitor metrics and keep a rollback plan in place.
7.2 Cost Control Checklist
| Technique | How to apply | Effect |
|---|---|---|
| Tiered routing | Route simple tasks to lightweight models and complex ones to high-capability models | Balances quality and cost |
| Result caching | Reuse results for identical requests | Eliminates duplicate calls |
| Prefix caching | Reuse stable system prompts and tool definitions | Reduces repeated computation |
| Context trimming | Summarize and compress tool output before adding it to the context | Controls input tokens |
| Streaming output | Return results incrementally | Improves perceived latency |
| Budget circuit breaker | Set monthly budget limits per project and per scenario, with real-time alerts | Prevents abnormal consumption |
class BudgetGuard:"""Budget guard: hard limit based on cumulative cost; can be refined by response dimensions"""def __init__(self, limit: float):self.limit = limitself.spent = 0.0def check(self, delta: float) -> bool:if self.spent + delta > self.limit:return Falseself.spent += deltareturn True
8. Keep It in Perspective: Don’t Treat Individual Cases as Conclusions
- Methodology differences: Reports use different time frames, respondents, and scopes. Their numbers can’t be compared directly.
- Limits of unit cost: Token price is only part of the bill. Real cost also depends on task success rates and routing efficiency.
- Balancing quality and cost: Cost is an important factor, but not the only one. Weigh quality, latency, stability, compliance, and long-term negotiating power together.
- Risk hedging: Integrate multiple models with a routing layer. Avoid binding tightly to a single model or vendor, and stay flexible enough to switch.
Conclusion
About 90% of open-source model spending going to China isn’t simply a matter of “who is cheaper.” It comes from three forces combining: a widening price gap, agents amplifying usage, and open weights giving enterprises control. In the end, a simple business rule still applies. As long as quality is good enough, enterprises will rationally choose the option that costs less and gives them more control.
For enterprises, the real dividing line isn’t whether to use open-source models. It’s whether they can break AI spending down to each task and each workflow, then keep optimizing cost per task. Calculate the costs clearly first, then decide how to use models. That’s how enterprises avoid entering this AI cost war unprepared.
