Review · October 13, 2026
Transactional Access Tokens Bring Txn-Token Context to the Front Door
The problem it's solving
Transaction Tokens solve the inside of the house. An API gateway receives an external access token, swaps it at a Transaction Token Service for a short-lived txntoken+jwt, and every internal workload in the call chain gets the same signed transaction ID and context. The Txn-Token never leaves the trust domain.
So what does the API gateway actually have to work with when it calls the TTS?
An access token with a scope. Maybe some RAR. Plus whatever request parameters the gateway decides to pass along in request_details. The authorization server that actually made the decision to let this client in has no way to say "this token is for this one task, and here's the context I evaluated."
That's the gap this draft targets. A Transactional Access Token (Txn-AT) is an RFC 9068 JWT access token that also carries Txn-Token claims: a txn identifier, AS-asserted tctx and rctx, a lifetime capped around five minutes, and exactly one audience. The resource server can trade it for a real Txn-Token at its own TTS and carry the AS's context into its internal call chain.
The motivating use case is AI agents. Consent and the refresh token stay durable. Every task gets its own token, and the AS makes a fresh policy decision for each one.
Does this duplicate Transaction Tokens?
No. The two are carefully kept apart, and the comparison table in Appendix A is accurate.
A Txn-Token is issued by a TTS, audienced to a trust domain, and explicitly not an access token. Section 13.13 of the Txn-Tokens draft says a workload MUST NOT use one as an OAuth access token. A Txn-AT is issued by the AS at the token endpoint, audienced to a single resource server, and is an access token. The draft adds a different typ and has both sides reject each other's tokens.
The interesting tension is that Section 13.13 of Txn-Tokens also calls the separation of transaction context from access tokens "a deliberate design choice," one that "reduces the need for including transaction context in the access token." This draft puts transaction context back into the access token. Atul Tulshibagwale is the lead editor on both documents, so this isn't someone misreading Txn-Tokens. It's the same author deciding the boundary needs a bridge. The draft should say so directly, because that's the first question the working group will ask.
How it fits in the working group
It's a profile of RFC 9068 that borrows claims from an adopted draft. Squarely in charter.
The dependency list is long but nothing exotic: RFC 6749, RFC 9068, RFC 8693 Token Exchange, RFC 8707 Resource Indicators, RFC 8417 for the txn claim definition, RFC 8414 and RFC 7591 for metadata, and Txn-Tokens as a normative dependency. RAR, DPoP, and mTLS show up informatively.
It also establishes one new relationship. Today the AS and a resource server's TTS have no defined connection. Section 6 makes the Txn-AT a defined subject_token_type for a Txn-Token request, so the TTS can take AS-asserted tctx as input instead of relying on the gateway.
How it relates to the Txn-Token chaining profile
draft-fletcher-oauth-txn-token-chaining-profile covers the other direction. A workload in trust domain A holding a Txn-Token needs to call a partner. It exchanges the Txn-Token at AS-A for a JWT authorization grant using identity chaining, presents that to AS-B, and gets an access token for the partner's API. That's context leaving a trust domain.
This draft is context entering one. Pieter Kasselman is on both, as an author of the chaining profile and a contributor here.
The two fit together naturally. In the chaining profile, the access token AS-B issues at the end is an ordinary access token, so AS-B's resource server loses the transcribed transaction context at its own front door. If AS-B issued a Txn-AT instead, the context would survive the whole path: Txn-Token in domain A, JWT grant across the boundary, Txn-AT into domain B's resource server, Txn-Token inside domain B. Neither draft mentions the other. They should, and the working group should probably look at them as a set.
What the mechanism actually does
The client requests a Txn-AT at the token endpoint with requested_token_type=urn:ietf:params:oauth:token-type:txn_access_token and exactly one resource. Three grants are allowed: Token Exchange, refresh token, and client credentials. The authorization code grant is explicitly excluded, on the reasoning that you can't ask the user to consent per task. Get a refresh token once, then request Txn-ATs with it.
The AS MUST evaluate policy on every request and can return a new transaction_denied error even when the grant itself is valid.
On a new transaction, the response includes a txn_handle. The client presents the handle on later requests to get more Txn-ATs for other resource servers in the same transaction. The handle is bound to the client and the subject, never sent to resource servers, and lets the AS enforce transaction-level rules like "this task may touch at most these three APIs" or "no more than ten tokens."
The txn value is pairwise per audience. Two resource servers in the same transaction see different txn values and can't correlate them. Only the AS can. Section 7.6 gives an HMAC construction for deriving them without storage.
Resource servers validate as RFC 9068 with a few additions: typ MUST be txnat+jwt, aud MUST be a single string, txn MUST be present.
Where it fills a real gap
The cross-boundary context story is genuine. Today the AS that decided a client could summarize Q3 invoices has no standard way to hand that decision to the resource server's internal workloads. The resource server's TTS ends up reconstructing intent from scope strings and gateway-supplied parameters. Letting the TTS consume AS-signed tctx is a real improvement, and Section 6 is short and well specified.
Pairwise txn is also a thoughtful design. A per-task agent token that every downstream API can join on is a tracking identifier, and the draft treats it that way.
Significant interoperability concerns
Transaction-level policy is opt-in for the client. Section 4.3 says that if txn_handle is absent, "the AS begins a new transaction." So an agent that wants to escape a "ten tokens per task" limit just stops sending the handle. Every limit in Section 4.4 is only enforceable against a cooperative client. Either starting a new transaction needs its own policy gate that the draft describes, or the handle needs to be required under some conditions. As written, the handle is a correlation hint, not a control.
transactional_access_tokens_required contradicts the grant rules. Section 4.2 says an AS MUST issue only Txn-ATs to a client with that metadata set. Section 4.1 says the AS MUST NOT issue Txn-ATs from the authorization code grant. So what goes in the access_token field of the code exchange response for that client? RFC 6749 requires one. The draft needs to say whether the code response carries only a refresh token, or whether this flag only applies to the three allowed grants.
tctx has no shape. The draft defers this to Txn-Tokens, which also leaves it to deployments, and the open issues ask whether there should be a vocabulary for agent tasks. Inside one trust domain that's fine because the TTS and its workloads are run by the same team. Across a trust boundary, it means every AS and resource server pair needs a bilateral agreement on what tctx contains. That's the main thing that would make Txn-ATs interoperable, and it's the main thing missing.
tctx and authorization_details overlap. Section 3.4 says authorization_details is "what was granted" and tctx is "the context the AS asserts about the transaction." The example tctx is {"task": "summarize_invoices", "period": "2026-Q3"}. That's a RAR object. A resource server receiving both has no guidance on which one to enforce. Either tctx should be defined as something RAR can't express, or the draft should lean on RAR for the AS-to-RS piece and use tctx only as the bridge into the TTS.
The client's view of the task is unverifiable. The AS only knows what the client told it through scope, authorization_details, and request_details. "Fresh policy decision per transaction" is real, but the AS is deciding on the agent's own description of the task. That's inherent, not a bug, but the security considerations oversell it a bit when they say the AS is "in control of each authorization decision."
Smaller items:
- Section 4.4's "MUST evaluate policy for every Txn-AT request" isn't observable or testable. It's a statement of intent, and could be a SHOULD with the actual normative hook being the
transaction_deniederror. - Token Exchange responses MUST NOT include a refresh token, so after the first call the handle is the only continuation mechanism. That's fine, but the handle expiry isn't returned (open issue 1), so the client has no idea when it'll stop working.
- The Overview step list is misnumbered. Steps 5 and 6 are collapsed into "5. and 6." and then step 7 is labeled 6.
- The draft says
tctxandrctxhave "semantics as defined in [TXN-TOKENS]," but Txn-Tokens definestctxas immutable through a call chain. That property doesn't mean anything for a single resource server. Worth restating what carries over. - RAR, DPoP, and mTLS are informative references, but
authorization_detailsandcnfare defined claims with MUST-level processing in Section 5. They belong in the normative list.
Mechanisms that could be removed or simplified
The new typ is the biggest question. The justification is that resource servers that don't implement this spec will reject a Txn-AT "rather than accept them as ordinary access tokens and ignore their transactional semantics." But what's the harm in a resource server ignoring txn on a five-minute, single-audience access token? It's still a valid, narrowly scoped token. The draft already says a resource server that requires Txn-ATs MUST reject at+jwt, which gives the protection where it matters. Meanwhile txnat+jwt means every existing RFC 9068 validator, including every off-the-shelf JWT access token library, breaks on these tokens. A profile that adds txn and tctx to at+jwt, plus a resource server metadata flag to require them, would get most of the value with far less deployment friction. Token confusion with Txn-Tokens is already handled by txntoken+jwt on the other side.
The HMAC derivation in Section 7.6 is good guidance but isn't needed for interop, since only the AS ever computes it. It would read better as an appendix.
The transactional_access_tokens_supported AS metadata is a boolean that tells the client nothing it can't learn from transaction_denied or a rejected requested_token_type. It could go, or be replaced with something more useful like the maximum handle lifetime.
Writing quality
Clean and compact. Twenty-five pages including IANA and examples, which is about right for what it defines. BCP 14 language is used correctly, the claims table is clear, and the examples are complete and correctly encoded. The privacy section is unusually honest, calling out timing correlation and the AS as an observer of every transaction instead of pretending pairwise txn solves correlation.
The open issues list is useful, and the naming question is a good one. "Transactional Access Tokens" and "Transaction Tokens" will get confused in every hallway conversation. "Transaction-Scoped Access Tokens" is better.
The main gap in the prose is justification. The draft doesn't explain why the existing Txn-Token edge exchange isn't enough, and doesn't engage with Section 13.13 of its own parent spec. Two paragraphs on that would head off most of the first round of mailing list questions.
Background of the authors
Atul Tulshibagwale (CrowdStrike) is the sole listed author. His Datatracker profile shows zero RFCs, two active drafts (this one and Txn-Tokens), and four expired drafts, including the original individual Txn-Tokens draft and a WIMSE draft. The RFC count undersells him. He's the lead editor of an adopted OAuth working group draft now at -11, and this draft reads like someone who knows exactly where the edges of that spec are.
Pieter Kasselman (Defakto Security) is listed as a contributor. He has one published RFC and seven active drafts, spanning Txn-Tokens, identity chaining, SPIFFE client auth, first-party apps, the Fletcher chaining profile, and WIMSE. He's one of the most active people in OAuth's workload and cross-domain work right now.
Between them they've written most of the Txn-Token ecosystem. The useful next step isn't more detail in this draft in isolation. It's a mailing list thread that puts this draft next to the chaining profile and asks whether transaction context crossing a trust boundary, in both directions, should be one coherent piece of work.