
Why enterprise AI needs clearer delegated authority, not just broader access to business systems.
As AI agents take on more responsibility in enterprise operations, the question is no longer just how much work they can automate, but how much authority organizations should give them. The value of an AI agent is not just in what it can access, but in understanding what it is authorized to do. Through a practical case-study example, this piece explores why clearly defined boundaries are essential to both security and agent performance, who should own those boundaries and be accountable for enforcing them, and why getting it right requires a multi-pronged approach across the organization.
A Small Example with a Big Challenge
Imagine an enterprise deploying an AI agent to handle customer support requests, such as a refund.
The agent can retrieve customer records from the CRM, check billing and subscription details, and interact with the payment platform. It has the credentials and permissions needed to use these systems. A customer contacts support about an unexpected charge and asks for help resolving it.
The agent investigates the transaction and determines that the customer may be eligible for a refund. It also discovers that the customer has an upcoming renewal and could potentially benefit from a different subscription plan.
The agent now has several possible actions:
- Should the agent issue the refund?
- Can it change the subscription?
- Could it offer additional compensation to retain the customer?
Technically, the agent may have access to perform all three actions. But the customer only asked it to resolve a disputed charge. Connecting agents to more applications or giving them additional permissions won’t resolve this problem. The agent needs to understand what it has been authorized to accomplish, which decisions it can make independently, and when it needs someone else’s approval.
For CIOs and technology leaders looking to move beyond AI pilots, defining these boundaries is an important part of enterprise architecture.
Permission to Access a System Is Not Authority to Make Every Decision
Most enterprises already have established approaches to identity and access management. Applications and users receive identities, permissions are assigned, and access to systems is controlled through policies. AI agents need these controls too. Giving an agent its own identity makes it easier to manage access, attribute actions, and revoke credentials when necessary.
But an identity tells us which agent is acting. Permissions establish which operations it can technically perform. Neither necessarily tells us what the agent was authorized to accomplish in a particular business workflow. Consider the customer support example.
The agent might have permission to initiate refunds because that capability is required for some support cases. But having that permission does not mean every customer conversation authorizes a refund. Unlike a conventional application workflow which usually follows what engineers have explicitly programmed, an AI agent may interpret a broader objective, select tools, and determine its next action based on information it encounters.
That flexibility is part of what makes agents useful. It also means the organization needs to be more precise about the authority it delegates. A request to investigate a billing issue should not automatically become permission to modify an account or move money.
Clear Boundaries Can Make Agents More Useful
There is a tendency to approach agent security by restricting capabilities or requiring human approval for every consequential action. That may be appropriate for early experiments, but it becomes difficult to scale if every routine decision needs manual intervention. A more useful approach is to separate the operations an agent can perform from the decisions it is authorized to make.
Take the billing dispute workflow. The agent could be allowed to retrieve the customer’s transaction history and compare the disputed charge against the subscription agreement. It could calculate whether the customer qualifies for a refund using the organization’s existing billing rules.
If the customer is eligible and the amount falls within an approved policy, the agent might be permitted to initiate the refund without additional approval. However, changing the customer’s payment destination, offering exceptional compensation, or modifying a subscription could require separate authorization. These boundaries would be defined by the organization based on the risks and business rules involved.
The benefit is that teams can identify which parts of a workflow are suitable for independent execution and which require human judgment or additional controls. An agent does not need to make every business decision itself. It can investigate a problem, collect the relevant information, propose an action, and invoke an application that makes the final determination using established rules. The objective should be to give agents enough autonomy to complete legitimate work without allowing them to redefine the scope of that work.
Three Controls That Make Agent Boundaries Enforceable
There are three areas enterprises need to bring together when designing agent-driven workflows: agent identity, delegated authority, and runtime enforcement.
Agent identity establishes who is acting.
Each agent should have an identifiable principal that allows the organization to manage its access and attribute its actions. This becomes especially important when several agents use the same applications or when an agent operates on behalf of a human user. Organizations need to distinguish between the agent’s identity and the authority of the person or business process that initiated the work.
Delegated authority establishes what the agent has been authorized to do.
An employee asking an agent to investigate a billing dispute is delegating a particular task, not necessarily every permission that an employee possesses. The delegated authority should reflect the scope of that request. That could include the customer account involved, the operations permitted, the duration of the task, and conditions requiring additional approval. These restrictions should be represented in enforceable policies wherever possible, rather than relying entirely on natural-language instructions.
Runtime enforcement checks whether an action falls within those boundaries.
Before an agent invokes a sensitive API or tool, a trusted enforcement point can evaluate the request against the applicable restrictions. For example, a support agent attempting to change a customer’s payment destination could be blocked or required to obtain separate approval, even if its underlying identity has access to the payment platform. The important point is that the agent should not be the only system deciding whether its own actions are authorized.
These controls need to work together. Identity without task context can leave agents with excessive standing permissions. Delegated authority without enforcement may amount to little more than an instruction the agent is expected to follow.
Runtime enforcement also has limits. It cannot reliably determine whether a refund is legitimate unless it has access to authoritative business rules and current application state. The billing application must still enforce eligibility, transaction limits, and other business requirements. For consequential operations, the organization may also need to verify the resulting state independently.
The Challenge Becomes Harder When Agents Work Together
Enterprise workflows rarely stay within a single application, and increasingly they may not stay within a single agent, which is an obstacle worth exploring.
Suppose our customer support agent delegates the refund calculation to a finance agent. The finance agent needs access to relevant transaction information and the rules used to determine eligibility. But does it need permission to issue the refund? Probably not.
Its delegated responsibility is to calculate eligibility and return the result. The support workflow or billing application can then determine whether to execute the transaction.
The second agent should not automatically inherit all the permissions available to the first. The organization also needs to preserve enough context to understand which customer request initiated the work, what authority was delegated, and what each agent actually did.
If a delegated agent discovers that it needs additional access, there should be a defined process for requesting that authority. It should not be able to expand its permissions simply because it considers the action useful. Enterprise architects need to account for these decisions when designing multi-agent workflows. Otherwise, teams may end up with agents that are individually well secured but collectively difficult to govern.
Who Owns the Boundaries?
One question on repeat is who should actually define and enforce these limits. Is it the identity team? The AI platform team? The application owner? Or security? In practice, each has a different responsibility, and it should be a multi-pronged approach.
The business and application owners understand what legitimate decisions look like. They know when a refund is permitted, what constitutes an exception, and which actions require approval.
IAM teams provide the mechanisms for managing identities, permissions, and delegated access.
AI platform and engineering teams determine how agents interact with applications, how task context is preserved, and where enforcement happens.
Security teams establish requirements, assess the risks, and test whether the boundaries work as intended.
For CIOs and CTOs, the challenge is ensuring these responsibilities are connected.
An identity team cannot independently determine whether a customer qualifies for compensation. Equally, an application team should not have to invent its own identity and delegation infrastructure for every agent it deploys. There also needs to be a clearly accountable owner for the end-to-end workflow.
Without that ownership, it becomes difficult to answer a basic question when something goes wrong: which team was responsible for defining the authority the agent was supposed to operate within?
Building Enterprise AI Around Authority, Not Just Access
As enterprises move from isolated AI experiments to agents performing real business operations, access to tools will become easier to provide, while the harder work will be deciding how much authority those agents should have.
In our customer support example, the agent does not need unrestricted control over the billing platform to resolve a disputed charge. It needs permission to investigate the issue, access to the relevant information, and clearly defined authority to take specific actions.
When a request falls outside those limits, the workflow should provide a way to obtain additional authorization rather than allowing the agent to make that decision for itself. For enterprise technology leaders, this requires coordination between application architecture, identity infrastructure, AI engineering, and business ownership. The measure of a successful agent deployment should be how much work the agent can reliably complete within the boundaries authorized by the organization.
About the Author
Ashish Rajan is the CISO of TechRiot.io, author of AI Security Engineering (Wiley), and Chief Researcher at AI Security Lab. His work focuses on how AI systems are built, where they fail, and the security engineering practices needed to secure them. He also hosts the Cloud Security Podcast and AI Security Podcast.


