Skip to content
Home/Insights/Uncategorized/Your AI Agent Has Permission. But Does It Have Authority?

Your AI Agent Has Permission. But Does It Have Authority?

Your AI Agent Has Permission. But Does It Have Authority?

As AI agents move from assisting users to acting on their behalf, enterprise authorization faces a question that traditional access controls were not designed to answer.

In October 2026, Axios reported that major U.S. banks were detecting unvetted third-party AI agents operating inside customer accounts. In most cases, customers had handed their login credentials to these agents themselves. More concerning, some agents appeared to take actions independent of the customers’ instructions, and banks said they often could not tell whether account activity was user-directed or initiated by the agent on its own. JPMorgan, Citi, Bank of America, Morgan Stanley and others have moved to restrict third-party agent access.

The report did not cite confirmed losses or a widespread compromise. Much of the activity involved customers granting access to tools their banks had never approved. But the situation exposes a problem that reaches well beyond banking:

When a user gives an AI agent access to a system, how do we determine which actions the agent is authorized to perform?

We have spent decades building systems that authenticate identities and enforce permissions. Agentic AI introduces something different: software that interprets an objective, builds its own plan, and decides which actions to take without a human specifying each step. That makes the difference between having permission and having authority a practical security question, not a philosophical one.

Permission Is Not Authority

Consider a customer who asks an AI agent to review their bank transactions and find ways to reduce monthly expenses. The agent identifies recurring subscriptions and recommends canceling the ones that look unnecessary. So far, it is doing exactly what was asked.

Now suppose it goes further and cancels those subscriptions itself, reasoning that cancellation is the logical next step toward lower expenses. Did the customer authorize cancellation, or only an analysis? The answer is obvious to a human. It is not necessarily obvious to an autonomous system working from a broadly worded objective.

The agent may have valid credentials. It may be using supported application features. It may even achieve the customer’s financial goal. None of that establishes that the customer authorized the action.

This is the distinction the rest of this article rests on. Technical permission determines whether an identity can perform an operation. Delegated authority determines whether that operation falls within the responsibility the user actually intended to hand over. The two often overlap, but they are not the same thing.

What Changes When Software Decides What to Do

The underlying problem is not entirely new. Service accounts, scheduled jobs and workflow engines have long run with significant privileges, and badly configured automation has deleted the wrong records and triggered the wrong processes for as long as automation has existed.

But traditional automation executes steps defined in advance. An AI agent can be given an outcome instead and left to decide the steps.

Suppose an enterprise agent is told to reduce cloud infrastructure costs by 20%. It analyzes utilization, finds underused virtual machines, and reviews storage consumption. Depending on its tools and permissions, it may then stop virtual machines, change service tiers, or remove resources it considers unnecessary. It is no longer executing a procedure. It is choosing which procedures are appropriate.

That shifts responsibility in a subtle way. A human authorized the objective, not every possible method of reaching it. The agent may see shutting down a lightly used production service as a sensible saving; the business owner may consider that service essential despite low utilization. Both views can be internally consistent. Only one is acceptable to the business.

The agent did not necessarily misunderstand the environment. It may have correctly spotted a real saving. The failure occurs when the agent treats its own interpretation of the objective as sufficient authority to act.

Three Questions, Two Answers

It helps to separate three questions that every agent actions raise:

  1. Who is acting? The human user, an application, or an AI agent operating on the user’s behalf?
  2. What can the actor do? Which resources and operations are available through its credentials and permissions?
  3. What was the actor authorized to do for this task? Does this specific operation fall within the responsibility the user delegated?

Enterprise security has mature answers to the first two. Authentication and identity management handle the first. Role-based and attribute-based access control, OAuth scopes and Zero Trust policy handle the second. These are established, necessary controls.

The third question is where the gap lies. Take a cloud administrator who is permitted to stop production virtual machines. An agent running with that administrator’s privileges can call the same APIs. But the administrator’s permission does not mean the agent has been authorized to stop any production machine whenever it concludes that doing so would help. The operation can be perfectly valid from an identity and access perspective while still falling outside the task.

A sufficiently granular policy could prevent this, by restricting the agent to development resources or requiring approval for production changes. That is precisely the point. The hard part is translating a user’s task-specific intent into enforceable controls when the agent’s execution plan is not known in advance.

In practice, that translation usually does not happen. The boundary lives in the prompt instead. But an instruction such as “do not modify production resources” is not equivalent to an access policy that prevents production modifications. If the agent retains broad privileges, the boundary depends entirely on the agent interpreting and following its instructions correctly. That may shape its behavior. It is not independently enforced control.

The banks’ response illustrates the gap well. According to Axios, most are moving toward allowing agents read-only access: agents may view account information but cannot act on it. That is a reasonable interim measure, and it is also revealing. Lacking a way to express “act only within what this customer delegated for this task,” the only enforceable lever available was to remove the ability to act at all.

An Agent Should Not Be the Sole Judge of Its Own Authority

An obvious response is to instruct agents to check their authorization before taking consequential actions. That is useful, but it raises a further question: who is doing the checking?

If the same agent interprets the objective, builds the plan and then decides whether its proposed action is permitted, the authorization decision rests on the same interpretation that produced the action. One wrong assumption can drive both.

Consider a software engineering agent asked to fix a performance problem. It discovers that a validation step accounts for much of the processing overhead and concludes that removing it will improve performance. Technically, it may be right. But that validation might exist to satisfy a regulatory requirement or protect a critical business invariant. If asked whether removing it falls within its task, the agent may well say yes, because its task is performance and the validation is in the way. Its reasoning may be coherent. That does not mean the business authorized it to redefine the application’s compliance obligations.

Better prompts and richer context reduce mistakes like this, but they do not remove the need to establish which decisions an agent may make on its own. There must be a separation between an agent’s ability to propose an action and the system’s authority to permit it.

This does not mean every operation needs a human in the loop. Organizations can authorize categories of action in advance, define acceptable conditions, and set thresholds for automatic execution. The principle is that those boundaries are enforced independently of the agent’s interpretation. The agent can decide what it wants to do. It should not be able to decide, on its own, that it has the authority to do it.

Accountability Gets Harder

The banking case raises one more problem. Suppose an agent initiates a transaction with the customer later disputes. The audit trail shows valid credentials, a submitted request and a completed transaction. That establishes what happened technically. It does not establish whether the customer authorized that particular transaction.

The same holds inside the enterprise. If an agent modifies production data, the log may identify the service account that made the change. It probably will not show which human delegated the task, what boundaries came with that delegation, or whether the operation exceeded them. And an agent’s own explanation of what it did is not evidence of authorization.

Meaningful accountability needs to distinguish four things: the original instruction, the authority granted, the action proposed, and the action executed. Without that separation, an organization can know exactly how an operation happened and still be unable to say whether it should have happened. That is not a logging problem. It is an architectural one, spanning identity, delegation, authorization and responsibility.

Far Broader Than Banking

Banks are meeting this problem early because their systems hold sensitive data and execute transactions with immediate consequences. The same questions arise wherever agents are allowed to carry out business operations:

  • A customer service agent can update customer accounts. Does that include changing contractual terms?
  • A security operations agent is authorized to investigate suspicious activity. Does that include disabling an executive’s account during a critical business event?
  • A software engineering agent can modify source code. Does that include removing a security control to meet a performance target?
  • A finance agent has access to invoices and payment systems. Does identifying a valid invoice authorize it to release payment?

In each case the operation is technically available to the agent. The open question is whether it falls within the authority delegated for the task.

Many enterprise systems were built on a simple division of labor: users make decisions, applications execute them. Autonomous agents move part of the decision-making into the application itself, and that changes the relationship between identity, permission and responsibility.

The Next Authorization Boundary

The answer is not to eliminate agent autonomy. Much of the value of agentic systems comes from their ability to work out how to reach an objective without constant human direction, and requiring approval for every minor step would destroy that value. But unrestricted autonomy is not the alternative.

Enterprises need to distinguish between decisions an agent may make on its own and decisions that require additional authority. Some of those boundaries can be expressed through existing access controls. Others depend on business context: resource sensitivity, transaction value, reversibility, and the consequences of getting it wrong. The challenge is making those boundaries explicit and enforceable without having to define every possible execution path in advance, and it deserves attention before organizations extend agent access to production systems, financial operations and customer records.

We have spent decades building systems that verify whether an identity is permitted to perform an operation. Agentic AI adds a question those systems were never designed to ask:

Is this particular action within the authority delegated to the agent for this task?

An agent can pursue a legitimate objective, use valid credentials and execute a technically permitted operation while still doing something the user never authorized. As enterprises move toward more autonomous systems, that distinction can no longer stay buried in application logic or natural-language instructions. It has to become an explicit part of how we design and secure those systems.

In our next article, we look at what that looks like in practice: how to scope delegation, separate proposing from executing, and build an audit trail that can answer not just what an agent did, but whether it was allowed to.


References

  1. Madison Mills, Axios, October 22, 2026. Scoop: Unvetted AI agents are accessing U.S. bank accounts.
  2. Reuters, October 22, 2026. US banks are blocking third-party AI agents access to customer accounts.
  3. NIST, Special Publication 800-207. Zero Trust Architecture.
Share Email
Previous AI in practice – The number looked retrieved. It was Generated Next The Phishing Email Came From a Real Colleague. That Was the Problem.