Review · November 10, 2026
OAuth 2.0 Delegated Authorization Summary
The problem
An orchestrator agent holds an access token and wants to hand part of that access to a sub-agent. Today it has two options. It can share the token, which gives away everything. Or it can go back to the authorization server for a Token Exchange, which costs a round trip and tells the AS about every hop.
This draft adds a third option. The client mints a narrower token for the next client itself, offline, by signing it with the key its own token is bound to.
How it fits in
Agent delegation is active OAuth territory, so the topic fits the charter.
This is a large new mechanism, not a small extension. It defines a new token type, a new HTTP authentication scheme, a chain serialization, a chain validation algorithm, two request parameters, four metadata parameters and an extension to token revocation. It has 18 normative references, 9 of them OAuth RFCs.
It also changes a basic OAuth relationship. Clients become token issuers. The AS signs only the first token in the chain and never sees the rest. The resource server ends up trusting signatures from keys it has never heard of, on the basis that each key was named by the token before it.
The idea itself is well known. It's the macaroon and biscuit model, built from JWTs and DPoP.
The problem is that the draft doesn't acknowledge the competition. Its comparison appendix covers only Token Exchange, DPoP and RAR. The working group adopted Delegate SD-JWT in October, which solves holder-to-delegate delegation with key binding. Attenuating Authorization Tokens is an individual draft with the same offline, narrowing-only chain design, and it already has an independent implementation report and a test suite. Neither is mentioned.
What it actually defines
The flow has three steps.
The AS issues a root token. The client adds delegation=true to the authorization and token requests and sends a DPoP proof. The AS returns a JWT with token_type of DA. The token carries cnf.jkt for the client's key and a max_delegation_depth claim.
A client delegates. Client A builds a new JWT with narrower scope, authorization_details, aud or exp. It puts Client B's key thumbprint in cnf.jkt, puts its own public key in the jwk header, and signs with its own private key. It appends the result to the chain with a ~ separator. Client B can repeat this for Client C until the depth runs out.
A client calls the API. It sends Authorization: DA root~child~child and a DPoP proof signed by the last token's key. The proof's ath covers the whole chain.
The resource server checks the root signature against the AS's keys. Then it walks the chain. Each token must be signed by the key the previous token named, and each token must be no broader than the one before it.
Client-issued tokens are forbidden from carrying iss, sub, iat or jti. The only identity in the chain is the user in the root token. Every other party is a key thumbprint.
What changed in -04? Meiling Chen of China Mobile joined as an author. The section structure is identical to -03.
Significant interoperability concerns
The token format and the validation algorithm are specified tightly. Two resource servers would agree on whether a scope-only chain is valid. The gaps are around the edges, and some of them are large.
- Rich Authorization Requests can't actually be delegated. A child token may only keep
authorization_detailsif the type has published containment rules for delegation. No type has them. Until someone writes those specs, every child token is scope-only, and the fine-grained downscoping in the agent use case isn't available. - The resource server can't tell who is calling. It sees a user and a list of key thumbprints. It can't write a policy like "this agent may read but not deploy", and its audit log can't name the agent that made the request. The draft calls delegation "cryptographically attributable", but only to a key.
- Revocation is recorded and then goes nowhere. The draft extends Token Revocation to accept a chain. Resource servers validate offline, and distribution of revocation status is out of scope. A client gets a 200 from the revocation endpoint and the revoked chain keeps working at every API until it expires.
- A child token isn't tied to its parent. It's valid under any parent bound to the same key, and omitted claims inherit from whichever parent is in front of it. If a client gets a fresh root token on the same key, child tokens issued under the old root work again. That includes children of a root that was revoked. The draft calls this "an intentional property" and offers a SHOULD for one key per token.
- Low-S ECDSA signatures are mandatory. JOSE doesn't require this, and common libraries, including WebCrypto, don't produce it. A client using a stock JWT library will have roughly half of its ES256 child tokens rejected, with an error the draft tells the resource server to keep vague.
- No refresh tokens. The draft forbids them for this token type. When the root expires, every chain under it dies. For an authorization code grant, the user has to be sent through the flow again.
- Client-to-client is out of scope. How Client A learns Client B's key and how the chain gets delivered are left to the deployment. An orchestrator from one vendor and a sub-agent from another have no protocol to do the handoff.
- Scope plus
authorization_detailshas no defined meaning. The combination is left to "resource server policy", and the delegating client is required to know it before issuing a child. - No mandatory-to-implement algorithm. A client has to find the intersection of algorithms across every resource server in the audience, from metadata that is optional.
- Header size. Every hop adds a full JWT with an embedded JWK to the
Authorizationheader. A few hops will hit the 8 KB default limit on common proxies.
Mechanisms that could be removed
- The
DAscheme and token type. A single-token chain is a DPoP-bound JWT access token under a different name. Reusing theDPoPscheme with a chain-aware token would spare resource servers a second code path, and would remove the redefinition ofath. - The revocation section. It has no effect on resource servers without a distribution mechanism the draft doesn't define. It's also the reason for the low-S signature rule and the requirement that the AS implement every containment rule. It should move to a companion draft that also defines distribution.
- The
max_delegation_depthrequest parameter. The AS must grant the exact value or fail the request. AS policy can decide the depth, the way it decides token lifetime. delegated_authorization_max_depthmetadata. It describes a server ceiling that the draft itself says no client can rely on.delegation=trueon the token request. The AS has already bound it to the authorization code.- The range of 0 to 65535. The text repeats it eight times. No HTTP header will carry a chain that long.
- Operational sections on caching, logging and validation services. None of them affect what goes on the wire.
Writing quality
The prose is clean, correct IETF English. Normative language is used properly. Security, privacy and IANA sections are complete. This is a far more finished document than most individual drafts on agent delegation.
It's also much too long. At 62 pages, every rule appears at least three times: in the claim definition, in the issuing steps, and in the validation steps. Many appear a fourth time in Security Considerations. The depth rule is stated in sections 5.3.2, 7.5, 8.6 and 12.9. The same content fits in half the pages, and the repetition makes it harder to check that all the copies agree.
The examples are placeholders. There are no test vectors, for a format where the draft insists on byte-exact serialization. Appendix C is a table of expected rejections with no actual tokens.
A few template leftovers remain, like "the WG Working Group mailing list".
The design choices that matter most are asserted without justification. Why no parent binding? Why forbid iss and sub in child tokens instead of defining how to validate them? Why a new scheme instead of DPoP?
Background of the authors
I couldn't reach Datatracker from this session. The numbers below come from lookups in August and September 2026.
- Ruochen Li (Huawei) has no RFCs. This draft, one other active OAuth draft on subject key binding and one expired ACME draft.
- Haiguang Wang (Huawei) has no RFCs. Four expired drafts across ACME, EMU and TLS, and a seat on the 2026/2027 Nominating Committee.
- Chunchi Peter Liu (Huawei) has no RFCs and around 15 active drafts, four of them adopted. He is Secretary of the SATP working group. His recent work has shifted to agent identity and delegation across OAuth and WIMSE.
- Meiling Chen (China Mobile) is new on -04. She has 2 RFCs, both DOTS telemetry (RFC 9244, RFC 9387), with 17 active and 42 expired drafts across more than a dozen working groups. She leads a separate cluster of OAuth agent drafts, including use cases, revocation and RAR extensions.
- Tieyan Li (Huawei) has no RFCs. This draft, the subject key binding draft and one expired RATS draft.
This is a team that knows IETF process and is new to OAuth. Five revisions in under a year shows the draft is being actively developed. Adding Chen links it to the China Mobile agent drafts, which so far have assumed an AS-centric model that this draft deliberately avoids.
Questions worth raising
- How does this relate to Delegate SD-JWT, which the working group has already adopted for holder-to-delegate delegation?
- What does this offer over Attenuating Authorization Tokens, and could the two merge?
- Should a child token carry a hash of its parent, so that it can't be reattached to a different root?
- How does a resource server identify the delegate for policy and audit if child tokens can't carry any identity claims?
- Which
authorization_detailstype will be the first to define containment rules, and should this draft define one to prove the model works? - Can the chain be presented under the existing
DPoPscheme? - Should revocation be split out until there is a way for resource servers to learn about it?