When a user asks an agent to do something and that agent calls a tool, a sub-agent and then an API, the final service usually sees only the last caller and a token that carries far more authority than the task needs. The original user, the purpose of the request and the narrowing that should have happened at each hop are lost, which is how confused deputy problems, over-broad data access and untraceable actions arise. Standards work is converging on a set of answers: OAuth 2.0 Token Exchange with actor claims, transaction tokens inside a trust domain, identity chaining across domains, and capability-style tokens that can only be narrowed as they are passed on. This guide explains how each mechanism represents a delegation chain, how attenuation works, what the current specifications actually say and how to design an agent call chain that narrows authority at every hop. It is for identity architects, agent platform engineers and security reviewers; it goes deeper than the OAuth Token Exchange and Delegation Guide and the AI Agent Authorisation Guide on the chain itself.
Specification status below was checked on the IETF Datatracker on 27 October 2026. Internet-Drafts change between versions; treat draft details as indicative and recheck before implementing.
Key takeaways
- Delegation is not impersonation. RFC 8693 distinguishes an actor that keeps its own identity while representing a subject from one that becomes indistinguishable from it; agent designs should use delegation.
- The act claim records the chain but only the current actor counts. RFC 8693 says prior actors in nested act claims are informational and must not be used in access control decisions.
- Attenuation must be enforced by the issuer or the token format. Either a token service downscopes at each exchange, or a capability token makes widening cryptographically impossible.
- Keep chains short and bound. Depth limits, short lifetimes and sender-constrained tokens stop a stolen intermediate token from being replayed or extended.
- Log the whole chain at every hop. A unique transaction identifier plus the subject and actor at each step is what makes an agent action attributable afterwards.
Why multi-hop agent calls lose authority context
A typical agent request crosses several boundaries: the user's client, an orchestrating agent, one or more tool servers (often via MCP), possibly another agent over A2A, and finally a resource API. Without a deliberate design, three things go wrong.
- Token forwarding: the orchestrator passes the user's access token on to tools. Every tool now holds a credential valid for every scope the user granted, at every audience that accepts it.
- Service identity substitution: the tool calls the API with its own broad service credential. The API sees a trusted service, not the user, and cannot apply the user's permissions. This is the confused deputy pattern described in the Confused Deputy in AI Agents Guide.
- Lost intent: even when identity survives, the purpose ("summarise this one document") does not, so a prompt-injected agent can use legitimate authority for a different task. See the AI Agent Goal Hijacking Guide.
The WIMSE architecture draft (draft-ietf-wimse-arch-08, Informational, 6 July 2026) names multi-hop delegation chains for AI agents as a specific risk and says each hop "MUST explicitly scope and re-bind the security context". That sentence is a good design rule regardless of which mechanism you choose.
Delegation versus impersonation in RFC 8693
OAuth 2.0 Token Exchange (RFC 8693) is the base mechanism most chains build on. A client presents a subject_token representing the party on whose behalf the request is made and, optionally, an actor_token representing the acting party, and receives a new token for a target audience.
| Semantics | RFC 8693 description | Resulting token | Use for agents |
|---|---|---|---|
| Impersonation | A is given B's rights and is indistinguishable from B in that context | Subject is B, no actor | Avoid: audit cannot tell the agent from the user |
| Delegation | A keeps its own identity and acts as an agent for B | Subject is B, act identifies A | Default for agents acting for users |
| Nested delegation | Outermost act is the current actor; nested act claims are prior actors, least recent most deeply nested | Subject is B, act chain C then A | Multi-hop agent chains |
| Pre-authorised actor | may_act states that a party is authorised to act for another | Input to the token service's decision | Restricting which agents may receive delegation from a token |
The access control rule matters: RFC 8693 states that a token consumer must only consider the top-level claims and the current actor, and that prior actors "are not to be considered in access control decisions". The chain is therefore an audit record, not a policy input, unless your token service evaluates it at exchange time. If a resource must refuse requests that passed through an untrusted agent, that decision has to be made by the token service when it issues the token, not by the resource reading nested act claims.
Vendor platforms implement the same idea. Microsoft's Entra Agent ID documentation describes user tokens requested by an agent where "the subject is the user, and the actor is the agent identity". See the Microsoft Entra Agent ID Guide.
Mechanisms for carrying and narrowing authority
Several specifications address different segments of the chain. They are complementary rather than competing.
| Mechanism | Status (checked 27 Oct 2026) | Segment of the chain | How it attenuates |
|---|---|---|---|
| OAuth 2.0 Token Exchange | RFC 8693 | Any hop with a token service | Token service issues a token with narrower scope and audience |
| Transaction Tokens | draft-ietf-oauth-transaction-tokens-11, OAuth WG, 30 July 2026 | Inside one trust domain, across internal workloads | scope set by the Transaction Token Service as narrowly as possible; immutable tctx |
| Identity and Authorization Chaining Across Domains | draft-ietf-oauth-identity-chaining-17, in the RFC Editor queue | Between trust domains with separate authorisation servers | Claims transcription allows downscoping and subject mapping |
| WIMSE architecture | draft-ietf-wimse-arch-08, Informational | Workload-to-workload context propagation | Each hop re-scopes and re-binds context |
| Attenuating Agent Tokens | draft-niyikiza-oauth-attenuating-agent-tokens-01, individual draft, not adopted | Agent-to-agent and agent-to-tool hand-offs without a round trip | Holder derives child tokens that can only be narrower; verified offline |
| Macaroons | Research paper, NDSS 2014 | Bearer credentials passed between services | Caveats appended with chained HMACs restrict when, where and for what |
Transaction tokens inside a trust domain
The transaction tokens draft defines short-lived signed JWTs that carry user or workload identity and authorisation context through a call chain within one trust domain. A single logical Transaction Token Service per domain issues them through token exchange. Key claims are txn (a unique transaction identifier for audit and replay detection), sub, scope (the purpose, set as narrowly as possible and not necessarily equal to what was requested), tctx (immutable transaction context), rctx (request context such as originating IP) and req_wl. Lifetimes are expected to be "on the order of minutes or less", and a token must not be accepted outside the trust domain named in aud. For an agent platform this means the external user token stops at the edge, and internal tools receive a narrow, short-lived token tied to one transaction. See the OAuth Transaction Tokens Guide.
Crossing domains
When an agent in one organisation must call an API protected by another organisation's authorisation server, the identity chaining draft combines token exchange in domain A (to obtain a JWT authorisation grant audienced to domain B's server) with the JWT bearer grant (RFC 7523) in domain B. Either server may add, remove or change claims, which is where downscoping and subject mapping happen. The draft advises that domain B should not issue refresh tokens for this flow and recommends short lifetimes, single use and sender constraint for the grant. See the OAuth Identity and Authorization Chaining Across Domains Guide and, for the enterprise-managed variant, Enterprise-Managed Authorisation for AI Agents.
Capability-style attenuation
Token exchange depends on a token service at every hop. Capability-style tokens let the holder narrow authority locally. Macaroons (Birgisson and others, NDSS 2014) append caveats under chained HMACs, so any holder can add restrictions but nobody can remove them; they are bearer credentials without proof of possession. The individual Attenuating Agent Tokens draft proposes signed JWTs (Ed25519) in which each derived token must name its parent's holder key as issuer, increment del_depth by exactly one without exceeding del_max_depth, expire no later than its parent, carry a subset of the parent's tools with argument constraints at least as strict, and commit to the parent through par_hash. The leaf holder signs a fresh proof-of-possession JWT for each tool call, and unknown constraint types fail closed. The draft has no IETF standing yet, but its invariants are a useful checklist for any attenuation design. See the Capability-Based Security Guide.
Designing an attenuating call chain
A practical design for most organisations uses a token service at the boundaries and narrow, bound tokens inside.
- Authenticate the user and the agent separately. The agent has its own workload or agent identity; the user's token is a subject token, never forwarded as-is to tools.
- Exchange at the first hop. The orchestrator exchanges the user token (subject) plus its own credential (actor) for a token audienced to one tool, with only the scopes that tool needs. Use resource indicators or the
audienceparameter so the token is valid at exactly one place. - Carry purpose, not just scope. Put structured task detail (the document ID, the amount limit, the recipient) in authorisation details or transaction context, so the resource can refuse anything outside it. See the OAuth Rich Authorization Requests (RAR) Guide.
- Re-exchange at every further hop with a smaller scope set, a shorter or equal lifetime and an incremented depth counter. The token service rejects requests that would widen scope or exceed the maximum depth.
- Sender-constrain every token with DPoP or mTLS so that a token copied out of a tool's memory cannot be replayed by another party. See the DPoP Guide.
- Use
may_actor token service policy to restrict which agents may receive delegation at all. - Stamp a transaction identifier at the edge and log it, with subject and full actor chain, at every hop.
Testing: before production, run negative tests at each hop: request a wider scope than the parent, a longer lifetime, an extra hop beyond the depth limit, a different audience, and replay of a captured token from another client. Each must fail. Roll back by reverting the token service policy version rather than by allowing token forwarding.
Choosing an approach
| Situation | Recommended approach | Trade-off |
|---|---|---|
| Single organisation, agents and tools in one platform | Token exchange at the edge, transaction tokens internally | Requires a central token service on the hot path |
| Agent calls a partner or SaaS API in another domain | Identity chaining (token exchange plus JWT bearer grant) | Needs trust between authorisation servers and claims mapping |
| Deep or dynamic agent-to-agent delegation, offline verification needed | Capability tokens with holder binding and depth limits | Formats are not yet standardised; interoperability is limited |
| Hosted agent platform with a credential vault | Platform-native user binding, for example AgentCore's JWT-based workload access tokens | Attenuation limited to what the platform exposes |
| Small team, one or two tools | Separate narrowly scoped tokens per tool and no forwarding; defer full chains | Less audit detail across hops |
Platform features interact with these choices. AWS documents that AgentCore's GetWorkloadAccessTokenForJWT binds a validated user iss and sub to the agent's workload identity, while the GetWorkloadAccessTokenForUserId variant trusts an unverified string and should be denied where not needed. A chain is only as strong as the weakest user binding inside it. See Cloud Agent Identity Services Compared.
Detection and measurement
What to log at every hop: transaction identifier, subject, current actor and full actor chain, audience, scopes or authorisation details, token lifetime, depth and the decision taken. With that data:
- Chain completeness: share of resource-side requests from agents that carry a subject and actor rather than only a service identity (target near 100% for user-initiated work).
- Forwarded tokens: count of requests where the presented token's audience does not match the receiving service, a sign of forwarding (target zero).
- Scope delta per hop: average reduction in scopes between the edge token and the leaf token; flat lines mean no attenuation is happening.
- Depth distribution: requests by delegation depth, with alerts on depth above the design maximum.
- Exchange denials: token service refusals for widening or depth violations, which are both a control working and a signal of misbehaving or compromised agents.
- Lifetime: median and maximum lifetime of tokens held by tools.
Relevant ATT&CK techniques for the threats these controls address are T1528 Steal Application Access Token and T1550.001 Application Access Token, both of which narrow, bound, short-lived tokens make far less useful. For runtime monitoring of agents generally, see the Agent Controls and Monitoring Guide.
Framework mapping
| Framework | Reference | Relevance to delegation chains |
|---|---|---|
| NIST SP 800-53 Rev. 5 | AC-6 Least Privilege | Attenuation at each hop |
| NIST SP 800-53 Rev. 5 | AC-16 Security and Privacy Attributes | Carrying subject, actor and purpose attributes with the request |
| NIST SP 800-53 Rev. 5 | IA-9 Service Identification and Authentication | Agents and tools authenticating as themselves, not as the user |
| NIST SP 800-53 Rev. 5 | AU-2 Event Logging, AU-12 Audit Record Generation | Transaction ID and actor chain in logs at every hop |
| NIST CSF 2.0 | PR.AA-05 | Authorisations defined and enforced with least privilege |
| CIS Controls v8.1 | Control 6 Access Control Management | Least privilege for service and agent access |
| ISO/IEC 27001:2022 Annex A | 5.15 Access control, 8.3 Information access restriction | Restricting each component to the information it needs |
| OWASP Top 10 for Agentic Applications | ASI03 Identity and Privilege Abuse | See the OWASP Agentic Top 10 ASI03 Guide |
Common failure patterns
- Forwarding the user's token to tools: every tool becomes able to act with the full user grant at every audience that accepts it.
- Making access decisions on nested act claims: RFC 8693 says prior actors are informational only; resources that trust them can be misled by any token service that writes them.
- Impersonation by default: exchanges that drop the actor make the agent invisible in audit, so a misbehaving agent's actions are attributed to the user.
- Attenuation in prompts, not tokens: telling an agent "only read this folder" while giving it a token for the whole drive. Prompt-level limits do not survive injection.
- Unbounded depth and lifetime: sub-agents that can re-delegate indefinitely with refresh tokens create long-lived authority nobody intended. The Salesloft Drift breach shows how stored, long-lived integration tokens are reused by whoever obtains them; short, bound, per-task tokens would have limited that reuse.
- Unverified user binding: trusting a caller-supplied user identifier (as with AgentCore's userId path) anywhere in the chain lets one user act as another.
Practitioner checklist
- Map each agent workflow hop by hop: who calls whom, with which token, at which audience.
- Ban forwarding of user tokens to tools; require exchange per audience.
- Configure the token service to refuse scope widening, longer lifetimes and depth beyond a set maximum.
- Emit delegation (subject plus act) rather than impersonation tokens for agents acting for users.
- Carry task-specific authorisation details, not just scope strings, for high-impact actions.
- Sender-constrain tokens with DPoP or mTLS and keep lifetimes in minutes for internal hops.
- Log transaction ID, subject, actor chain, audience, scope and depth at every hop and centralise the logs.
- Run negative tests for widening, extra hops, wrong audience and replay before each release.
- Track the transaction tokens, identity chaining and attenuation drafts and recheck status before adopting draft-only features.
Standards and references
- IETF: RFC 8693 OAuth 2.0 Token Exchange
- IETF: Transaction Tokens (draft-ietf-oauth-transaction-tokens)
- IETF: OAuth Identity and Authorization Chaining Across Domains (draft-ietf-oauth-identity-chaining)
- IETF: Workload Identity in a Multi System Environment (WIMSE) Architecture
- IETF Datatracker: Attenuating Agent Tokens (individual draft)
- Google Research: Macaroons: Cookies with Contextual Caveats for Decentralized Authorization in the Cloud
- Microsoft Learn: Microsoft Entra Agent ID authentication protocols
- AWS: Get workload access token
Related NHI Mgmt Group resources: OAuth Token Exchange and Delegation Guide · AI Agent Authorisation Guide · OAuth Transaction Tokens Guide · Multi-Agent and A2A Security Guide