Review · September 9, 2026
Identity Continuation Assertion for OAuth 2.0 Token Exchange
Problem Statement
A workload receives an access token and needs to call the next service for the user, possibly after the user is gone. It holds nothing the next authorization server will accept. When subjects are pairwise, it can't even name the user at that audience, because only the IdP holds that mapping.
So every cross-boundary hop has to go back to the IdP for a fresh grant. The question this draft answers is what the workload presents to get one. The IdP needs evidence that the previous hop actually landed, and the workload has no credential that carries that evidence.
The answer is a new short-lived JWT. A Continuation Assertion Issuer (CAI) attests three things: the resource authorization server (RAS) accepted the earlier ID-JAG, the authorization it created is still active and eligible for continuation, and the authenticated workload is associated with that authorization. The workload presents that as the subject_token of a Token Exchange at the IdP. The assertion carries no user subject and no authority of its own.
How the Spec Fits In
This is an extension of ID-JAG, which is already a WG document, and it complements OAuth Identity Chaining. Both are in charter, so the topic fits.
The dependency surface is large. Published RFCs: Token Exchange, DPoP, JWT, JWK Thumbprint, PoP Key Semantics, AS Metadata, JWT BCP, RAR, Resource Indicators, Introspection, OAuth core. In-progress drafts as normative references: ID-JAG (-04), Transaction Tokens, and draft-parecki-oauth-jwt-dpop-grant.
That last one matters. Every onward ID-JAG carries cnf, so it MUST be redeemed with the jwt-dpop grant type. That draft is an individual submission at -01. It's on the critical path for this profile and should get adopted before this can advance.
New things this spec adds:
urn:ietf:params:oauth:token-type:identity-continuationtoken type andapplication/oauth-identity-continuation+jwtmedia typeidentity_continuation_handleJWT claim, which the IdP places in ID-JAGs- A new role, the Continuation Assertion Issuer, plus IdP-held chain and hop state
urn:ietf:params:oauth:grant-profile:id-jag-continuationfor continuation-aware RASesinvalid_continuationerror,identity_continuation_supportedmetadata,identity_continuation_authorization_serverresponse parameter, and the handle as an introspection response member
Seven IANA registrations. This changes ID-JAG behavior on both ends: the IdP adds a claim, and a continuation-aware RAS binds it and must issue DPoP-bound tokens rather than bearer tokens.
High-Level Summary
Six steps, using the draft's own example. An agent app calls a tool gateway for Alice, and the gateway calls a wiki API for her.
- The agent app exchanges Alice's ID Token at the IdP for an ID-JAG for the gateway's RAS. New: the IdP records this as the root hop and puts its handle in the ID-JAG.
- The agent app redeems the ID-JAG at the gateway's RAS for an access token. New: the RAS binds the handle to the authorization it creates. A RAS that doesn't implement this profile just ignores the claim, and the chain ends there.
- The agent app calls the gateway with that access token.
- New: the gateway exchanges that access token at its RAS's token endpoint for a Continuation Assertion. Here the RAS is also acting as CAI.
- New: the gateway presents the assertion to the IdP with its own client credential and a DPoP proof. The IdP checks the request against what it recorded at step 1 plus current policy, resolves Alice's subject for the wiki, and issues a child ID-JAG.
- The gateway redeems that ID-JAG at the wiki's RAS. Standard ID-JAG, plus the DPoP-bound grant type.
The relationships that matter for a leadership audience:
The IdP is the only party that can name the user at the next audience, and it's the only party that holds the chain. At the root exchange it records a chain authorization: the user, the tenant, the root client, the authentication context, the lifecycle anchor, and restrictions on who may continue and to what. Those facts are fixed for the life of the chain. Later policy can narrow access but never widen past that recording.
The RAS is the party that knows whether the previous hop actually worked. Acceptance is not carried on the wire anywhere. The IdP learns it only from a CAI's signed attestation, which is why the CAI role exists at all.
RAS acceptance does not bound downstream authority. The spec is explicit about this: incoming access-token scopes do not limit what the workload can get at the next target. The chain authorization and current IdP policy are the only bound.
Chains are anchored to something revocable: an ID Token sid, a SAML SessionIndex, or optionally a refresh token's grant for chains that outlive logout. Kill the anchor and no further continuation happens. Already-issued ID-JAGs stay redeemable for their short lifetime, which the draft calls out plainly.
What Changed Since -00
The -00 review here asked whether the Chain Authority needed to be a separate role. That's now answered: it's renamed to CAI, co-located with the RAS is the baseline topology, and Section 9.5 admits that separating it "creates no protocol-level quorum." Good resolution.
Other substantive changes: the fixed root envelope became the chain authorization; actor_token processing is gone, so client authentication alone determines the actor; assertion issuance is now a defined Token Exchange at the CAI rather than deployment-specific; the root exchange no longer requires proof of possession; grant anchors are optional; and idempotent retry is new.
Interoperability
Two of the three wire surfaces are tight. The assertion format is genuinely well constrained: compact JWS only, no JWE, no nested signing, exactly one cnf method, an explicit list of forbidden claims, and seven ordered validation rules at the IdP with defined error precedence. Both exchanges have concrete request and response formats. An implementer can build the IdP side and the workload side from this document.
The third surface is where the gaps are.
"Eligible for continuation" has no interoperable meaning. Fact 5 of Section 5.4.3 is evidence "authoritative by the RAS's own authorization semantics." Two RASes can mean entirely different things by eligibility and the IdP can't tell the difference. This stays inside one domain so it doesn't break the protocol, but it's the hinge the whole design turns on, and it's undefined. Worth deciding deliberately rather than by omission.
A separate CAI has no discovery. The draft presents two first-class topologies in Table 3, but for the separate case, how a workload finds the CAI's token endpoint is left entirely to the deployment. It's issue #109 in the tracker. Co-located gets discovery through RAS metadata; separate gets nothing.
Idempotent retry is optional and undetectable. Section 5.5.7.1 defines a seven-field request fingerprint and a RESERVED/ISSUED/FAILED state machine, and then deliberately makes all three failure modes return the same invalid_request so a client can't distinguish them. There's no metadata flag and the retry window is a deployment choice. A client's only interoperable strategy is to obtain a fresh assertion. That's roughly 80 lines of normative text plus error-code prose for behavior no client can detect or act on differently.
Limits aren't advertised. A finite hop-count limit is required, with no default. Fan-out, rate, and actor-lineage depth are optional tenant controls. None appear in metadata. A workload can't predict when a continuation will come back invalid_grant. Appendix C already asks this question.
Tenant is normative but undefined. Issuer trust is scoped per tenant, and identities in different tenants never compare equal, but there's no tenant claim and determination is deployment-defined. Everything depending on it lives in one IdP's configuration, so nothing breaks, but a meaningful chunk of the security model can't be tested across implementations.
Mechanisms That Could Be Removed
Idempotent retry (Section 5.5.7.1). Best candidate by a wide margin. Keep the single-use (iss, jti) reservation, which is a real replay control. Drop the recovery state machine, or move it to Implementation Considerations as guidance.
identity_continuation_authorization_server. The spec already says a client SHOULD only present an assertion to an IdP it's configured to trust. If it's configured, it knows the issuer identifier. This parameter saves the client from decoding a JWT it holds. That's convenience, not interoperability.
Transaction Token as a subject_token type at the CAI. The CAI and the workload are in the same trust domain, so the carrier choice never crosses an interop boundary. Defining txn_token normatively here pulls in another WG draft dependency for something the deployment picks anyway. Section 8.1 already lists three carrier options as non-normative guidance, and this could join them.
The introspection response member. Section 5.3 constrains the handle to stay within the issuing server's trust domain. An intra-domain introspection member doesn't need an IANA registration.
Section 5.4.6 (Separate CAI). Follows from the topology question above. If the security benefit is component isolation rather than a trust quorum, the base spec could define one topology and leave separation to a deployment profile.
Writing Quality
Strong. Correct and consistent 2119 usage, standard IETF structure, careful cross-referencing, precise sentences. The seven named validation rules are a good structural idea: other sections refer to "the issuer-trust rule" or "the well-formedness rule" instead of restating conditions. The author also writes with unusual care about what a reader can skip, for example telling readers who only implement session anchors to skip the grant-anchor processing.
The cost of that referencing is that almost no section reads standalone. Sentences routinely carry three conditions and two cross-references. Getting through Section 5.5 requires holding the rule names, the fact numbers from 5.4.3, and the hop states in your head simultaneously. The document is precise and hard to read at the same time.
84 pages, of which roughly 28 are Appendix B examples. The three examples are good, but B.2 and B.3 largely rerun B.1 with different names, and each ends with a "What differs from" section, which reads like the author knowing they repeat. One of them could go.
The core normative content, Sections 3 through 7, is about 32 pages. That's not padded. The mechanism genuinely has this many moving parts, which is itself the thing to weigh.
Author Background
Karl McGuinness ([email protected]), Independent
- 0 published RFCs
- 16 active Internet-Drafts. Not a new participant, and very actively writing.
- Editor on
draft-ietf-oauth-identity-assertion-authz-grant, the adopted WG document this profile extends.
Aaron Parecki ([email protected]), Okta
- 2 published RFCs: RFC 9728 (Protected Resource Metadata) and RFC 10017 (OAuth 2.0 for Browser-Based Applications)
- 16 active Internet-Drafts, SCIM WG chair, co-author on both ID-JAG and Identity Chaining
- Added as an author in this revision
Assessment
The direction is sound and the problem is real. Agentic and gateway deployments hit this exact wall: a workload holding an access token, a next service that won't take it, and pairwise subjects that only the IdP can resolve. The design is honest about its own limits, including the parts that don't work well.
Questions worth raising:
Where does "eligible for continuation" belong? It's the crux of the design and it's entirely RAS-local with no interoperable definition. Is that the right place for it, or does the IdP need a defined signal?
Root bearer tokens. Section 9.1 admits that a captured root bearer token lets an attacker induce an honest workload to continue to any target the chain authorization permits, not just the resource the token was for. -02 removed the root PoP requirement to keep existing clients working. That's a deliberate deployability trade. The WG should decide whether chain establishment ought to require a sender-constrained root.
Should the handle claim live in ID-JAG instead?
identity_continuation_handleis a claim in an ID-JAG, and continuation-aware RAS behavior changes how ID-JAGs are processed and redeemed. Two documents now jointly define ID-JAG processing. Splitting it is defensible given where ID-JAG is in the process, but it's worth naming.Dependency ordering. Four in-progress drafts as normative references, one of them not adopted and on the critical path.
jwt-dpop-grantneeds to move first.Is there a smaller base profile? Cutting idempotent retry, the separate-CAI topology, and the Transaction Token subject type would take out most of what a first implementer has to read without touching the core mechanism.