Blog

Autonomy Is a Governance Architecture, Not a Model Capability

  • Last Updated: Nov 19, 2026
  • 9 min read

Share on

Autonomy Is a Governance Architecture, Not a Model Capability
  • One 2026 survey of senior AI executives found 85% of those whose organization uses agentic AI saying at least a handful of those systems already execute actions without a human involved in real time. A separate survey of 3,235 business and IT leaders across 24 countries found 21% reporting a mature governance model for agentic AI.
  • Autonomy in IT operations is a property of the architecture around the model, not a property of the model. Better models raise the floor of what can be attempted. They do not decide whether an agent may write to a production system.
  • The architecture has to contain five structures: an absolute read and write boundary, risk tiers the business signs rather than the vendor, verification of the condition rather than the command, rollback as a designed path, and an audit record that answers why.
  • The unit of governance is the agent, not the model: which sources it may see, which roles may invoke it, which tools it may call, and whether that configuration has been reviewed and published rather than left in draft.
  • Governance does not raise coverage. It decides how much of the already automatable work an organization is willing to let run, which is why the two conversations keep getting confused in business cases.

Reimagined ITOps is a weekly series about what IT operations becomes when AI stops assisting and starts operating. This is article 12 of Season 1. Stay with it. 

Two numbers published this year sit badly together. 

In one survey of senior AI executives, 85% of those whose organization uses agentic AI said at least a handful of those systems already execute actions without a human involved in real time. In another, covering 3,235 business and IT leaders across 24 countries, 21% said their organization has a mature governance model for agentic AI. 

Nothing in that gap is about model quality. Both groups are buying the same models. 

My claim: autonomy in IT operations is a property of the architecture around the model, not a property of the model. What decides whether an agent may write to a production system is a set of structures you can draw on one page, and most programs have not drawn them. 

Process flow titled one write path, four gates, no exceptions. A read only reasoning block on the left connects to production systems on the right by a single arrow labeled the only write path, passing through four gates labeled risk tier, verify the condition, rollback ready and audit the why. A dashed bypass line beneath it is crossed out and labeled no second path. Reimagined ITOps S01 A12.

The Model Is Not What Is Stopping You

When we scoped the first write actions in a live estate, every blocking question was architectural. Who approves this class of change. What does the system check before it acts, and what does it check afterward. What happens when it is wrong at 2am. Who can reconstruct the decision six weeks later in front of an auditor. 

A better model answers none of those. It produces a more plausible recommendation, which is a different thing and occasionally a worse one. 

Here is the concession, and it is real. Model capability sets the floor of what can be attempted. Weak reasoning under good governance fails safely and often, which is annoying and survivable. Strong reasoning with no governance fails rarely and expensively. Only one of those is a risk you can price, and better models do raise the floor. 

What the Architecture Has to Contain

Five structures, and the specific failure each one prevents. 

A read and write boundary that is absolute. The layer that reasons never changes anything. Every state-changing action leaves through one governed execution path, and there is no second path. Without it you have a reasoning system holding production credentials, which is the finding a security review will open. 

Risk tiers the business signs, not the vendor. Low risk executes, medium risk executes inside guardrails, high risk waits for a named approver. The tiering is a business decision taken per class of demand. A vendor default is a configuration, not a policy, and nobody is accountable for a configuration. 

Verification of the condition, not the command. Most of what gets called verification checks that the command returned successfully. That confirms something ran. It does not confirm the disk is clear, the service is healthy, or the user can log in, which was the point. 

Rollback as a designed path. If the recovery plan for a failed action is a person on a bridge call, there is no rollback. There is an incident procedure with better branding. 

An audit record that answers why. Not only what ran and when, but what evidence the agent held, which policy applied, what it rejected, and who or what approved it. An action you cannot explain is an action you will eventually have to defend. 

The Unit of Governance Is the Agent, Not the Model

Most of the governance conversation in the market is about models. The things that actually need governing sit one level up: which sources an agent may see, which roles may invoke it, which tools it may call, and whether that configuration has ever been reviewed and published rather than left in draft. 

Draft versus published is the control that stops a demonstration reaching production. It looks like a configuration state. It is the governance boundary. 

An estate with one approved model and 40 unreviewed agent configurations is not governed. It is governed in the place where nothing happens. 

What This Costs

This architecture adds latency, adds cost, and makes the first deployment slower than a pilot that skips it. Guardrails do not demonstrate well. That is most of the reason the market builds them last. 

It also does not raise coverage. Governance does not make more work automatable. It decides how much of the already automatable work you are willing to let run, which is why the two conversations keep getting confused in business cases. 

And human oversight has to be a guardrail rather than a dependency. If a human approves every action, the result is the previous human process with added latency and a license fee. Early in a deployment, more is gated than the design requires, because trust is earned one class of demand at a time rather than one release at a time. That is a deliberate cost, not a capability gap, and it should be written down as such before anyone is disappointed by it. 

The Second Concession

Nothing here makes an agent safe on its own. These five structures make failure bounded, attributable and recoverable. They do not make it rare. An organization that builds all five and skips the work of deciding what an agent is allowed to decide has built a very well audited way of doing nothing. 

Architecture and delegated authority are two different problems, and both have to be solved. Last week’s article was about the second one. This one is about the first. 

What This Changes

Put the write path in the security review before the model evaluation. The model question is answerable in a week. The write path question will take a quarter and decides whether anything reaches production. 

Ask any agent vendor, including us, for those five structures on one page, with the failure each prevents named. A supplier who answers with model benchmarks has told you where their engineering went. 

Then stop buying autonomy as a capability. It arrives as a set of constraints you can audit, or it does not arrive. 

The Question for IT Leaders

Pick one system in your estate that an agent could usefully change tonight. 

Without opening a document, can you name the approver, the verification, the rollback path, and the place the record of that decision would live? If any of the four is blank, that is the gap between your pilot and your production estate. 

Next week: the four jobs left for the operations engineer when execution moves to the agents. 

Sanjesh Rao leads product strategy and innovation for Hexaware’s Agentic ITOps platform. 

Frequently Asked Questions

Because the questions that block a write action are not answered by a model. Who approves this class of change, what the system checks before and after it acts, what happens when it is wrong at 2am, and who can reconstruct the decision in front of an auditor are all properties of the system around the model. Model capability sets the floor of what can be attempted and does raise that floor, but it does not determine what an agent is permitted to change in a production system.

Five structures, each tied to the failure it prevents. An absolute read and write boundary, so the layer that reasons never changes anything and every state-changing action leaves through one governed execution path. Risk tiers signed by the business rather than set by a vendor default, where low risk executes, medium risk executes inside guardrails and high risk waits for a named approver. Verification of the condition rather than the command, because a command returning successfully is not evidence that the service is healthy. Rollback as a designed path rather than an incident procedure. And an audit record that answers why, including the evidence held, the policy applied, and what was rejected.

No, and conflating the two is a common error in business cases. Governance does not make more work automatable. It decides how much of the already automatable work an organization is willing to let run. It also adds latency and cost and makes a first deployment slower than a pilot that skips it. What it buys is failure that is bounded, attributable and recoverable, which is the condition for letting an agent near production at all.

Author

Sanjesh Rao

Sanjesh Rao

Senior Vice President, Product Strategy and Innovation, Digital IT Operations, Hexaware

Sanjesh Rao is Senior Vice President for Product Strategy and Innovation in Hexaware’s Digital IT Operations business, where he leads the company’s Agentic ITOps platform. Part strategist, part think tank, part builder, he has shaped how Hexaware and its customers run IT operations: from scripted automation to reasoning systems to governed autonomy. He writes from live enterprise deployments, and his teams build the platform his ideas describe. Reimagined ITOps is his weekly column on where IT operations go next.

Read more Blue Arrow Black Arrow