79% of Developers Use Open-Source AI But Only 51% Ship It — The Missing Piece Is the Platform Layer

Mozilla published something this week that cuts through the AI hype like nothing else I've read this year. Their first State of Open Source AI report, built with SlashData from a survey of over 1,400 developers, doesn't argue about whether open models can compete with closed ones. It just shows you the receipts.

Here's the number that stopped me: 79% of developers building AI features use open models. That's adoption. That's not a niche. But only 51% of those teams ever reach production. For closed models, it's 63%.

That's a 28-point gap. Nearly a third of the people who pick up open models never ship anything real with them.

The question is why. And the answer lives in the operational weeds, not the model benchmarks.

If the models are at parity, what's breaking?

Open weights have closed the capability gap. The report is explicit: open models are at or near parity on coding, instruction-following, and general knowledge. The frontier gap that remains (about 3.3% on Chatbot Arena) is concentrated in reasoning and long-context retrieval, the kinds of things most production workloads don't need. Meanwhile, inference costs have collapsed 50x in 36 months. GPT-4-class tokens went from $20 per million to $0.40. The models are good enough. They're cheap enough. So what's the problem?

Mozilla asked developers exactly this. The top four challenges cited by teams that churned away from open models are, in order: infrastructure and compute costs (27%), security and compliance (26%), ongoing maintenance and updates (24%), and deployment complexity (23%). The bottom two? Model performance and fine-tuning difficulty.

Let that land. The thing everyone spends their time arguing about, can open models match GPT-5, is dead last on the list of what actually stops people shipping. The top of the list is all operational. Auth, monitoring, scaling, updating, securing. The boring stuff.

Why isn't money fixing this?

Here's the data point that makes the operational argument stick. Mozilla sliced production rates by company size. For closed models, the line climbs cleanly: 54% at small companies, rising to 73% at enterprises. You can buy your way through closed-model deployment. More engineers, more cloud credits, more vendor support. It works.

For open models, the line is basically flat. 53% at startups, 57% at enterprises. Four percentage points of improvement across the entire spectrum of company size.

Enterprises can throw money at the problem and it doesn't move. The bottleneck isn't budget. It's that nobody has finished building the operational tooling layer for open-source AI. The models are there. The platform to make them production-usable isn't.

Isn't this the no-code thesis in one statistic?

I've been writing about no-code platforms for years, and I've never seen a single survey result that makes the case more cleanly than this one.

The whole pitch of a serious no-code platform has always been: you shouldn't have to become a DevOps engineer to ship software. You shouldn't have to think about container orchestration or certificate rotation or database migrations. The platform abstracts all of that so you can focus on what your thing actually does.

Open-source AI has exactly the same problem, at exactly the same layer. The models are a commodity now. Anyone can download DeepSeek or Qwen or Mistral and get output that rivals Claude or GPT-5 for most tasks. But downloading a model is not the same as running a production service with it. You need hosting that doesn't fall over. You need auth so random people can't burn your inference budget. You need monitoring so you know when the outputs drift. You need a way to swap models without rewriting your entire pipeline. You need updates, versioning, rollback.

None of that is AI. All of it is platform.

And that's the gap. 79% adoption, 51% production. The 28 points in between are the platform layer.

So what does closing the gap actually look like?

A model-agnostic platform. One where the model is a parameter, not the product.

Think about what that means in practice. You build your application once. The platform handles the auth, the hosting, the monitoring, the scaling. You point it at whatever model makes sense, open or closed, frontier or lightweight, depending on the task and the budget. Next month when a better open model drops, you swap it in. Your users don't notice. Your code doesn't change. The platform absorbed the operational complexity, and you get to treat models as interchangeable components rather than dependencies you're locked into.

This isn't theoretical. Stacker works this way: model-agnostic, production-native. The platform gives you the boring infrastructure: user management, permissions, data storage, deployment. You bring whatever AI model fits your use case. You're not betting your application on one API endpoint's pricing decisions or one company's export controls. You're building on a platform that treats models as swappable.

And look, I'm not saying every no-code tool does this. Plenty of AI builders are thinly-wrapped single-model APIs with a chat interface on top. That's useful for prototyping. But the second you need something real, actual users, actual auth, actual uptime, you hit the same wall the Mozilla data describes.

What should builders do with this?

If you're building AI features and you're not already using open models, you should start. The capability gap is effectively closed for most workloads, and the cost asymmetry is staggering. The Linux Foundation's Nagle-Yue study puts it at roughly 6x per call, which compounds to about $24.8 billion in unrealised annual savings across the industry.

But don't start by downloading weights and configuring a Kubernetes cluster. That's the path to becoming one of the 28% who try and never ship.

Start with a platform that handles the operational layer for you. Pick one that's model-agnostic, so you're not locked to a single provider. Build your application logic, not your infrastructure. Swap models when better ones arrive. Let someone else solve the deployment, auth, monitoring, and scaling problems, because those are the problems the data shows are actually stopping people.

The open models won. The survey proves it. But winning adoption without winning production is like winning the semi-final and not showing up for the match. The missing piece isn't better models. It's the platform layer that makes them boring enough to use.