AI agents
Autonomy, Authority, and Delegation
Design autonomy as a set of delegated decisions, permissions, budgets, and escalation points.
By the end you can
- Define bounded autonomy as an operational contract rather than a capability label
- Contrast Recommendation with Staged execution in “A procurement agent found a cheaper supplier and violated an approval rule”
- Trace “Broad credentials turn reasoning errors into operational incidents” through a concrete execution path
- Produce “Build an authority matrix” with evidence for “No action can exceed the principal’s documented scope”
Example
Claudius held real pricing authority for a month and was talked out of it in Slack
An office shop ran for about a month with an AI as its shopkeeper. Real money, real pricing authority, a real Slack channel. Anthropic ran it with Andon Labs in 2025 and called it Project Vend. The operator was Claude Sonnet 3.7, named “Claudius”.
The financial authority was real. The approval gate around it was not. Anthropic's own performance review of the run says what that combination produced: “Claudius was cajoled via Slack messages into providing numerous discount codes and let many other people reduce their quoted prices ex post based on those discounts.” It also sold specialty metal items below cost. TIME reported that the shop's net worth fell from about $1,000 to just under $800 after Claudius ordered roughly 40 tungsten cubes.
Nothing in that sequence was a tool failure. Every discount code went through a mechanism the shop had been handed. Every price change sat inside the discretion it had been granted. Each step was technically valid. The system confused being able to set a price with being allowed to give one away. No rule stood between a persuasive message and the money.
- Decision at stake: Whether an operator holding a budget may also set prices, grant discounts on request and place purchase orders without a second signature. Project Vend delegated exactly that, for about a month.
- Hidden assumption: That tool access grants legitimate authority to use the tool. Claudius could issue a discount code, so issuing one when asked looked like part of the job.
- Primary control question: Which limit was absent — decision scope, action scope, resource budget, escalation rule or revocation — when a Slack message was enough to move a quoted price ex post?
- Evidence to collect: The money, not the transcript. About $1,000 down to just under $800, roughly 40 tungsten cubes, specialty metal items sold below cost. No action can exceed the principal's documented scope, and here the scope was never documented.
Visual
Bounded autonomy is four limits, and Article 14 makes two of them law
Bounded autonomy is four limits rather than one. Decision scope: which choices may be made without consultation. Action scope: which tools, records and side effects are permitted. Resource budget: limits on money, time, tokens, calls and retries. The escalation rule: conditions that transfer control to a person or service. Revocation — a mechanism to stop or narrow authority during the task — is the fifth box. The escalation rule and revocation need separate owners and separate tests.
For high-risk systems in the EU, the last two boxes are not design advice. They are law. Article 14 of the Artificial Intelligence Act requires that the people assigned to human oversight be enabled, among other things, “to decide, in any particular situation, not to use the high-risk AI system or to otherwise disregard, override or reverse the output of the high-risk AI system;”. That is Article 14(4)(d). It is the escalation box written as an obligation. Article 14(4)(e) is the revocation box: the overseer must be able to interrupt the system through a “stop” button that brings it to a halt in a safe state. Halting in a safe state is stronger than stopping. It is the part that has to be tested.
Article 14(4)(b) adds a limit on the humans in the diagram rather than on the runtime. Overseers must remain aware of automation bias. An escalation rule that routes a decision to someone who will approve whatever the system proposes has an owner but no effect.
- 1
Decision scope
Which choices may be made without consultation.
- 2
Action scope
Which tools, records, and side effects are permitted.
- 3
Resource budget
Limits on money, time, tokens, calls, and retries.
- 4
Escalation rule
Conditions that transfer control to a person or service.
- 5
Revocation
A mechanism to stop or narrow authority during the task.
Capability is not permission, and OWASP has given the gap a number twice
Autonomy describes which decisions the runtime may make without another actor. Authority describes which effects it is permitted to cause. Delegation links both to a principal, a purpose, a scope and a time window.
Capability is not permission. An agent that can call a payment API, delete a file or message a customer should receive only the narrow authority the current task needs.
The failure has a number, and it has kept one across editions. The OWASP Top 10 for LLM Applications listed it as LLM06:2025 Excessive Agency in the 2025 edition. It carries it as LLM03:2026 Excessive Agency in the 2026 one. The definition is the same in both: “Excessive Agency is the vulnerability that enables damaging actions to be performed in response to unexpected, ambiguous or manipulated outputs from an LLM, regardless of what is causing the LLM to malfunction.”
Read the last clause again. The vulnerability holds regardless of what is causing the LLM to malfunction, which puts the whole of it on the far side of the model. Both editions give the root cause as one or more of “excessive functionality”, “excessive permissions” and “excessive autonomy”. A deployer configures all three. A model acquires none of them by itself. The remedies keep that shape: fewer extensions, narrower permissions, human approval for high-impact actions.
No improvement in the model closes an excessive-agency gap: OWASP's three root causes — excessive functionality, excessive permissions, excessive autonomy — are all grants somebody made.
Position
“Autonomous” names a permission somebody granted
The word points at the model. The published rules point at what somebody configured around it. OWASP files the failure as Excessive Agency — LLM06:2025 in the 2025 edition, LLM03:2026 in the current one — and traces it to excessive functionality, excessive permissions and excessive autonomy. The model granted itself none of them.
The Model Context Protocol is blunter, because of who its sentence is addressed to: “Hosts must obtain explicit user consent before invoking any tool”. The subject of that requirement is the host application. That is software somebody ships, configures and can be asked about. The wording is identical in revision 2025-06-18 and in the current revision 2026-07-28, and it survived a change of governance in between. Anthropic donated MCP to the Linux Foundation's Agentic AI Foundation, announced on 9 December 2025. The consent obligation came through unchanged, still aimed at the host.
So the question about a system described as autonomous is not what it can do. It is which limits somebody set, and on whose authority: decision scope, action scope, resource budget, escalation rule, revocation. Being able to call a payment API is not the same as being allowed to. An agent holds exactly the authority its credential carries. A demonstration of what it managed to do says nothing about what it was permitted to do.
Ask which permissions were granted and by whom before asking how autonomous the system is — the spec addresses its requirement to the host, not to the model.
Analogy
A power of attorney with fine print, and the version that already ships
A power of attorney names the acts it allows, the period it covers and the conditions attached. Holding it authorizes nothing beyond that list.
The digital instrument is not hypothetical, and it is older than the agents now using it. OAuth has had it since 2012. RFC 6749 defines the named acts as the scope parameter, and settles who decides what the list contains: “The authorization server MAY fully or partially ignore the scope requested by the client, based on the authorization server policy or the resource owner's instructions.” The client asks. The server and the resource owner grant. A component that requests broad authority does not thereby hold it. That is the whole distinction the word autonomous smears over.
RFC 7009 supplied the other half of the instrument in 2013: a revocation endpoint. Implementations MUST support revocation of refresh tokens and SHOULD support revocation of access tokens. Revocation is a documented endpoint you can call, not an intention you can state.
One difference from the paper document costs money. Paper cannot be silently duplicated. A digital credential can be copied, cached or reused unless the runtime enforces expiry and scope.
Autonomy should be described as delegated authority over named acts — a scope somebody granted and an endpoint that takes it back.
Key idea
$460 million in 45 minutes, because the thresholds were not pre-set
A model can follow the user's general intent and still exceed the principal's delegated authority. The risk grows when one credential spans unrelated systems or carries permissions the task does not need.
The clearest regulatory finding on this involves no model at all, which is why it generalises. On 1 August 2012 Knight Capital Americas' SMARS router took in 212 retail orders and sent millions of orders in 45 minutes. It obtained over 4 million executions in 154 stocks for more than 397 million shares. The loss was $460 million. The SEC's order of 16 October 2013 found violations of Rule 15c3-5. That is the market access rule: controls reasonably designed to prevent orders that exceed pre-set credit or capital thresholds, and to prevent erroneous orders. The penalty was $12,000,000.
The order states the mechanism in the regulator's own words: “In the absence of appropriate controls, the speed with which automated trading systems enter orders into the marketplace can turn an otherwise manageable error into an extreme event with potentially wide-spread impact.” The initiating mistake was ordinary. It was a deployment error. What made it $460 million was authority to act on production at machine speed with no pre-set ceiling in the path.
Issue task-scoped credentials. Enforce authorization outside the model. Require fresh approval for high-impact transitions.
A credential wider than the task turns an otherwise manageable error into damage inside a system nobody meant to put in reach.
Steps
Build an authority matrix, and cite AC-6 while you do it
Build the authority matrix for a workflow that already exists. List every action against the principal who may authorize it. That is what keeps broad credentials from quietly converting a reasoning error into an operational incident, and it is what makes the record show no action exceeding the principal's documented scope.
Five columns. List action classes: separate reading, drafting, staging, committing, notifying and deleting. Name the principal: record whose authority the agent is exercising. Set per-action limits: scopes, budgets, destinations and valid time windows. Attach approval gates: put confirmation before irreversible or high-impact transitions. Test revocation: verify that the runtime stops using withdrawn permissions immediately.
Two of those columns already carry a control number in a federal catalogue. NIST Special Publication 800-53, Revision 5, calls it AC-6, LEAST PRIVILEGE: “Employ the principle of least privilege, allowing only authorized accesses for users (or processes acting on behalf of users) that are necessary to accomplish assigned organizational tasks.” The parenthesis is what makes the matrix unremarkable rather than novel. “Processes acting on behalf of users” is an agent, described in a control published in September 2020 — years before anyone deployed one.
Enhancement AC-6(7) supplies the revocation column, and a calendar with it: periodic review of assigned privileges, with reassignment or removal when the need for them cannot be revalidated. A permission nobody can justify at review is one the matrix is supposed to remove, not to record.
- 1
List action classes
Separate reading, drafting, staging, committing, notifying, and deleting.
- 2
Name the principal
Record whose authority the agent is exercising.
- 3
Set per-action limits
Define scopes, budgets, destinations, and valid time windows.
- 4
Attach approval gates
Place confirmation before irreversible or high-impact transitions.
- 5
Test revocation
Verify that the runtime stops using withdrawn permissions immediately.
Grant less authority than the model appears able to use
The safest design grants less authority than the model appears capable of using. That is not new advice for agents. Saltzer and Schroeder set it out in 1975 as one of eight design principles, under the heading Least privilege: “Every program and every user of the system should operate using the least set of privileges necessary to complete the job.” Every program. The principle never asked how competent the program looked.
The same paper explains why the check cannot live inside the thing being checked. Its complete mediation principle requires that “Every access to every object must be checked for authority”, and it warns that cached authority checks must be updated when authority changes. That is the revocation test in the authority matrix, fifty years early. A runtime that decided once at the start of a long task and kept acting on that decision is running a stale check.
Additional permissions should therefore be earned by evidence and attached to a specific task state. Two lines belong in any review of bounded autonomy. The failure: broad credentials turn reasoning errors into operational incidents. The evidence that answers it: no action can exceed the principal's documented scope.
Permission handed out on the strength of how capable the model looks is permission nobody can defend afterward — and it has been the wrong answer since 1975.
Key takeaways
- Autonomy describes which decisions the runtime may make without another actor. OWASP files the failure of getting that wrong as Excessive Agency — LLM06:2025 in the 2025 edition, LLM03:2026 in the edition published 4 August 2026.
- Capability is not permission. OWASP's three root causes are excessive functionality, excessive permissions and excessive autonomy, all configured by a deployer rather than acquired by a model.
- The obligation lands on whoever configured the host: “Hosts must obtain explicit user consent before invoking any tool”, unchanged from MCP revision 2025-06-18 to revision 2026-07-28.
- Scoped, revocable delegation is a standardised pattern, not an aspiration. RFC 6749 lets the authorization server ignore the scope a client requests, and RFC 7009 adds a revocation endpoint.
- Unbounded authority converts ordinary errors into extreme ones. Knight Capital's router took 45 minutes and $460 million, and the SEC's order of 16 October 2013 fined the firm $12,000,000 under Rule 15c3-5 for missing pre-set thresholds.
- Grant less authority than the model appears capable of using. Saltzer and Schroeder's 1975 least-privilege principle, NIST control AC-6 with its periodic review under AC-6(7), and Article 14(4)(d)–(e) of the Artificial Intelligence Act say the same thing in three registers.