ChangeGamer

Credential Propagation Across Agent Hops: Exchange, Audience and Depth

Part 6 of A2A in practice: agent-to-agent interoperability · 1,361 words · ~6 min read · published · updated · Markdown variant

How to carry authority through a chain of delegating agents: why forwarding a token fails, per-hop RFC 8693 exchange with act and may_act, RFC 8707 audience binding, a worked sequence and a failure walk-through.

In short

  • To propagate credentials across a multi-agent delegation chain, each agent should exchange the token it received for a new, narrower token aimed only at the next hop, using RFC 8693 token exchange, and never forward the token it was given.
  • Binding each hop token to the next service with the RFC 8707 resource parameter means a resource server that checks the aud claim rejects a token captured mid-chain when it is replayed against any other downstream service.
  • Depth caps and 5 to 15 minute token lifetimes are builder guidance from the ChangeGamer delegation-chains reference, not requirements of RFC 8693, so they must be enforced as policy in your own authorization server.
  • The nested act claim records who acted, but RFC 8693 does not verify it cryptographically, so a resource server should log the full chain for audit and not treat it as proof by itself.
  • The IETF actor-chain drafts that aim to make chains verifiable were still individual Internet-Drafts as of June 2026, so they are signals to watch and not specifications to build against.

Part of the The A2A Protocol in Practice: Agent Cards, Tasks, Auth and When You Need It guide.


Propagate credentials across a delegation chain by minting a new, narrower token at every hop instead of passing one token along. The agent delegation chains reference (updated 2 October 2026) states the contract. The A2A pillar names the mechanisms; this article adds what neither does, which is a worked sequence and a failure walk-through. Both are reasoning from the reference, labelled as such.

Why does forwarding a token fail?

Forwarding fails because a token keeps its original audience and authority at every hop, so whoever holds it can use it anywhere the issuer is trusted. The reference calls this the confused-deputy flaw replayed across hops: a token captured at hop two works against any other service that trusts the same authorization server.

Forwarding also destroys the record (reasoning). A token passed through unchanged says nothing about which agents handled it, so the resource server sees only the original authority. The agent identity reference (updated 17 July 2026) draws the underlying line: workload identity is what an agent is, delegated authority is permission to act for someone, and it names conflating them as the root cause of most agent auth mistakes. Forwarding one credential for both is that conflation (reasoning). Handing over a user's own token is also the anti-pattern described in the A2A authentication schemes article.

How does per-hop token exchange work?

Each hop presents the token it holds to the authorization server and receives a new token for the next hop. The mechanism is RFC 8693 (January 2020), with grant type urn:ietf:params:oauth:grant-type:token-exchange.

Two claims carry the delegation story, per the reference:

Claim Where Role
act In the issued token Names the party now acting; nests so each hop appends itself
may_act In the subject token The issuer pre-approves which party may act next

Audience comes from RFC 8707 (February 2020). The exchange request names the next service in the resource parameter, and the issued token's aud matches that service only. A token minted for service B should be refused by service C.

What does a worked hop-by-hop sequence look like? (reasoning)

The sequence below is an illustration built from the reference's mechanisms, not a transcript of any product. Take a user, an orchestrator agent, a research sub-agent and a tool API.

  1. Hop 0. The user authorizes the orchestrator. The authorization server issues token T0 with sub the user, aud the orchestrator, and a may_act naming the orchestrator, the party the issuer allows to act next.
  2. Hop 1. The orchestrator exchanges T0 with resource set to the sub-agent. Token T1 has aud the sub-agent, sub still the user, and act naming the orchestrator. In this illustration the issuer also puts a may_act naming the sub-agent on T1, so the same check can run at hop 2.
  3. Hop 2. The sub-agent exchanges T1 with resource set to the tool API. Token T2 has aud the tool API, sub the user, and act naming the sub-agent with the orchestrator nested inside.
  4. Resource server. The tool API accepts T2 only because its own identifier is in aud, then logs sub and the full nested act chain with the request.

At each exchange the authorization server can apply the policy the reference recommends: reject if may_act does not name the caller, reject if the chain would exceed the depth cap, and issue a lifetime of minutes. The scope on each new token should be the same or narrower, never wider; that narrowing is the point of the exchange.

How deep and how long should a chain live?

Cap depth and keep lifetimes short, but treat both as your own policy. The reference recommends deciding the maximum hop count in authorization-server configuration and rejecting exchanges that exceed it, and it gives 5 to 15 minutes per step to limit the damage if one token leaks. It states that no current RFC mandates either; this is builder guidance, not standard.

A practical reading, as inference: set the depth to the deepest chain your real workflows need and no further, because every extra hop is another place a token can be captured. A short lifetime also means a long-running task needs a fresh exchange at each step, so budget for exchange latency and failure.

Why must the resource server log the whole act chain?

The resource server should log the full act chain because the reference calls it the only audit artifact linking the original user delegation to every downstream agent action. Without it, an investigation can see that the tool API was called but not by whom on whose behalf.

Do not read more into the claim than the standard gives. RFC 8693 checks only the immediately preceding hop, and earlier actors in act are informational. The claim is a useful record, not proof that the history is untampered, so pair the log with the authorization server's own exchange records. The audit trails article covers keeping such records.

What happens when a hop is compromised? (reasoning)

A compromised hop is contained by audience, lifetime and exchange policy working together. Walk through the same chain with the sub-agent breached after it receives T1.

The walk-through shows why forwarding is worse: a single forwarded token would have no audience boundary and no cap.

Are there standards for verifiable actor chains?

Two drafts target the gap, and as of June 2026 both were individual Internet-Drafts with no working-group RFC standing, per the reference. Verify the current revision on the IETF Datatracker before building to either.

Draft State in the reference Adds
draft-mw-spice-actor-chain Rev -05, April 2026; resubmitted as draft-mw-oauth-actor-chain-00 Verified profiles with sender-constrained tokens and a signature over the chain, aimed at chain-splicing
draft-oauth-ai-agents-on-behalf-of-user Rev -02, August 2025 requested_actor and actor_token parameters on the authorization-code flow, for per-agent user consent

The reference advises tracking the OAuth working group draft, not the original SPICE-space document. As of June 2026 the reference calls such drafts directional signals, not stable specifications, so treat neither as a settled dependency and verify the current revision.

How does this map onto A2A? (inference)

A2A carries the authentication step; token exchange between hops is an OAuth practice you layer on top. The A2A reference describes security schemes declared on the Agent Card, and does not describe an exchange between hops, so treat everything here as inference.

In practice that suggests the following: a receiving agent reads the card's declared scheme, satisfies it with a token minted for that agent's audience, and then performs its own exchange before calling onward. The A2A pillar and the scheme-selection article cover the card side. For the single-hop OAuth foundations, see how AI agents prove identity and delegated authority, and for storage and rotation, credential hygiene for AI agents.

Does ChangeGamer run a delegation chain?

No cross-service delegation chain. As of 4 November 2026, the only first-hand artefacts are that ChangeGamer's six .claude/agents definitions are in-process delegation, with no network hop or token exchange, and that the BACKLOG entry of 16 September 2026 records a deliberate decision not to publish A2A discovery documents because the site speaks MCP. Everything above is reasoning from the reference, not operating experience.

Frequently asked questions

Why can an agent not just forward the user token to the next agent?
A forwarded token carries the user authority with its original audience and scope, so any agent or service that captures it can replay it elsewhere. That is the confused-deputy flaw repeated across hops. Each agent should instead obtain a fresh token for the next hop only.
What is the difference between the act and may_act claims?
The act claim records which party is currently acting for the token subject and can nest to show earlier actors, while may_act in the subject token names a party the issuer pre-approves to act. One describes the actors so far; the other authorizes the next one.
How many hops should a delegation chain allow?
No RFC fixes a number, so the cap is your own policy. The ChangeGamer delegation-chains reference recommends enforcing a maximum depth at the authorization server and rejecting exchanges that would exceed it. Pick the smallest depth your real workflows need.
Does A2A define how credentials move between agents?
The A2A reference in the ChangeGamer corpus describes security schemes declared on the Agent Card, not a token exchange between hops. Layering OAuth token exchange on top of A2A calls is therefore an inference from OAuth practice, not specified A2A behaviour.

#a2a #delegation #oauth #token-exchange #multi-agent #security #identity

Put this corpus inside your own agents

This guide is free and stays free. The reference corpus behind it — machine-readable contracts, verified primary sources, continuously refreshed — is the paid product: a €5 starter key unlocks every premium reference for one agent via API; a €25 corpus license delivers the full corpus as RAG / fine-tuning data with an explicit AI-use grant; the €150 enterprise license adds commercial redistribution rights.

Agents: this page as Markdown · JSON · offers at /api/pricing.json · payment methods at /api/payment.json · single-resource access via HTTP 402 (how that works)