Delegation Is Not Authority: Governing Multi-Agent Handoffs
When one agent hands work to another, authority should narrow, never widen. A delegated task must carry its origin and its limits, or it becomes a way to launder a prohibition.
Written as at 9 August 2026.
multi-agent-systemsai-securityauthorisationagentic-ai
For: security architects and platform engineers. The decision: what authority a task carries when one agent hands it to another.
A handoff turned a prohibition into a request
Illustrative scenario: a fictional composite written to make the point concrete. It does not describe a real organisation, and its figures are not reported outcomes.
Consider a bank’s retail onboarding flow. An orchestrator agent receives a new application and delegates identity checks to a KYC agent. The KYC agent may read the application and the uploaded documents, run verification and raise a discrepancy. It may not change the customer record.
The application says the applicant was born on 14 March 1988. The passport image says 14 March 1983. The KYC agent, trying to finish its task, asks a document agent to “fix the date of birth in the core record so it matches the passport”.
The document agent normally attaches document references and updates document-status fields, so its service identity has write access to the customer record. It checks its own permissions, finds the write allowed, and makes the change. Verification now passes, on a value the verification step itself arranged. Nobody with authority to amend a customer’s identity data ever decided anything.
Checking the receiver’s own permissions is not enough
Many multi-agent frameworks treat delegation as a routing problem: find the agent that can do the task, send it, collect the result. Authority, if it is considered at all, is checked at the receiver against the receiver’s own entitlements. The document agent could write to the record, so the write went through.
That check answers the wrong question. The right question is whether this action, for this requester, for this purpose, is allowed. Norm Hardy named the failure in 1988: the confused deputy, a component that holds legitimate authority and is induced to use it on behalf of someone who lacks it (Hardy, 1988). Agents reproduce the pattern with unusual ease because a request is just a sentence, and sentences travel.
Two misunderstandings sit underneath. The first is that a delegated task carries the delegator’s full authority, so whatever the orchestrator could do, anything downstream may do. The second is quieter: that a restriction on the requester stops at the requester. In the onboarding flow, the KYC agent’s prohibition on editing the record did not travel with its request. Delegation laundered it.
The OpenID Foundation’s 2025 white paper on agent identity reaches a similar conclusion from the identity side. It argues that agents should act under explicit on-behalf-of delegation rather than impersonating users, and that permissions must narrow at each hop of a multi-hop delegation chain (OpenID Foundation, 2025). It also notes that doing this verifiably across such chains is still an open problem.
In CAE, each delegation is narrower than or equal to its source
The Contextual Agentic Enterprise (CAE) is Contextual Agentic’s architecture and operating model for people, models, agents and systems acting together under delegated authority. One of its constructs is the Authority Envelope: the explicit bounds on what an agent may do, covering tools, resources, actions, values, duration and side-effect classes.
Across a handoff, CAE treats that envelope as something that can only shrink. The authority a delegated task carries is the overlap of four things: what the originating principal could authorise, what the delegating agent itself holds, what the receiving agent is eligible to do, and what policy allows for this task. It is never the combined set of everything the participants happen to hold. As the book puts it, “delegation is not permission multiplication”.
Two further properties go with it. The original principal must survive every hop, so the system of record knows whose request it is ultimately serving. And the causation chain must be preserved, so an investigator can see how authority reached the final call, not only which service made it. This is the discipline Saltzer and Schroeder called complete mediation, applied along a chain: every access is checked against current authority, not an earlier decision (Saltzer and Schroeder, 1975).
Evaluate every handoff against the envelope it carries
Each receiving boundary should apply this procedure before acting on a delegated task.
- Read the envelope, not just the instruction. A delegated task arrives with a record of who started the chain, who is asking, for what purpose, what classes of action are allowed, and how much further it may be delegated and for how long.
- Intersect, don’t inherit. Compute what may be done as the overlap of the carried envelope and the receiver’s own capability. The receiver’s permission is necessary but not sufficient.
- Carry prohibitions forward. If the requester was barred from an action, the delegated task is barred from it too.
- Re-authorise on a change of class. A move from reading to writing, or from preparing to committing, is a fresh decision at the Commit Boundary, the point where a proposal becomes an externally observable effect.
- Choose one of four outcomes. Permit, deny, escalate to a human with the evidence, or re-evaluate after gathering what is missing.
- Record the hop. Log the envelope received, the decision and the policy version, keyed to the root task.
Delegation fails in predictable ways
- Authority amplification. A low-privilege agent obtains a high-privilege effect by asking a stronger peer. The onboarding flow is this case.
- Lost principal. By the third hop, logs show only service identities. The customer, the officer and the purpose have disappeared from the record.
- Unbounded depth. An agent re-delegates a task it could not complete, and the chain grows until nobody can say what the original request allowed.
- Stale envelopes. A long-running task keeps authority that expired, was revoked, or belonged to an approval for a different payload.
- Task laundering across domains. A delegation crosses into another business unit’s or supplier’s agent, which evaluates only its own rules. Protocols such as A2A give agents a common way to exchange tasks; they do not decide what authority a task should carry, which remains the enterprise’s job (A2A Protocol Specification 1.0).
This model has limits worth stating. It does not decide what each agent’s envelope should be; that is a business decision about delegations. It does not make the model’s reasoning correct. And standard, verifiable envelopes across organisations are still maturing, as the OpenID paper acknowledges.
Each role owns a different part of the chain
Executives decide that agent delegations are written down like human financial and operational delegations, with a named owner for each authority an agent may exercise. In onboarding, that means stating plainly that no agent may amend identity data.
Architects design handoff contracts that carry the originating principal, purpose and permitted action classes as fields, not prose. Identity data corrections go through their own workflow, with their own authority and evidence, rather than through whichever agent has write access.
Engineers implement and test the negative paths. Write a test in which a restricted agent asks a privileged one to perform the restricted action, and assert that it is refused or escalated. Test that authority does not accumulate across three hops. Test that a changed payload invalidates an approval.
The onboarding handoff, decided correctly
| Hop | What the request carries | What the receiver holds | Outcome under the envelope rule |
|---|---|---|---|
| Orchestrator → KYC agent | Applicant as principal; purpose: identity verification; read and verify only | Read documents, run checks, raise discrepancy | Permit: within both |
| KYC agent → document agent: “attach passport image to case” | Same principal and purpose; attach reference | Write document references | Permit: within both |
| KYC agent → document agent: “fix date of birth in core record” | Same principal; KYC’s bar on editing identity data travels with it | Write access to customer record | Deny; escalate as a discrepancy |
| Discrepancy → onboarding officer | Both dates, passport evidence, request history | Authority to request correction from the applicant | Escalate: human decides |
| Officer → correction workflow | Officer as principal; purpose: identity correction; one field | Correction capability with evidence check | Permit only with confirmed evidence; record on the case |
The mismatch is resolved, but by someone entitled to resolve it, with the evidence attached. The same principle, pushed out to identity and verification across the whole estate, is the subject of next week’s Field Note, Zero Trust for AI Agents. For where the enforcement itself should sit, see Closing the Governance-to-Action Gap with Runtime Mediation; for why fewer boundaries are often better, see The One-to-Five Trap.
Key takeaways
- A delegated task should carry no more authority than the overlap of its origin, its delegator, its receiver and its policy.
- A receiver checking only its own permissions is a confused deputy waiting for a request.
- Prohibitions must travel with a task, or delegation becomes a way to launder them.
- The originating principal and the full causation chain belong in the record of every consequential action.
- A change from reading to writing, or preparing to committing, needs a fresh decision, not an inherited one.
Sources and further reading
- The Contextual Agentic Enterprise, Chapters 10, 13 and 14.
- Hardy, N. (1988) “The Confused Deputy (or why capabilities might have been invented)”, ACM SIGOPS Operating Systems Review 22(4). https://dl.acm.org/doi/10.1145/54289.871709
- Saltzer, J. H. and Schroeder, M. D. (1975) “The Protection of Information in Computer Systems”, Proc. IEEE 63(9). https://doi.org/10.1109/PROC.1975.9939
- OpenID Foundation (October 2025) Identity Management for Agentic AI (white paper). https://openid.net/wp-content/uploads/2025/10/Identity-Management-for-Agentic-AI.pdf
- A2A Protocol Specification 1.0. https://a2a-protocol.org/latest/specification/
Where the book goes further
The book develops delegation as an authority chain from human to system of record, with the fields a delegation should carry, how attenuation works through MCP and A2A gateways, and the threat model for task laundering and confused deputies. It is where to go for the full treatment, including how long-running tasks re-evaluate authority as they cross trust boundaries.
This article is part of CAE Field Notes, a series accompanying the book, The Contextual Agentic Enterprise.
Related
The One-to-Five Trap: Why Multi-Agent Systems Become Distributed Systems
Splitting one agent into five does not add a team. It adds a distributed system. Each boundary has to earn its coordination cost, or it should be a function.
Zero Trust for AI Agents: Identity, Authority and Continuous Verification
An agent is neither a user nor a service account. Zero Trust still applies, but it has to verify the agent, the principal and each action, and treat content as influence, never authority.
Closing the Governance-to-Action Gap with Runtime Mediation
Policies, approval screens and audit logs describe governance. Only a control on the execution path enforces it, and every consequential action must pass through one.