Review · November 10, 2026
Attenuating Authorization Tokens for Agentic Delegation Chains Summary
The problem
An orchestrator agent holds a token that covers a whole workflow. Each sub-agent only needs a small piece of it. If the sub-agent gets the full token, a prompt injection or a hallucinated tool call can use all of it.
This draft lets the token holder mint a narrower token for the next agent itself, offline. The narrowing is specific to agents: which tools can be called, and which argument values are allowed. The resource server verifies the whole chain without calling the authorization server.
How it fits in
Agent delegation is active OAuth territory, so the topic fits the charter.
This is a large new mechanism. It defines a new JWT token type, its own proof-of-possession JWT, a constraint language with nine types, a subsumption algorithm, a 50-step verification algorithm, a presentation object, a new token_type, two media types and a new IANA registry.
Its ties to OAuth are thinner than the title suggests. Of 21 normative references, three are OAuth RFCs: RFC 6749, AS Metadata and Rich Authorization Requests. The AS is involved once, to issue the root token. Everything after that is a capability system built from JOSE.
It also changes a basic OAuth relationship. Clients become token issuers. The resource server trusts signatures from keys it has never seen, because the previous token in the chain named them.
The field is crowded. The working group has adopted Delegate SD-JWT, which this draft doesn't mention. OAuth 2.0 Delegated Authorization has the same offline chain design using scopes and DPoP. The WIMSE Agent Delegation Chain draft reuses this draft's claim names with different semantics for del_max_depth.
What sets this one apart? It's the only one that defines containment rules for a RAR type, which is the piece the Delegated Authorization draft is missing.
What it actually defines
The AS issues a root token. The agent sends a token request with authorization_details of type attenuating_agent_token and a req_cnf parameter carrying its public key. The AS returns a JWT with token_type of aat. The token lists tools, a constraint per argument, the holder key in cnf.jwk, and a del_max_depth.
A holder derives a child. It builds a new JWT with fewer tools, tighter constraints, an earlier exp or a lower depth limit. It names the next agent's key in cnf.jwk, sets iss to its own key thumbprint, adds a hash of the parent in par_hash, and signs with its own key.
The leaf holder invokes a tool. It sends the full chain plus a PoP JWT signed with the leaf key. The PoP JWT contains the tool name and the exact arguments of the call.
The enforcement point verifies. The root must be signed by a configured trust anchor. Each child must be signed by its parent's key and be no broader than its parent. The arguments must satisfy the leaf's constraints and match the PoP JWT.
There is no sub claim. No token in the chain identifies a user. Every party after the AS is a key thumbprint.
Constraints are typed: exact, range, one_of, not_one_of, contains, subset, wildcard, all and any. Each pair of types has a fixed rule for whether one narrows the other. Anything else needs a registered extension type.
Significant interoperability concerns
The token format and verification algorithm are specified tightly, and there are published test vectors. An independent implementation report matched all 229 vectors from the text alone. The gaps are everywhere around that core.
- There is no way to send it. The draft defines what a presentation contains and leaves the wire format to future "bindings" for MCP, A2A or HTTP. The token type registers no HTTP authentication scheme. Two conforming implementations can't exchange a single request today.
- The user is missing. How a user's consent ends up in a root token is out of scope, and the only example uses
client_credentials. A tool server that receivesread_filewith an allowed path has no claim telling it whose files those are. - Getting a root token isn't portable. The AS MUST verify the agent holds the
req_cnfkey, and the mechanism is "deployment-specific".req_cnfcomes from the ACE working group's RFC 9201. DPoP already solves this at the token endpoint and isn't used. - The AS has to understand every tool. It must check each requested tool and constraint against the agent's entitlements. Tool identifiers and argument names are exact strings agreed out of band. Nothing ties them to an MCP server's tool list or schema.
- The core constraints can't express a path prefix or a hostname. There is no string pattern type. "Any file under
/data/" or "any URL onapi.example.com" requires an extension type, and an enforcement point that doesn't implement an extension must reject the chain. Real deployments will need extensions on day one. - Stock JSON parsers aren't good enough. Verifiers must reject duplicate member names and numbers that lose precision as doubles, checked "as written".
JSON.parsedoes neither.EdDSAis banned in favor of the newerEd25519algorithm name, which many JOSE libraries don't emit yet. - Replay protection is a menu. Chain
aud, PoPaat_audand a server nonce are all optional, and the enforcement point may require any of them. There is no metadata for a holder to learn which. Nonce delivery is out of scope. - Trust anchors are configured by hand. Root keys aren't discovered through AS metadata, and rotation is out of scope.
- No revocation. The draft suggests short lifetimes and a status list on the root. A compromised sub-agent key works until expiry.
- The implementations already disagree. The author's production engine uses CBOR with its own envelope, and its JWS support for -02 is "in progress". The two independent implementations target -01, which -02 breaks. The Mission-Bound Authorization implementation swaps in
cnf.jktand DPoP. - Size. Every call carries the whole chain at 1 to 4 KB per token, plus a PoP JWT that repeats every argument. A tool call with a large argument is sent twice.
Mechanisms that could be removed
- The custom PoP JWT. It duplicates DPoP's job with different claim names. One listed implementation already uses DPoP instead. A DPoP extension that binds tool and arguments would reuse deployed code and settle the
cnf.jwkversuscnf.jktsplit. all,any,not_one_ofandcontains. The composites bring recursion, depth limits and matching rules that reject valid narrowings. A first version withexact,one_of,rangeandsubsetcovers the examples in the draft.- Two of the three replay mechanisms. Pick one and make it required.
aat_id.aat_hashalready binds the proof to the leaf token.del_depth. It always equals the token's position in the chain, and the algorithm checks that it does.- The background material. The lattice model, the Macaroons, SPKI, Biscuit and UCAN comparisons, the policy language appendix and the CBOR appendix are all non-normative.
Writing quality
The writing is good. It uses IETF conventions correctly, the normative language is precise, and the threat model has an honest "Threats Not Mitigated" section. The author responded to list review from Neil Madden with real changes.
The problem is length. It's 73 pages. The same rules appear in the claim descriptions, the invariants, the derivation steps and the verification algorithm. A reviewer has to check four places to confirm they agree.
A lot of the text is defensive JWT hygiene: header key sources, crit handling, parse-after-verify ordering, duplicate keys. It's correct, but it's general JOSE guidance that belongs in a reference to RFC 8725.
-02 is a near rewrite that breaks -01 implementations. That's fine for an individual draft, but it shows the design is still moving.
Background of the author
Niki Aimable Niyikiza of Tenuo is the sole author. Tenuo is the product that implements this model, so this is a vendor bringing its design to the IETF.
I couldn't reach Datatracker during this review, so RFC and active draft counts are unverified. This is the only draft with this author in the OAuth and WIMSE collections tracked here, which points to a new IETF author focused on one document.
The draft has more traction than most individual submissions. Four other individual drafts cite or profile it, and it has an independent implementation report.
So what should the working group do with it?
The containment rules for tool arguments are the valuable part. No other draft in this space has them, and the Delegated Authorization draft needs exactly this to make RAR delegation work.
The chain format, the proof of possession and the transport are where it overlaps with adopted and competing work. A smaller draft that defines the attenuating_agent_token RAR type and its narrowing rules, and leaves the chain to whichever delegation format the working group settles on, would be much easier to adopt.