| Internet-Draft | Delegator-Bound Delegation Chains | November 2026 |
| Nandakumar & Jennings | Expires 20 May 2027 | [Page] |
Attenuated delegation chains let a verifier check, without contacting any server, that no hop of a chain of AI agents holds more authority than the root granted. They do not show that each hop was granted by the agent before it: a child token can be signed by any key the verifier accepts. This document defines an extension that requires each child token to be signed with the key that its parent token confirms, so that every hop provably granted the next, with no authorization server in the path. The extension also defines a per-chain pseudonym for the principal, a rule that rejects chains in which an agent appears twice, a rule that keeps a child's audience within its parent's, and a claim that binds a chain to the dialog or transaction it was issued for. The extension builds on an existing attenuated delegation token format and can be mapped to other chained-token formats.¶
This note is to be removed before publishing as an RFC.¶
Status information for this document may be found at https://datatracker.ietf.org/doc/draft-nandakumar-wimse-delegator-bound-chains/.¶
Discussion of this document takes place on the Workload Identity in Multi System Environments Working Group mailing list (mailto:wimse@ietf.org), which is archived at https://mailarchive.ietf.org/arch/browse/wimse/. Subscribe at https://www.ietf.org/mailman/listinfo/wimse/.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 20 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
When an agent delegates part of a task to another agent, which delegates further, the agent at the end of the chain receives a credential and has to decide whether to act on it. It needs to know that:¶
the authority comes, hop by hop, from a principal who granted it;¶
no hop widened that authority;¶
each hop was granted by the agent before it, not asserted by a third party; and¶
the chain does not loop.¶
Where the agents are in different organizations and delegate directly to each other, the receiver usually has to check this without an authorization server in the path (see [CROSS-ORG] and Section 4.4 of [UCREQ]).¶
Several designs address parts of this:¶
Delegation Tokens [DELEGATION-TOKENS] define attenuation precisely: a closed authorization detail with subsumption rules, a parent hash that prevents splicing, a principal that stays the same at every hop, and an offline verification algorithm. The verifier checks the root token against a trusted key and checks the signature of every other token, but the specification does not say which key must sign a child token. A chain therefore shows that each hop is no broader than its parent, not that the holder of the parent granted it.¶
Delegate SD-JWT [DELEGATE-SD-JWT] chains key-binding JWTs so that each hop is signed with the key the previous hop confirms. It defines no rule for comparing authority between hops.¶
The OAuth Actor Chain [ACTOR-CHAIN] records an actor proof signed by each new actor, accepted by an authorization server at every step.¶
The OAuth Actor Profile [ACTOR-PROFILE] makes nested act claims
the issuer's assertion of history and invites companion profiles
that carry independently verifiable evidence for each hop.¶
This document is one such companion profile: it gives each hop of a Delegation Token chain [DELEGATION-TOKENS] verifiable evidence that the hop before it granted it. It extends Delegation Tokens with five things:¶
Delegator binding (Section 3): each child token is signed with the key confirmed by its parent token, and names the parent's acting agent as its issuer.¶
Originator pseudonym (Section 4): the principal can be a per-chain pseudonym that only the root issuer can resolve.¶
Cycle detection (Section 5): a chain in which an acting agent appears twice is rejected.¶
Audience attenuation (Section 6): a child token's audience is limited to that of its parent.¶
Context binding (Section 7): a chain can name the dialog or transaction it was issued for.¶
Section 2 walks through a three-hop chain before the rules. Section 8 maps the same rules onto Delegate SD-JWT [DELEGATE-SD-JWT].¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
This document uses the terms Delegation Token, Delegation Chain, Principal, Acting Agent, Authority, and Verifier from [DELEGATION-TOKENS]. DT_0 is the root token and DT_i, for i > 0, is the child of DT_{i-1}.¶
A person asks a travel agent, agent-a, to book a trip. Agent-a
delegates the hotel booking to agent-b, which delegates the payment to
agent-c. Agent-c then pays at a payment service. Figure 1 shows
the three tokens of the chain and the claims of [DELEGATION-TOKENS]
that matter at each hop. The values are illustrative:
authorization_details is shown as a summary of its one
agent_delegation object, and par_hash as the token it hashes.¶
+---------------------------------------+
| DT_0 |
| iss: as.example |
| client_id: agent-a |
| cnf: key A ------------------+---+
| aud: hotel, pay | |
| authorization_details: | |
| book a trip, up to 2000 | |
+---------------------------------------+ |
| key A signs DT_1
+---------------------------------------+ |
| DT_1 | |
| iss: agent-a <--------------+---+
| client_id: agent-b |
| cnf: key B ------------------+---+
| aud: hotel, pay | |
| authorization_details: | |
| book a hotel, up to 900 | |
| par_hash: hash of DT_0 | |
+---------------------------------------+ |
| key B signs DT_2
+---------------------------------------+ |
| DT_2 | |
| iss: agent-b <--------------+---+
| client_id: agent-c |
| cnf: key C ------------------+---+
| aud: pay | |
| authorization_details: | |
| pay the hotel, up to 900 | |
| par_hash: hash of DT_1 | |
+---------------------------------------+ |
| agent-c proves key C
v
Payment service (verifier)
In every token: sub = pseudonym P, del_bind = delegator
What changes at each hop:¶
iss is the agent that issued the token, and the key that signs it
is the key the previous token confirms in cnf. DT_1 is signed with
key A because DT_0 names agent-a and confirms key A.¶
client_id and cnf name the next agent and its key.¶
authorization_details and aud can only narrow: the trip becomes
a hotel, then a payment for that hotel; aud drops hotel.¶
ctx names the dialog each token was issued for; each delegation
here is a new dialog.¶
What stays the same: sub, the per-chain pseudonym P of the person
(Section 4), and del_bind, which makes every hop follow these
rules (Section 3).¶
The payment service verifies DT_0 under the root issuer's key, then for each later token:¶
its signature, with the key the previous token confirms;¶
that its iss equals the previous token's client_id;¶
that its authorization_details and aud are within the previous
token's
(Section 6);¶
that sub, sub_kind, and del_bind are unchanged, and that no
client_id appears twice (Section 5); and¶
that its par_hash matches the previous token.¶
Finally, it checks that agent-c holds key C, the key DT_2 confirms. A chain that passes shows that the person's issuer granted agent-a, agent-a granted agent-b, and agent-b granted agent-c, each within the authority it held, with no server in the path after the root.¶
OPTIONAL in DT_0. When present with the value delegator, every
child in the chain MUST satisfy the rules of this section. A child
MUST carry del_bind with the same value as its parent. A verifier
MUST reject a chain in which a child omits or changes del_bind.
delegator is the only value this document defines; a verifier MUST
reject a chain whose del_bind has any other value.
Because the claim is in DT_0 and in every child, a delegator cannot
remove the requirement for later hops.¶
A delegator that issues DT_i in a delegator-bound chain:¶
MUST sign DT_i with the private key that corresponds to the cnf
claim [RFC7800] of DT_{i-1}, using an asymmetric digital signature
algorithm;¶
MUST set iss of DT_i to the client_id of DT_{i-1};¶
MUST include in the JWS protected header the public key used to sign
DT_i as a jwk header parameter [RFC7515] when the cnf of
DT_{i-1} carries only a thumbprint (jkt); and¶
follows every other rule of [DELEGATION-TOKENS], including attenuation, the parent hash, and the principal invariant.¶
Issuing a child therefore requires only the delegator's own key. No authorization server takes part.¶
A verifier of a delegator-bound chain performs the algorithm of Section 6 of [DELEGATION-TOKENS] and, as part of its step 1, the following for each DT_i with i > 0:¶
Determine the public key confirmed by DT_{i-1}: the jwk member of
its cnf; or, if its cnf has a jkt member, the jwk header
parameter of DT_i, whose JWK SHA-256 Thumbprint [RFC7638] MUST
equal that jkt. Deny if the cnf has neither member, or confirms
a symmetric key.¶
Verify the signature of DT_i with that key, under an asymmetric algorithm. Deny on failure.¶
Verify that iss of DT_i equals client_id of DT_{i-1}. Deny on
failure.¶
DT_0 is verified under a trusted root key, as in [DELEGATION-TOKENS].¶
For a delegator-bound chain that verifies, a verifier knows, in addition to what Section 6.1 of [DELEGATION-TOKENS] establishes, that each child was issued by the holder of the key that its parent confirmed, and therefore by the Acting Agent that the parent named. Only the root rests on a trust anchor; every later hop rests on the previous hop. This is the property that [UCREQ] asks for when it requires that the credential presented to an agent was issued by the agent that delegated to it, and the chain traces back to the original authorization.¶
The key that signs DT_i is also the key that DT_{i-1} binds for proof of possession (Section 7 of [DELEGATION-TOKENS]). A deployment that wants separate keys for signing children and for presenting tokens uses a separate delegation key and does not use this extension.¶
[DELEGATION-TOKENS] carries the Principal in sub, identical at
every hop. Every agent in the chain, and every enforcement point, then
learns the Principal's identifier. When that is not acceptable, the
issuer of DT_0 sets sub to a pseudonym and marks it:¶
OPTIONAL in DT_0; when present, it MUST be present with the same
value in every child, and a verifier MUST reject a chain in which a
child omits or changes it. The value pseudonym means that sub is
a pseudonym computed as below. The value identifier, or absence,
means that sub identifies the Principal directly.¶
The pseudonym is¶
sub = BASE64URL(HMAC-SHA-256(K, principal-id || 0x00 || jti_0))¶
where HMAC-SHA-256 is defined in [RFC2104] and [RFC6234], K is a
secret key held by the issuer of DT_0, principal-id is the UTF-8
encoding of the issuer's identifier for the Principal, jti_0 is the
UTF-8 encoding of the jti of DT_0, || is concatenation, and
BASE64URL is base64url encoding without padding. The
pseudonym differs for every chain, so chains for the same Principal
cannot be linked by sub, and the principal invariant of
[DELEGATION-TOKENS] still holds within a chain. The issuer of DT_0
can resolve the pseudonym, for example for audit or revocation.¶
An issuer MUST NOT place in sub an identifier that another issuer
directed to a specific audience, such as a pairwise subject
identifier, because the identifier would then reach parties it was not
directed to.¶
[DELEGATION-TOKENS] bounds the length of a chain with
del_max_depth. A bound limits the damage of a loop but does not
detect one. In a delegator-bound chain:¶
A delegator MUST NOT issue a child whose client_id equals the
client_id of any token already in the chain.¶
A verifier MUST deny a chain in which two tokens carry the same
client_id. An agent that receives a chain to act under is such a
verifier: it refuses a chain in which its own identifier appears as
the client_id of any token other than the last.¶
The rule detects cycles only among identifiers that are the same
string. An agent that uses a different client_id per chain can take
part in a cycle without detection; the depth bound then still applies.¶
[DELEGATION-TOKENS] requires aud in every token of a chain, but the
Enforcement Point checks it only in DT_n, and nothing relates the
audience of a child to that of its parent. A delegator could therefore
issue a child usable at a resource that its own grant did not name.¶
In a delegator-bound chain, the audience attenuates like the rest of the authority:¶
A delegator MUST NOT issue DT_i whose aud contains a value that is
not in the aud of DT_{i-1}.¶
A verifier MUST deny a chain in which the aud of any DT_i, i > 0,
contains a value that is not in the aud of DT_{i-1}.¶
With this rule, the audience check applied to DT_n also holds for every earlier token: a chain is usable only where every delegator in it allowed it to be used. Values are compared as strings, as Section 4.1.3 of [RFC7519] specifies. A chain that crosses a trust domain boundary through an authorization server is re-issued there with the audience that server sets, and this rule applies to the new chain from that point.¶
A chain is often issued for one dialog or transaction: an agent dialog
[DIALOG-BINDING] or a Transaction Token's txn [TXN-TOKENS]. Binding the chain to it lets a receiver
reject a chain presented in a different one.¶
OPTIONAL. A JSON object with members type, a string naming the
kind of context, and id, its identifier. A delegator MAY add ctx
to a child, or change it, because a child is often issued for a new
dialog that continues the parent's; the parent's ctx remains in the
chain for audit.¶
This document defines two values of type:¶
id is an agent dialog identifier, such as the dlg of
[DIALOG-BINDING] or the dialog identifier of another agent dialog
protocol.¶
id is the txn of a Transaction Token [TXN-TOKENS].¶
A receiver that knows the context in which a chain is presented, and
finds a different ctx in the last token, MUST reject the chain. A
receiver that does not know its context, or does not recognize the
type, ignores ctx.¶
Delegate SD-JWT [DELEGATE-SD-JWT] already signs each hop with the key confirmed by the previous hop, so it provides delegator binding by construction. To apply the remaining rules of this document, a deployment:¶
carries the authority of each hop as one agent_delegation
authorization detail of [DELEGATION-TOKENS] in the hop's
delegate_payload, and applies its subsumption rules between hops;¶
carries sub, sub_kind, client_id, aud, and ctx in each
delegate_payload, with the meaning defined here; and¶
applies Section 4, Section 5, Section 6, and Section 7 to those claims.¶
A verifier rejects a Delegate SD-JWT chain under this profile if any
hop's delegate_payload lacks these claims or fails these rules.¶
The OAuth Actor Profile [ACTOR-PROFILE] defines act as the
issuer's assertion: inner actors are history, not inputs to access
control. A delegator-bound chain is evidence that each hop made: it can
accompany an access token whose act describes the same chain, in its
own claims, as that profile's companion-profile provision allows.¶
The OAuth Actor Chain [ACTOR-CHAIN] records a proof by each new actor and an authorization server's acceptance at every step. A delegator-bound chain records the grant by each delegator and needs no server after the root. The two answer different questions, which actor took part and who granted whom, and can be combined.¶
Identity chaining [ID-CHAINING] and cross-domain Transaction Tokens [TXN-CHAINING] remain the right choice where every domain boundary has an authorization server. This extension is for agents that delegate directly to each other.¶
An agent dialog protocol can use delegator-bound chains for dialogs
that cross administrative domains without an authorization server,
with ctx of type dialog naming the parent dialog.¶
An earlier proposal by the authors defined a separate delegation assertion format with similar properties. This document replaces it by extending [DELEGATION-TOKENS], so that attenuation is defined once.¶
An attacker who obtains the key confirmed by DT_i can issue children within DT_i's authority. Delegator binding does not change this, which holds for any proof-of-possession token; it does attribute such children to DT_i's acting agent. Short lifetimes and status lists [STATUS-LIST] limit the exposure.¶
Delegator binding moves trust from every hop to the root. How the verifier obtains and trusts the root key is outside this document, as it is for [DELEGATION-TOKENS].¶
Anyone who holds K can link pseudonyms to Principals. The issuer of DT_0 MUST protect K as it protects its signing keys and SHOULD rotate it.¶
Without Section 6, any delegator in a chain could make it usable at resources the principal never named; the audience check of DT_n alone would not detect this.¶
Revoking DT_i invalidates every chain through it. A verifier SHOULD
deny a chain when it cannot obtain current status for a token that
carries a status claim within its configured staleness bound.¶
A delegation chain discloses the client_id of every hop to each later
hop and to the enforcement point. When agents in one organization must
not be visible to another, the delegator at the boundary can obtain a
new root from an authorization server, ending the chain, as
[TXN-CHAINING] does. Within a chain, per-chain client_id values
reduce linkability at the cost of cycle detection (Section 5). The
originator pseudonym (Section 4) prevents the Principal from being
linked across chains.¶
This document registers the following claims in the "JSON Web Token Claims" registry.¶
Claim Name: del_bind¶
Claim Description: Delegation binding mode of a delegation chain¶
Change Controller: IETF¶
Claim Name: sub_kind¶
Claim Description: Whether sub is an identifier or a per-chain
pseudonym¶
Change Controller: IETF¶
Claim Name: ctx¶
Claim Description: Dialog or transaction a delegation was issued for¶
Change Controller: IETF¶
This document extends the Delegation Token design of [DELEGATION-TOKENS] and draws on the requirements of [CROSS-ORG].¶