labb and Spico Solutions are now part of NETbuilder. Learn more or browse our services below.

Who Gets to Say Yes? The Case for Governed Autonomy in Agentic AI

As AI agents take on greater responsibility, organizations face a critical challenge: how to balance autonomy with security. Governed autonomy offers a practical way to achieve both without compromising efficiency.

Imagine an AI agent tasked with updating a customer’s address. It finds the record, attempts the change, and gets a timeout. So it tries again.

This time, it spots another tool that could do the job. It’s more powerful, capable of changing thousands of records rather than one, but it works. The agent reports success.

The customer gets their address changed. The agent has completed its task. So what’s the problem?

Somewhere between encountering an error and finding a solution, the agent decided to use more authority than the task required.

It’s a hypothetical example, but it points to a very real question for organizations deploying agentic AI: how much freedom should an agent have to get the job done, and who decides when that freedom has gone too far?

An Old Security Principle, a New Decision-Maker

Least privilege is a long-established security principle that predates today’s agentic-AI revolution: grant only the access needed for the job.

Sounds simple enough. And for an agent performing a narrowly defined task, removing unnecessary permissions is the obvious answer. But as we all know, enterprise work doesn’t always fit neatly into one task.

An agent managing customer accounts might need to view records, update contact information, and occasionally initiate account closure. Those actions require different permissions, so AI agents need to be able to choose tools, adapt their approach, and try alternatives depending on the task at hand.

While this sounds perfect in theory, a recent study uncovered some concerning behavior. The research, available at ACL Anthology, found that agents frequently chose higher-privilege tools even when lower-privilege options could complete the task. Six of the 11 models tested escalated in more than 30% of cases, with temporary tool failures making that behavior more likely. It was found that privilege-aware post-training “substantially reduces unnecessary high-privilege tool use while preserving general capabilities,” however, only to 27%, which is still a substantial risk.

Another October 2026 study explored the same issue. By showing agents which tools carried higher privileges, over-privileged selection was reduced by up to 19.3 percentage points, but the researchers concluded that this couldn’t replace independent enforcement.

Autonomy vs. Authority

These findings present an obvious security issue, but what is the answer?

One could be to give agents broad permissions and trust them to behave sensibly. After all, autonomy is the point. But there’s a difference between trusting an agent to find a solution and allowing it to decide which actions it’s entitled to take.

Another could be to require human approval whenever an action looks sensitive. That sounds safer, until automation becomes an endless queue of requests. NIST has warned about consent fatigue: if people approve enough prompts, they may stop thinking carefully about each one.

Neither approach offers a convincing way to scale. Broad permissions increase exposure, while excessive approvals introduce delays, operational costs, and another dependency on human availability.

For organizations investing in automation to increase capacity and reduce manual intervention, that’s a significant problem.

Governed Autonomy

Our view is that agents should be autonomous in how they complete a task, but not in deciding the limits of their own authority. In other words, governed autonomy.

  1. The agent chooses how to achieve an authorized outcome.
  2. A separate, enforceable control decides whether a proposed action is allowed.
  3. People define the rules, acceptable risks, and circumstances that genuinely require human judgment.

This builds on established security practices, not a radical new philosophy. The challenge is applying them when an agent’s next step may not be known in advance.

NIST’s proposed agent identity design tenets, published in October 2026, support this separation between what an agent wants to do and what the system permits it to do. They are proposed principles, not a formal standard, but the direction is compelling.

There’s an important catch: an agent shouldn’t be able to invent a justification for more access and have that accepted as proof. Identity, task scope, and permissions need to come from trusted sources. Otherwise, even an external policy engine risks rubber-stamping whatever the agent claims it’s doing.

What It Looks Like in Practice

Let’s go back to the hypothetical customer account agent mentioned at the beginning of this article.

For an address change, it receives permission to view the relevant account and modify contact fields. It can choose between approved methods and can recover from ordinary errors. If one tool times out, it can retry or use another route within those boundaries.

What it cannot do is treat a bulk-administration tool as an acceptable shortcut. If the task genuinely requires additional authority, it requests that authority instead of taking it. An independent control evaluates the request, with a person involved only where there is sufficient risk to justify it.

This ensures routine work continues without unnecessary delays, while higher-risk decisions receive appropriate scrutiny, allowing organizations to increase automation without proportionately increasing the number of people needed to supervise it.

And that’s the opportunity governed autonomy presents. Not simply reducing risk, facilitating scale.

Where the Authority Comes From

So who tells the control what the agent is entitled to do? In most enterprises, the answer already exists: the workflow.

An address change is rarely a standalone event. It’s one step in a process that has a case, an owner, and a history. By the time the agent is called, the workflow knows who made the request, whether their identity has been verified, and what should happen next.

That context is what makes governed autonomy workable.

  • The workflow, not the agent, states the task
  • Authority is granted for that step and ends when the step completes
  • If the agent needs more, the request becomes a routed step in the same process, reaching the right approver with the full case in front of them

The agent keeps its freedom inside the step. The process decides what the step is allowed to be.

The Difficult Decisions Are in the Design

Of course, this is easier to describe than to implement. Permissions must reflect the task and business context, and enforcement has to sit somewhere the agent cannot bypass.

We would encourage organizations to ask themselves the following questions:

Who Determines What the Agent Is Authorized to Do?

It’s not enough for an agent to declare its own task and request the corresponding permissions. The authority to act needs to come from a trusted business process, user, or system. Otherwise, the organization risks automating decisions about access without properly establishing who authorized them.

Does the Agent Need Permanent Access?

Short-lived, task-specific permissions can reduce exposure without restricting legitimate work. But there’s a balance to strike: introducing excessive complexity into identity management can create operational problems of its own. The level of control should reflect the risks involved.

Do the Boundaries Hold When the Agent Changes Its Approach?

An agent might use different tools, call another agent, or attempt an alternative route after a failure. Controls need to remain effective across those paths. Securing one tool achieves little if another provides a way around the restriction.

When Does Human Intervention Genuinely Add Value?

High-impact decisions may justify approval, but routine actions generally shouldn’t. The challenge is defining the right thresholds, rather than simply labeling everything involving elevated permissions as dangerous.

Can You Explain and Improve the Decisions Being Made?

Organizations should be able to establish what an agent attempted, why it was permitted or denied, and what happened next. That visibility supports security and accountability, but also helps identify inefficient workflows, unnecessary escalations, and opportunities to expand automation safely.

Remember that independent enforcement doesn’t make mistakes impossible. That’s why it’s essential that decisions happen within a framework that can be reviewed, tested, and improved.

Better Governance Should Enable More Autonomy

Security and autonomy are often treated as opposites. More controls equal less freedom, right? We think it’s more nuanced than that.

When an organization can confidently define what an agent is permitted to do, it can give that agent greater freedom over how to do it, which we believe makes autonomy more sustainable.

Organizations won’t realize the full value of agentic automation if every new deployment demands its own collection of manual approvals, exceptions, and workarounds.

It also helps to improve. If an agent repeatedly requests access outside its scope, that tells us something. Perhaps the task definition is too narrow? Perhaps the agent is choosing the wrong tools? Perhaps the workflow needs redesigning?

This isn’t an argument for elaborate dynamic authorization everywhere. Some techniques are still maturing, and there will always be trade-offs between security, complexity, and speed. But none of that excuses giving agents broad access simply because narrower controls take more thought.

As agentic automation moves from experiments into business-critical operations, the question isn’t only what agents can do. It’s what they should be allowed to do, under which conditions, and who is accountable.

Our position is straightforward. The agent decides how to do it, independent controls decide whether to do it, and humans set the boundaries for both.

In conclusion, I’ll ask you this:

If your agent decided a more powerful tool was the easiest way to finish its task, what would stop it?

If the answer is “the prompt told it not to,” that’s a behavioral expectation, not an enforced permission boundary.

And if the answer is “someone approves every action,” it’s worth asking whether that person is making thoughtful decisions or simply trying to keep up.

Getting that balance right isn’t just a security challenge.

The answer to both questions is rarely found in the agent. It’s found in the process the agent works within, and it’s fundamental to making enterprise agentic automation work at scale.

Learn More

If you want to see where your agents get their authority, and how workflow can govern it, talk to the NETbuilder Automation team.

About the author

Rob Smart

Head of Solutions
Dynamic and results-driven Principal Architect with over 20 years of extensive experience in designing, pitching, implementing, and operating AI & automation solutions to drive digital transformation for large corporates and the public sector. A passionate Pega professional, both a Certified Lead System Architect a (CLSA) and Certified Decisioning Consultant (PCDC), specialising in business orchestration, intelligent automation, omnichannel CX, cloud migration, and the practical application of agentic AI.
Other popular articles

Other popular articles

Free download

Agentic Self-Service: The Future of Customer Service Automation

Agentic self-service is reshaping how enterprises deliver customer service, enabling digital channels to complete outcomes rather than simply respond to queries. This white paper provides a shared blueprint for leaders across CX, operations, technology, risk, and procurement to evaluate readiness, align priorities, and scale agentic self-service responsibly.