Twelve months ago, the enterprise AI model decision was straightforward. If you needed the best performance and had the budget, you bought access to GPT-4 or Claude. If you needed control and had technical capability, you built on open source.

That clarity is gone. Llama 3, Mixtral, and Command R+ have closed the performance gap for most enterprise tasks. Meanwhile, proprietary providers have added deployment options that give you more control. The decision tree just got more complicated.

The Cost Math Changed

The pricing advantage of open source used to be obvious. Self-hosting a Llama model cost a fraction of API calls to OpenAI or Anthropic. That’s still true for high-volume workloads, but the breakeven point shifted.

Cloud providers now offer optimised inference at prices that make small to medium deployments cheaper than running your own infrastructure. Unless you’re processing millions of tokens daily, the self-hosting economics don’t work.

There’s also the hidden cost problem. Open source models need more engineering time for fine-tuning, monitoring, and updates. That labour cost often exceeds the savings on compute. You need a team that can actually support the infrastructure.

Performance Gaps Are Narrowing

For straightforward tasks—summarisation, classification, basic question answering—the open source models match proprietary offerings. The gaps show up in edge cases and complex reasoning.

Proprietary models still handle ambiguity better. They’re more reliable when instructions are vague or context is missing. They fail more gracefully. For production systems where consistency matters more than peak performance, that reliability is worth paying for.

But if your use case is well-defined and you can provide clear prompts with good examples, the open models perform just as well. Document classification, data extraction, content generation from templates—these tasks don’t need frontier models.

The Control Question

This is where the decision gets philosophical. What does “control” actually mean? If you’re self-hosting an open model, you control where data goes and how it’s processed. That matters for regulated industries and sensitive information.

But you don’t control the model’s training data or underlying biases. You don’t control the release schedule or bug fixes. For truly critical applications, you might need to fork and maintain your own version. That’s a massive commitment.

Proprietary models give you less control over deployment but more predictability. The providers maintain the infrastructure, handle updates, and offer SLAs. You’re trading control for reliability.

Deployment Flexibility

The proprietary providers saw this coming. Azure OpenAI, AWS Bedrock, and Anthropic’s enterprise offerings now let you deploy models in your own VPC. You get the model quality without sending data to external APIs.

That middle ground option changes the decision matrix. You can get proprietary performance with data residency guarantees. It’s more expensive than API access but cheaper than building equivalent capabilities on open models.

The remaining advantage for open source is air-gapped environments. If you genuinely can’t have any external connectivity, self-hosted open models are your only option. That’s a real requirement for some government and defence applications, but it’s rarer than vendors claim.

The Vendor Lock-in Problem

Building on proprietary APIs creates dependency. If pricing changes or capabilities shift, you’re stuck. Open source models let you swap between providers or host yourself if needed.

In practice, this portability is overvalued. The prompt engineering, fine-tuning data, and integration work is the real asset. That’s portable across models. Switching costs exist regardless of which foundation you chose.

The bigger risk is capability lock-in. If you build workflows around features that only exist in one model family, you’ve created dependency whether it’s open or closed. Design for model-agnostic patterns from the start.

What Enterprises Are Actually Doing

The pattern we’re seeing is hybrid. Proprietary models for customer-facing applications where reliability and quality matter most. Open models for internal tools and high-volume batch processing where cost matters more than consistency.

Some organisations are also using proprietary models for prototyping and validation, then migrating to fine-tuned open models once the use case is proven. That’s probably overcomplicated, but it does manage risk.

The least successful approach is choosing based on principle rather than requirements. Teams that commit to “open source only” or “best model regardless of cost” both end up with suboptimal solutions. Match the tool to the task.

Decision Framework for 2026

Start with your constraints, not your preferences. Do you have regulatory requirements around data location? That narrows your options immediately. Do you have ML engineers who can manage model infrastructure? If not, proprietary makes more sense.

Then look at your use case. High stakes customer interactions? Proprietary. High volume internal processing? Open source. Prototyping and experimentation? Proprietary with a plan to migrate if volume justifies it.

Finally, consider your timeline. If you need production quality in weeks, proprietary is faster. If you’re building for 2027 and beyond, investing in open source capabilities might pay off as models continue improving.

The Convergence Ahead

The distinction between open and proprietary is blurring. Proprietary providers are offering more deployment flexibility. Open models are closing performance gaps. The decision is becoming less about the model and more about the infrastructure around it.

In two years, we’ll probably stop framing this as open versus closed. It’ll be about which combination of models, hosting options, and support services fits your requirements and capabilities. That’s a more boring decision, but a more useful one.

For now, the answer to “which should we use?” is almost always “both, for different things.” The organisations treating this as a binary choice are setting themselves up for problems. The ones succeeding in 2026 are the ones being pragmatic about when each approach makes sense.