Open-source AI models can now run inference at 70-90% lower cost than their closed counterparts. Training costs have collapsed even more dramatically: DeepSeek built V3 and R1 for roughly $5.6 million, a figure that would barely cover OpenAI's monthly coffee budget. The capability gap on benchmarks has narrowed to the point where Llama, Mistral, and Qwen can match GPT-4-class performance on many tasks.
And yet, enterprise adoption of open models is declining.
Menlo Ventures reports that open-source share of enterprise workloads dropped from 19% to 11-13% over the past year. The market is voting with its wallets, and it's not voting for the cheaper option. This isn't irrational. It reveals something important about what enterprises actually value when deploying AI systems.
Cheaper doesn't mean adopted
Most open-source AI advocacy rests on a straightforward bet: make it cheap enough and enterprises will switch. OpenRouter's analysis of 100 trillion tokens found remarkably weak price elasticity in LLM usage. A 10% cost reduction only increases usage by 0.5-0.7%.
Enterprises are not optimizing primarily for inference costs. They're optimizing for outcomes.
Consider what these models actually do in practice. Programming accounts for roughly 50% of tokens on commercial platforms, and for high-value coding tasks, the performance difference between frontier and open models still matters. Claude has captured 42% of the code generation market, double OpenAI's 21%. Enterprises will pay premium prices for tools that make their developers more productive. The 70-90% cost savings on inference are real, but inference cost is often a small fraction of the total cost of deploying an AI system. Developer time, integration complexity, and maintenance burden dwarf the API bill for most companies.
Where open models have actually caught up (and where they haven't)
Survey respondents in the Menlo research cited a 9-12 month performance gap between open and frontier closed models on cutting-edge reasoning and code generation tasks.
That's not nothing.
For companies building products where being on the capability frontier matters, waiting 9-12 months for open alternatives isn't a viable strategy. But the gap isn't uniform across domains. Open models have closed it entirely in some areas: edge deployment, specific vertical applications, and high-volume cost-sensitive workloads are where they now dominate. Proprietary systems retain roughly 70% share of high-value workloads, while open models handle the long tail.
This isn't a race where one side wins. It's market segmentation.
The Berkeley CMR analysis calls it a "multi-model landscape" where closed and open models serve different niches. That framing matches reality better than the "open-source will disrupt everything" narrative that dominated 2024 discourse.
The real strategic advantage of open models isn't cost. It's control. For regulated industries (finance, healthcare, defense), data sovereignty drives adoption. Running models on-premises or in air-gapped environments isn't optional when compliance requires it. The ability to inspect model weights, audit behavior, and guarantee data never leaves your infrastructure is worth the deployment overhead.
But most enterprises aren't in regulated industries. For them, the "customization" advantage of open models is theoretically compelling and practically difficult. Fine-tuning requires ML engineering capacity most companies don't have. Keeping pace with rapidly improving closed models means constant retraining. The maintenance burden of running your own infrastructure often exceeds the cost savings from avoiding API fees.
The Berkeley research notes that open-source communities iterate weekly versus quarterly or semi-annual cycles for closed providers. That's a double-edged sword. If you're self-hosting, you need to evaluate, test, and potentially upgrade weekly. If you're using an API, the provider handles that for you.
DeepSeek and Qwen's enterprise problem
Nobody's saying it directly, but it's shaping enterprise decisions more than benchmarks.
DeepSeek and Qwen now lead in downloads and developer popularity globally, but enterprise adoption remains below 1%. The gap between developer experimentation and production deployment has never been wider. Trust concerns explain most of this. Even technically excellent models face friction when enterprises need to explain their AI stack to customers, regulators, or boards. The geopolitical dimension of AI deployment isn't going away.
This creates a bifurcated market. Developers try everything. Enterprises deploy what they can defend.
Picking your tradeoffs
If you're weighing open versus closed models, here's the honest calculus:
Closed models make sense when you need frontier capabilities for reasoning, code generation, or complex tasks; when developer velocity matters more than inference cost; when you don't have dedicated ML engineering capacity for model ops; or when you want to outsource the upgrade treadmill.
Open models make sense when data sovereignty is a genuine requirement (not a talking point); when you're building high-volume, cost-sensitive applications where good-enough performance scales; when you have the engineering capacity to run and maintain model infrastructure; or when your use case is specific enough that fine-tuning provides real advantages.
The interesting space is using both. Different parts of your system have different requirements. You might route based on task complexity (open for simple queries, closed for hard ones). You might want fallback options and negotiating leverage with API providers.
The framing of "open vs closed" as a binary choice misses how production systems actually work. Most serious deployments will use multiple models, routing between them based on cost, latency, and capability requirements.
The LLM API market doubled from $3.5 billion to $8.4 billion in six months. Growth is happening on both sides of the divide, just in different segments. Closed models are capturing the high-value enterprise tier with better performance on frontier tasks. Anthropic's rise to 32% enterprise share (surpassing OpenAI's 25%) shows that competition within closed models is fierce. Open models are capturing developer experimentation, edge deployment, and cost-sensitive applications.
The capability gap will continue narrowing. Specialized open variants (Med-Qwen2-7B, Fin-R1) are emerging months after base model releases, which suggests domain-specific applications may be where open models find their strongest foothold.
Our read: the "disruption" framing is wrong. This isn't a story where open-source AI eventually replaces closed models. It's a story where both find their natural market segments and compete primarily within those segments. The real question isn't "which will win?" It's "what are you building, and which tradeoffs make sense for that specific use case?"
Cost was never the deciding factor. Control, capability, and deployment burden are.