Join our Newsletter — 33% off our NHI Course
Home› Guides› Delegation Chains and Attenuated Authority for AI Agents:…
Guide Agent Identity & Access

Delegation Chains and Attenuated Authority for AI Agents: Guide to Narrowing Access at Every Hop

PDF for newsletter subscribers · free to read online

← All guides
By NHI Mgmt Group, edited by Lalit Choda Updated 27 October 2026 14 min read
On this page

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.

SemanticsRFC 8693 descriptionResulting tokenUse for agents
ImpersonationA is given B's rights and is indistinguishable from B in that contextSubject is B, no actorAvoid: audit cannot tell the agent from the user
DelegationA keeps its own identity and acts as an agent for BSubject is B, act identifies ADefault for agents acting for users
Nested delegationOutermost act is the current actor; nested act claims are prior actors, least recent most deeply nestedSubject is B, act chain C then AMulti-hop agent chains
Pre-authorised actormay_act states that a party is authorised to act for anotherInput to the token service's decisionRestricting 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.

MechanismStatus (checked 27 Oct 2026)Segment of the chainHow it attenuates
OAuth 2.0 Token ExchangeRFC 8693Any hop with a token serviceToken service issues a token with narrower scope and audience
Transaction Tokensdraft-ietf-oauth-transaction-tokens-11, OAuth WG, 30 July 2026Inside one trust domain, across internal workloadsscope set by the Transaction Token Service as narrowly as possible; immutable tctx
Identity and Authorization Chaining Across Domainsdraft-ietf-oauth-identity-chaining-17, in the RFC Editor queueBetween trust domains with separate authorisation serversClaims transcription allows downscoping and subject mapping
WIMSE architecturedraft-ietf-wimse-arch-08, InformationalWorkload-to-workload context propagationEach hop re-scopes and re-binds context
Attenuating Agent Tokensdraft-niyikiza-oauth-attenuating-agent-tokens-01, individual draft, not adoptedAgent-to-agent and agent-to-tool hand-offs without a round tripHolder derives child tokens that can only be narrower; verified offline
MacaroonsResearch paper, NDSS 2014Bearer credentials passed between servicesCaveats 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.

  1. 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.
  2. 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 audience parameter so the token is valid at exactly one place.
  3. 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.
  4. 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.
  5. 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.
  6. Use may_act or token service policy to restrict which agents may receive delegation at all.
  7. 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

SituationRecommended approachTrade-off
Single organisation, agents and tools in one platformToken exchange at the edge, transaction tokens internallyRequires a central token service on the hot path
Agent calls a partner or SaaS API in another domainIdentity chaining (token exchange plus JWT bearer grant)Needs trust between authorisation servers and claims mapping
Deep or dynamic agent-to-agent delegation, offline verification neededCapability tokens with holder binding and depth limitsFormats are not yet standardised; interoperability is limited
Hosted agent platform with a credential vaultPlatform-native user binding, for example AgentCore's JWT-based workload access tokensAttenuation limited to what the platform exposes
Small team, one or two toolsSeparate narrowly scoped tokens per tool and no forwarding; defer full chainsLess 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

FrameworkReferenceRelevance to delegation chains
NIST SP 800-53 Rev. 5AC-6 Least PrivilegeAttenuation at each hop
NIST SP 800-53 Rev. 5AC-16 Security and Privacy AttributesCarrying subject, actor and purpose attributes with the request
NIST SP 800-53 Rev. 5IA-9 Service Identification and AuthenticationAgents and tools authenticating as themselves, not as the user
NIST SP 800-53 Rev. 5AU-2 Event Logging, AU-12 Audit Record GenerationTransaction ID and actor chain in logs at every hop
NIST CSF 2.0PR.AA-05Authorisations defined and enforced with least privilege
CIS Controls v8.1Control 6 Access Control ManagementLeast privilege for service and agent access
ISO/IEC 27001:2022 Annex A5.15 Access control, 8.3 Information access restrictionRestricting each component to the information it needs
OWASP Top 10 for Agentic ApplicationsASI03 Identity and Privilege AbuseSee 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

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

PDF for subscribers

Take this guide with you

Every section, table and checklist in one PDF, with links to the sources and related guides. Subscribe to our weekly NHI & AI Identity Journal and we’ll email you a download link.

Free weekly newsletter

Subscribe to the NHI & AI Identity Journal

The latest on NHI and Agentic AI security – articles, research, breaches, news and events every week.

Bonus 33% off our NHI Course when you subscribe.

NHIMG Editorial Note
Researched and written by the NHI Mgmt Group editorial team using AI tools, under the editorial direction of Lalit Choda. Facts are drawn from the sources listed on this page and checked by our automated quality process. Last updated 27 October 2026. Spotted an error? Use our contact page.
NHI Mgmt Group, the independent authority on Non-Human Identity, IAM and Agentic AI security. nhimg.org

PDF Downloads for Newsletter Subscribers

Get the guide

Enter your details and we’ll email you a download link.

The full guide is free to read online. The PDF is a thank you for subscribing.

Fill in all fields marked * and tick the PDF box to continue.