I’ve been watching the conversation around AI shift in real time. Six months ago, every discussion centered on capability: What can AI agents do? How fast will they disrupt software development? Can they really replace entire workflows?
That’s changed. The customers I’m talking to now have moved past wonder and landed squarely in skepticism. They’re asking a harder question: Can we actually trust these systems enough to put them in production?
This pivot matters more than people realize. It signals that we’re transitioning from the hype phase into the accountability phase. And that transition is where the real work begins.
The Trust Problem Nobody’s Talking About
Here’s what I’m hearing consistently: teams have already committed to AI agents as part of their development workflow. That decision is made. The question now is whether they can safely do it without sacrificing security, predictability, or control.
The problem is that most organizations building AI systems right now are treating trust as an afterthought. We slap security on top of models like it’s a layer of paint. But that’s backwards. Trust can’t be bolted on. It has to be architected from the ground up, starting at the runtime level where agents actually execute.
That’s why Docker’s participation in NVIDIA’s Open Secure AI Alliance resonates with me. This isn’t just another standards committee. It’s recognition that intelligence without governance is a liability, not an asset. And more importantly, it’s acknowledgment that no single vendor can build this alone.
Why Model Choice Actually Matters Now
I’ve noticed something telling: almost every customer I’ve talked to is already running open-weight models alongside closed models. This isn’t ideological. It’s practical. They need the flexibility to route different tasks to different models based on cost, latency, and regulatory requirements.
But here’s the friction: switching between model providers usually means rethinking architecture, rewriting deployment logic, and re-evaluating security policies. That’s a nightmare in practice, and it creates a perverse incentive to stick with whatever you started with, even if it’s suboptimal.
The real power emerges when you can swap models without redoing governance. When switching from Claude to Llama to Grok doesn’t mean rebuilding your trust framework. That’s freedom. That’s what developers actually need, whether they realize it yet or not.
The Supply Chain Attack Surface We’re Not Ready For
I want to get specific about something that keeps me up at night: AI agents handling credentials and secrets. There are already documented cases of agents leaking API keys and database passwords through seemingly innocent tasks. A developer asks an agent to “debug this deployment,” and suddenly the agent has enough information to compromise your entire infrastructure.
This is a supply chain problem wearing a different mask. And most organizations don’t have adequate controls in place. They’re running agents in environments with full access to sensitive data, then wondering why their security teams are panicking.
The answer isn’t to restrict what agents can do. It’s to build sandboxing and identity controls that prevent agents from accessing credentials in the first place, then let them operate freely within those boundaries. Security frameworks for AI need to be invisible to developers while being impenetrable to compromise.
Why Governance Can’t Slow Down Development
Here’s where I diverge from some of the enterprise security establishment: rigid governance will kill adoption. If your AI agent framework requires three weeks of compliance review per deployment, nobody’s going to use it. Developers will find workarounds, and your security posture becomes theater.
The answer is building governance into the runtime, not around it. If agents have deterministic constraints baked into their execution environment, you don’t need approval workflows. You need visibility and audit trails. You need the ability to trust that an agent will behave consistently regardless of what prompt someone throws at it.
This is where open ecosystems and developer freedom actually create better security outcomes. When developers can choose their tools and contribute to shared standards, they build better governance, not worse.
The Question That Defines What Happens Next
The enterprise AI conversation is no longer about capability. It’s about whether we can build systems that are simultaneously powerful, trustworthy, and composable. Whether we can give developers the freedom to choose models and tools without sacrificing control.
Docker, NVIDIA, and the other members of the Open Secure AI Alliance are signaling that they understand this. The next few years will determine whether they can actually deliver on it, or whether trust remains the bottleneck that prevents AI from transforming software development at scale.