Uniform agent governance fails. Clearances must match autonomy.
Forty percent of companies are about to decommission agents over a question nobody in the room answered.
TL;DR
Uniform agent governance fails because it treats an agent's ability to act as the same decision as the scope of access it was granted, and those are two different decisions that scale independently. Gartner projects that by 2027, 40% of companies will decommission agents for exactly this reason. The failure is sharpest in companies that grew by acquisition, where agents get wired into systems nobody consolidated first. Decision architecture is the part of an operating model that fixes who decides, what evidence a decision requires, where it is recorded, and who holds the last word. Applied to agents, it produces proportional clearance levels that match autonomy to access instead of applying one policy to every agent. The result is a governance system that holds when capability changes, rather than a policy document that cannot be enforced.
I have sat in the room where the agent sent the email. Nobody at the table knew it could.
Nothing catastrophic happened, which is why the moment is worth repeating. A tool three teams had been piloting for six weeks did something useful in front of the wrong audience, and the room went still in the particular way rooms go still when people are recalculating what they believed was true. Then the questions started. Who approved this? We did. Approved what, exactly.
That exchange contains the whole failure, and no model upgrade explains it. Four people in that room held three different versions of what the agent was permitted to do, and nobody had reconciled them, because the approval that would have forced the question lived as a checkbox on a form someone completed in March.
Companies that grew by acquisition live with this in duplicate. Three CRMs, two ERPs, a support stack nobody consolidated, and now agents wired into each of those systems by different teams at different times. The people who wrote the policy did not install the workflow. The people who installed the workflow never read the policy. The executive who owns the number is the last to learn what any of it can reach.
Gartner expects that by 2027, 40% of companies will decommission agents outright, and the stated cause is narrow: teams did not separate an agent's ability to act from the scope of access it was granted. That sentence reads like a technical finding. It is an organizational one. It says a company issued one permission slip for work containing at least four separate decisions, then registered surprise when the agent exercised authority nobody had assigned.
A blanket policy answers a question nobody asked
Watch what the room does next, because the reflex is predictable and it lands in four places.
Buy a governance platform. A vendor will sell you a registry, a policy engine, a control layer, and a dashboard with a score nobody can explain. Useful in places. Never the constraint, because the tool cannot tell you who is allowed to decide that this agent may modify a production configuration. It knows how to enforce whatever someone typed into it. It does not know your organization's answer, and neither does anyone else in the room, which is precisely the gap it cannot fill.
Write the blanket. Everything gets human review. Every action, every surface, no exceptions. For three weeks it feels like discipline. Then the approval queue becomes a rubber stamp, because no human meaningfully reviews four hundred agent actions a day, so they click approve the way people click through a terms of service. That is not oversight. It is a signature that has stopped meaning anything, sitting on top of a shadow layer where the real work moves so nobody has to wait.
Hand it to one person. Name a head of AI governance, hand over the policy, move on. The analyst quoted in the CIO Dive piece, Shiva Varma, is blunt about this one: governance should not sit with a single individual, because that arrangement is already a failure mode. He is right for structural reasons rather than political ones. One person can write a rule. One person cannot make Product, Engineering, Legal, and the business agree on what an agent is allowed to be, and that agreement is the actual deliverable. It does not fit inside a job title.
Slow everything down. This is the expensive one, because it looks like rigor and functions as decay. Capability arrives faster than the process around it, so the process says wait, and the teams who can move without asking move. Your governance program becomes the reason your best operators route around you.
Every one of those moves rests on the same assumption: that trust is binary. Either the agent is fully controlled or it is fully trusted. Fully controlled means the summarizer that reads a document and needs nothing more than scoped access and an authenticated user gets wrapped in the same ceremony as a system that touches payments. Over-restriction slows delivery and pushes teams into unofficial tools, which is the opposite of the control you were buying. Fully trusted means the things that can move money, rewrite configuration, or speak to a customer run on the same footing as a research assistant, and that is where the risk conversation actually belongs.
Binary trust is not a governance position. It is the classification decision, deferred and then enforced anyway.
Decision architecture is where the agent's authority lives
Decision architecture is the part of an operating model that fixes who decides, what evidence a decision requires, where that decision is recorded, and who holds the last word when two functions disagree. Applied to agents, it answers a question that policy language tends to blur: what is this specific agent cleared to do, and who decided that.
Once you ask it that way, the single switch falls apart. Ability to act and scope of access are two different decisions, and they scale independently. An agent that can read everything and change nothing carries a different risk profile than an agent that reads one record and changes everything. Collapse them into one yes or no and you will be wrong in both directions simultaneously, which is the most expensive way to be wrong, because it costs you speed and safety in the same quarter.
Proportional governance is the alternative, and it starts by naming levels instead of arguing about them.
Observe. The agent reads, summarizes, retrieves. It touches nothing. The control need is scoped data access and identity, and that is the whole list.
Advise. The agent produces a recommendation that a person reviews before it goes anywhere. Now you need output quality review, a plan for the hallucination case, and some attention to the people relying on it, because reliance is a skill and organizations assume it rather than teach it.
Act with approval. The agent can send the communication, adjust the configuration, trigger the workflow, and it stops at the gate. This level is where meaningful control at the boundary earns its keep. Who approves, what evidence they see, what happens when they decline.
Act autonomously. The agent executes with no human in the loop. This level demands the most guardrails, the most specificity, and periodic human sampling, because the defining property of the level is that nobody is watching every move.
The levels are not a maturity ladder and nothing is trying to reach the top. Most agents should live at observe or advise permanently, and that is not a limitation, it is the correct answer. The governance work is deciding which level each agent earns and who holds the standing to move one up or down. When someone asks why a governance program stalled, the honest answer is usually that nobody was ever assigned the classification, so it was left to whoever felt strongest that week.
When nobody sets the level, the level sets itself
That is the consequence, and it arrives the way structural failures usually do, without an announcement.
The ambitious agent gets shelved, because nobody can approve the access it would need. The safe agent gets deployed and does almost nothing, and the team that wanted to build stops proposing things. A pilot starts in a sandbox nobody audits, because the official path is a two-week review that answers a question nobody asked. The company does not experience this as a governance failure. It experiences it as friction, then as fatigue, then as an annual line item someone defends in a budget meeting.
In an acquisition-built business the gap widens, because the footprint is already fragmented. A clearance set for the acquired company's billing agent does not automatically describe the same agent's reach once it sits behind the parent's data model. Nobody reclassifies it, because reclassification was never assigned to anyone, and the number that agent touches is now a number in your consolidated reporting.
Then the decommissioning happens and the story gets told as a technology failure. The model was not ready. The tooling was immature. The use case had not arrived. None of that is what happened. What happened is that a company treated four different risk decisions as one decision, kept the switch binary for as long as it could, and killed the program when the binary produced an outcome it did not like.
Varma's sharpest line in the piece is not about levels at all. Governance, he argues, should be a shared and repeatable classification rather than a top-down decree from a single executive. Most organizations skip that part, because shared classification is slower to produce than a policy document and it requires four functions to sit in a room until they agree. It is also the only version that survives contact with a live system, since the classification depends on knowledge distributed across those four functions. Engineering knows what the agent can technically reach. Product knows what it is being asked to do. Legal knows the obligation. The business knows what a bad outcome costs. None of them alone can set a clearance that holds.
I made this call on my own stack. Maximum autonomy was on the table and it was genuinely tempting: more capability, less friction, and a demonstration that would have looked excellent in front of an audience. I went the other way and chose governed autonomy, with pre-write gates and an Active Writer model so an agent cannot write outside the template it was given. The agent does real work. It simply cannot decide for itself how far its own authority extends.
The counterargument is fair and I have made it to myself. Gates slow things down, and every gate is a place work queues. It is still the trade I would make again, because the speed that comes from unbounded autonomy comes due later, in one event, at the worst possible moment, in a room full of surprised people. The speed a gate costs is paid in small installments you can plan for.
Noise is cheap now and it gets cheaper every quarter. Agents will generate more output, more surface area, more activity than any process you build can absorb. Judgment is the scarce input, and judgment is exactly what a blanket policy replaces with a rule. That is the trade nobody says out loud. A blanket is not a decision. It is the decision you did not make, written down and enforced anyway.
The companies that get this right will not have the most sophisticated governance framework on the market. They will have named levels, a classification that four functions actually agree on, and one place where the last word lives. The rest is tooling.
Key Takeaways
Uniform agent governance fails because it collapses two separate decisions, an agent's ability to act and the scope of access it is granted, into a single approval.
Gartner projects that by 2027, 40% of companies will decommission agents for this reason, which makes separation of capability and access the governing failure mode rather than a tooling gap.
Binary trust over-restricts low-risk agents and under-restricts high-risk ones at the same time, pushing teams into unofficial tools while leaving consequential actions insufficiently controlled.
Proportional clearance levels (observe, advise, act with approval, act autonomously) match oversight to autonomy, and most agents should remain at the lower levels permanently.
Blanket human review degrades into rubber-stamp approval at volume, which produces the appearance of oversight without the substance.
Governance assigned to one executive fails structurally, because no single role can reconcile what Engineering, Product, Legal, and the business each know about an agent's reach.
In companies built through acquisition, the clearance gap widens, because agents sit across systems that were never consolidated and each function sees only part of the footprint.
When no one owns the classification, the level is set by default, and the outcome is shelved ambition, unused capability, unaudited pilots, and eventual decommissioning attributed to the technology.
Governance as shared classification is slower to produce than a policy document and is the only version that holds when an agent's capability changes.
Frequently asked questions about agent governance
What is uniform agent governance?
Uniform agent governance is a policy model that applies one set of rules and one approval standard to every agent regardless of what it does. It fails because it treats an agent's ability to act and the scope of access it was granted as a single decision. Those are separate decisions, and organizations that collapse them end up over-restricting simple agents and under-restricting consequential ones.
Why do agent governance programs get decommissioned?
Agent programs typically get decommissioned because teams did not separate what an agent can do from what it can reach. Gartner projects that by 2027, 40% of companies will decommission agents for this reason. The failure surfaces later as a technology conclusion, though the cause is an unresolved governance decision. The model is rarely the constraint.
How does agent governance differ in a company built through acquisition?
Agent governance is harder in an acquisition-built company because the systems were never consolidated, so agents operate across seams that no single function can see end to end. A clearance granted inside one business unit can describe a narrower reach than the same agent has once it sits behind a combined data model. Reclassification is usually nobody's assigned job, which is how inherited agents end up touching consolidated reporting without a matching decision.
What is decision architecture in an agent context?
Decision architecture describes the part of an operating model that establishes who decides, what evidence a decision requires, where it is recorded, and who holds final authority when functions disagree. In an agent context, it defines what each agent is cleared to do and who is accountable for that clearance. It is the layer that determines whether governance is enforceable or aspirational.
What are proportional clearance levels for AI agents?
Proportional clearance levels assign oversight based on what an agent is permitted to do. The common set includes observe, advise, act with approval, and act autonomously. Each level carries different control requirements, ranging from scoped data access at the lowest level to human sampling at the highest. The levels are not a maturity model, and most agents should not advance beyond the lower ones.
Why does human review fail as agent oversight at scale?
Human review fails at volume because the approval queue becomes a formality once the count exceeds what a person can meaningfully assess. Reviewers begin approving on pattern rather than evidence, which produces a signature that no longer signals scrutiny. Work that needs attention then moves outside the official path to avoid the wait. Effective oversight depends on clearance level, not on reviewing everything equally.
Who should own agent governance?
Agent governance should be a shared classification owned across Engineering, Product, Legal, and the business rather than assigned to a single executive. Each function holds a piece of the knowledge required to set a clearance that holds: technical reach, intended use, obligation, and cost of failure. A single owner can write a policy but cannot reconcile those inputs alone. Consolidating the decision in one role is itself a failure mode.
How should an organization set an agent's clearance level?
A clearance level should be set by classifying what the agent does and what it can reach, then matching oversight to the higher of the two risks. The classification is repeatable and belongs to the functions accountable for the outcome, not to the team requesting access. Clearance also needs an owner who can move it when the agent's capability changes. Without that ownership, the level gets set by default.
I help executives at companies built through acquisition achieve numbers nobody argues about, a room they are never surprised in, and a business that is easier to run and easier to sell, so they can stop defending their reporting and start leading with authority.
If this sounds familiar, you're not alone.
The work is not about moving faster. It is about preserving judgment as systems scale.
If you are navigating this right now, book a Relevance Check. We will walk through what you can move first.
No pitch. Just the read.
Clinton Pracher | CP Product Advisory
