67% of CIOs Can't Control Their AI Agents. IBM Just Proved It.
IBM just surveyed 2,000 CIOs and CTOs. The headline number should stop every executive cold.
67% say they cannot fully control what their AI agents are doing.
Not "don't have a perfect system." Not "are working on it." Cannot control it. Today. With agents already running in production.
The same survey found that only 11% of organizations have comprehensive AI governance in place. The rest are operating on hope -- that their agents will stay within expected parameters, that they won't take actions they weren't authorized to take, that someone will notice when something goes wrong.
This is not a technology problem. It is an architecture problem. And it has a solution -- but only if you build it in from the start.
The Gap No One Is Talking About
The 67%/11% numbers tell a specific story. Organizations deployed agents fast. They moved quickly to capture the productivity gains, the automation wins, the competitive advantage of having AI do work at scale.
What they did not do was build the governance layer before deployment.
The result is a fleet of agents operating with undefined authority. They can take actions. They can communicate externally. They can access systems. But the boundaries of that authority were never formally defined, never technically enforced, and never made auditable.
When something goes wrong -- and in 88% of organizations, something already has -- the question "who authorized this?" has no answer. Because no one explicitly did. The agent just... could.
What the 25% Did Differently
The organizations that closed the gap share a common architectural pattern. They did not add governance after deployment. They built it into the deployment layer.
Specifically, they did three things:
1. They treated agents as governed entities, not tools.
Every AI agent has an identity, a defined scope of authority, and a runtime permission model. The agent can only take actions explicitly authorized for its role. Not "probably won't exceed its scope." Cannot exceed its scope -- because the system enforces it at execution time.
2. They built real-time observability into the agent layer.
Every action, every decision, every external communication is logged at the point of execution -- not reconstructed after the fact from downstream system logs. When you need to answer "what did this agent do and why," the answer is already there.
3. They defined accountability at deployment, not at incident.
Before an agent goes live, four questions have explicit answers:
- Who approved its scope?
- Who reviews its actions?
- Who is notified when it operates outside expected parameters?
- Who has authority to suspend it?
These are not questions you want to answer for the first time during an incident.
The result is not slower deployment. It is faster -- because the governance layer eliminates the back-and-forth that happens when ungoverned agents create problems requiring human intervention.
The Architecture Argument
The 77%/11% gap reflects a specific failure in how the industry has framed AI governance.
Governance has been sold as a compliance requirement -- something you do because regulators or auditors require it. That framing produces the 11% outcome: organizations that implement governance only where they must, as minimally as possible, as late as possible.
The 25% who closed the gap treat governance as an architecture requirement. The same way you would not deploy a production database without access controls, you do not deploy a production AI agent without a defined permission model, an audit trail, and a suspension mechanism.
The compliance framing asks: "What governance do we have to have?"
The architecture framing asks: "What governance do we need to trust this system in production?"
Those are different questions with very different answers.
What This Means for Your Organization
If you are in the 67%, the path forward is not a governance audit or a policy document. It is an architectural change to how agents are deployed.
That means:
- Identity before deployment. Every agent needs a defined identity and a bounded scope of authority before it touches production systems.
- Observability at the agent layer. Logging downstream system effects is not enough. You need to capture agent decisions at the point they are made.
- Accountability defined upfront. The human accountable for each agent's actions needs to be named before the agent goes live -- not identified after an incident.
The organizations that get this right are not moving slower. They are moving faster, with higher confidence, because they have eliminated the failure modes that force human intervention.
The IBM survey is a snapshot of where the industry is. The 25% who closed the gap are a preview of where it is going.
The question is which side of that gap your organization is on.
Outermind builds AI agents with governance built into the architecture -- not bolted on after deployment. Every agent has a defined identity, a bounded permission model, and a real-time audit trail from day one. Join the waitlist to see what governance-first AI looks like in practice.