Open Models Are Commoditizing AI—and That Is Good News for Engineers

Open models are commoditizing AI, and software engineers should stop treating that as a distant ideological fight. The model itself is becoming a less defensible product layer; the lasting advantage is moving to everything that makes a model useful in a real system.

By commoditizing, I do not mean that models are becoming identical, free to run, or unimportant. I mean that a capable general-purpose model is increasingly available from multiple suppliers, can be hosted or adapted outside one vendor’s platform, and is falling in price fast enough that switching providers becomes a serious option. That is what happens when an expensive, scarce capability becomes an input to other products.

The capability gap is no longer a moat by itself

For years, the closed-model pitch was simple: the best intelligence lived behind a single API, so building on it meant accepting its price, latency, rate limits, roadmap, and policy decisions. That was a rational choice when the alternatives were conspicuously worse. It is becoming less rational as a default architecture.

Stanford’s 2025 AI Index tracked the best closed-weight and open-weight models on the Chatbot Arena leaderboard. The gap was 8.0 percentage points in early 2024 and had narrowed to 1.7 points by February 2025. That is not a promise that every downloadable model can match the best proprietary system at every task. It is more consequential: for a growing range of ordinary work—classification, extraction, RAG, coding assistance, structured transformations, internal agents—the question is no longer “can an open model do this?” but “which trade-off do we want among quality, speed, control, and cost?”

That change matters because most production workloads are not a weekly showdown on an elite benchmark. They are repeated, bounded operations wrapped in application code: turn a ticket into JSON, summarize a call, draft a test, route a document, answer from a constrained corpus, or extract fields from a messy form. A model that is slightly less generally capable but predictable, private, tunable, and cheap enough to invoke ten times can be the better component.

Open weights turn model choice into an engineering decision

An API-only model gives you a feature. Open weights give you options. You can quantize for the hardware you actually own, choose a serving stack, set retention rules, run in a private network, fine-tune or attach adapters for your domain, and pin a version rather than discovering on Monday that a vendor silently changed behavior. None of this is free. It replaces API convenience with operational responsibility. But that is precisely why it resembles normal software engineering rather than a dependency on a magical service.

The ecosystem is supplying the complements that make this practical. Hugging Face reported 13 million users, more than two million public models, and more than 500,000 public datasets in 2025; it also describes a rapidly growing layer of derivative artifacts such as fine-tunes, adapters, benchmarks, and applications. Qwen alone had more than 113,000 derivative models in its analysis. That is the signal of a platform market: the base model is valuable, but the surrounding work compounds faster than any one lab can ship it.

This is why the economically important unit is no longer simply “the smartest model.” It is a whole deployment: a model plus retrieval, tools, permissions, evaluation data, tracing, fallbacks, human review, and product design. Engineers who only compare leaderboards are making the same mistake teams made when they evaluated databases by a single query benchmark. The hard part is not calling the primitive. The hard part is designing a system that remains correct, observable, affordable, and safe when the primitive is probabilistic.

Falling inference prices accelerate the shift

Commoditization has a cost curve, and AI’s is brutal. The AI Index estimates that the cost of querying a model at roughly GPT-3.5-level MMLU performance fell from $20 per million tokens in November 2022 to $0.07 by October 2024—a more than 280-fold decrease. Better hardware matters, but so do algorithmic and serving improvements, smaller capable models, quantization, and competition. Once intelligence becomes cheap enough, teams stop rationing calls and start redesigning workflows around them.

That does not automatically make self-hosting the right answer. If you have sporadic traffic, no GPU operations experience, and a need for the best possible reasoning, a managed proprietary API can be the sensible choice. The point is that it is now a choice. A competent team can use a closed frontier model for difficult escalation paths, a fast open model for high-volume routine work, and conventional deterministic code where language models have no business being involved. Vendor loyalty is not an architecture.

The strongest objection: the frontier will stay closed

The strongest counterargument is that I am confusing catch-up with commoditization. Frontier labs still spend enormous sums on compute, research talent, post-training, data pipelines, and safety work. Their best models can lead on difficult reasoning, multimodal work, long-horizon agents, and reliability. Those labs also sell more than weights: they sell managed capacity, integrated tooling, enterprise contracts, and someone to call when production breaks. Open-weight releases often omit training data and other artifacts, so calling them “open source” can overstate what users can inspect or reproduce. On this view, open models are useful followers, while closed labs retain the only capabilities that truly matter.

That argument is substantially right—and it still does not rescue the model layer from commoditization. Commodity markets can have premium products. AWS did not make bespoke infrastructure irrelevant; Linux did not end proprietary software; Postgres did not prevent companies from selling excellent managed databases. They changed where customers would pay a premium. Closed frontier models can remain valuable for the hardest tasks while losing the right to charge monopoly rents for everyday intelligence.

And the openness critique is a reason to be more precise, not to dismiss the economic effect. Many releases are open-weight rather than fully open-source AI under the Open Source Initiative’s definition, which requires the freedoms to use, study, modify, and share the system. We should say that clearly. Yet downloadable weights with a workable license are still enough to create provider competition, local deployment, fine-tuning, and a derivative ecosystem. Those are the mechanisms commoditizing the practical model market.

What engineers and buyers should change now

Teams should stop designing products around a single model vendor unless a measured capability requirement truly demands it. Define an internal model interface, keep evaluation sets based on your own failures, and make routing a configuration decision rather than a rewrite. Test at least one open-weight option for workloads involving sensitive data, high token volume, offline requirements, or narrow domain behavior. Put deterministic validation around every output that changes money, permissions, production code, or customer records.

More importantly, invest where the moat is actually forming: proprietary workflow knowledge, clean feedback loops, trusted distribution, domain-specific evaluation, and boring operational excellence. The winners will not be the teams that merely rent the highest-scoring model. They will be the teams that assume models are replaceable, build accordingly, and use the resulting freedom to make better software.