Open source isn't a moral choice; it’s an operational strategy to prevent vendor lock-in. As transient AI models change, controlling the orchestration layer that routes and manages them becomes critical. Owning your infrastructure code is the only way to ensure true architectural sovereignty.
We tend to talk about open source as if it were primarily a moral choice.
We frame it around openness and community goodwill. And while those ideals are real and important, they are not the main reason open source has been so successful at the infrastructure layer.
Looking at some of the most successful projects in the OSS ecosystem (Linux, PostgreSQL, Kubernetes), none of them became foundational simply because engineers felt charitable. They won because of operational mechanics: you shouldn't surrender ownership of the layers that determine the behavior and portability of your system.
It’s not about owning every dependency. We all build durable systems on top of AWS, Stripe, or Cloudflare. It is about knowing which abstraction boundaries are strategically critical to own.
When an infrastructure layer determines how your application behaves, renting that layer from a single vendor is not just a convenience: it is an architectural vulnerability.
Models Are Temporary
Over the last two years, the AI ecosystem has been gripped by a specific anxiety: which model will win?
Teams have spent massive amounts of energy benchmarking frontier models, debating parameter counts, and optimizing prompts for whatever closed API launched this month. We treat the model as if it were the permanent core of our architecture.
The reality is becoming clear: models are transient; systems are permanent.
A model release feels like an event, but its lifecycle is short. Capabilities shift, pricing changes, and weights get updated. The durable value of what you build is not the raw API call to an external endpoint; it is the system sitting in front of it: the context assembly, routing decisions, fallback policies, evaluation harnesses, and data contracts that govern how your application interacts with intelligence.
The strategic layer is shifting from the model to the control plane.
Yet increasingly, even the decisions about which model to use are being taken out of our hands.
Providers now decide for you that query A should route to a fast model, query B needs a reasoning model, and prompt C should be cached behind their proprietary heuristic.
It is presented as convenience, and the appeal is obvious. But who controls those decisions? How are they audited? When you hand over routing, you don't just rent compute. You also rent the logic that decides how your application uses intelligence.
Fragility at the Boundary
This creates a subtle, dangerous kind of fragility.
Middleware companies in the AI space operate under intense market pressure. They raise venture capital, subsidize routing or compute to capture developer mindshare, and eventually face the inevitable: they pivot, adjust pricing tiers, or get acquired.
Recent industry events have reminded many teams that infrastructure decisions have long-term implications
When the company hosting your routing logic, rate limits, and fallback policies changes ownership overnight, what happens to your stack?
An infrastructure layer you treated as a neutral utility suddenly becomes a strategic asset for someone else. Upstream relationships shift. Data policies change. If your entire multi-model orchestration is locked inside a proprietary vendor’s dashboard, you don't have a portable architecture; you have a massive migration project on an emergency timeline.
Kubernetes established an open control plane for heterogeneous infrastructure. AI needs the same thing for heterogeneous models.
Imagine if the foundational interface between applications and operating systems had been controlled by a single vendor that could unilaterally change its licensing, economics, or behavior. That is the risk we run if we let closed gateways become the default control plane for AI.
Auditability and the Leverage of Source Code
This brings us to the question of auditability.
If you cannot inspect the code that sits at the boundary of your application, you cannot truly audit what your software is doing. When an LLM call fails, hangs, or silently routes to a fallback that degrades output quality, debugging through a closed proxy leaves you looking through a keyhole. Historically, source availability wasn't always the same thing as practical ownership. Most teams simply didn't have the time or specialized expertise to dive into complex infrastructure codebases and modify them.
AI coding agents change that equation entirely.
When software is written, debugged, and maintained alongside AI tools, the value of having the source code increases dramatically.
If you can point a coding agent at an open-source control plane and say:
- "Show me exactly how fallbacks and retries are calculated."
- "Add an adapter for this new internal model endpoint."
- "Adjust this routing policy to prioritize latency under peak load."
Then the source code is no longer something you merely possess, it becomes something you can actively operate on.
An open project doesn't guarantee better software by magic. What it guarantees is that your ability to understand, modify, audit, or continue operating that software doesn't disappear when a single company shifts its priorities.
Sovereignty in Practice
There is also the practical reality of privacy, compliance, and data residency.
Not every organization needs to self-host everything. But for regulated workloads, sensitive enterprise data, or strict residency requirements, being able to run the control plane inside your own perimeter isn't ideological: it is an operational requirement. Having that option available by default is what separates infrastructure you control from a closed silo.
Trying to build the future of software by treating proprietary gateways as permanent foundations is a short-term trade that creates long-term operational fragility.
This is why at Mozilla.ai we are building Otari.
Otari is an open-source LLM control plane designed to sit at that critical boundary between your applications and the evolving model ecosystem.
Open source was never about charity. It has always been about building systems that you can trust, understand, and control.
Don't rent the layer that coordinates your intelligence. Own it.