Review · November 10, 2026
Transaction Authorization Challenge Lets a Resource Server Demand Approval for One Specific Operation
The problem it's solving
An access token says the caller is allowed to talk to an API. It doesn't say a human approved this particular $5,000 payment.
That gap gets wider with agents. An agent framework might show the user a confirmation prompt, but the resource server never sees it and gets nothing it can validate. And sometimes the person who needs to approve isn't the user at all. It's the owner of the resource, or a manager, or an admin.
Step-up authentication lets a resource server ask for stronger or fresher user authentication. This draft is the authorization equivalent. The resource server asks for approval of one concrete operation and gets back an access token that proves it happened.
What the mechanism actually does
The resource server rejects the request with a 401 and a new transaction_authorization_required error. The WWW-Authenticate header carries a transaction_challenge, a JWT signed by the resource server.
The challenge names the resource server as iss, the authorization server it wants as aud, a txn identifier, a human-readable reason, and the operation itself as RAR authorization_details. It can also carry act to identify the agent that made the request and cnf to name a key the resulting token must be bound to.
The agent relays the challenge to the client without touching it. The client validates the signature, optionally shows it to the user, and posts it to the token endpoint with a new grant type, urn:ietf:params:oauth:grant-type:txn-authz-challenge.
The AS validates the challenge, decides who needs to approve, and goes and gets that approval. How it does that is out of scope. If approval takes time, the AS returns a deferral code using Deferred Token Response and the client polls.
The result is a short-lived access token, audienced to the resource server, carrying the same txn and the granted authorization_details. The client hands it to the agent, the agent retries the request, and the resource server checks that the token matches the challenge it issued.
How it fits in the working group
It's in charter. It extends RFC 6750 error signaling, adds a token endpoint grant, and adds two parameters to Protected Resource Metadata for the resource server's challenge-signing keys.
The dependency list is long. Fifteen normative references besides the BCP 14 boilerplate, including RAR, DPoP, mTLS, Token Exchange for act, RFC 7800 for cnf, and RFC 8417 for txn. Fourteen are RFCs. The fifteenth is Deferred Token Response, an adopted draft that is itself only at -01.
It creates three new relationships that the working group should look at closely.
The resource server becomes a JWT issuer that the AS has to trust. Today the AS signs things and the resource server verifies them. Here the AS also verifies something the resource server signed, and it needs to know that resource server and its RAR types in advance.
The resource server picks the AS. The aud of the challenge "need not be the issuer of the access token presented with the original request."
The OAuth client is split in two. The "agent" calls the resource server and presents tokens. The "client" talks to the AS. The draft never says how the agent got its original access token or how the two relate.
How does this relate to RAR remediation?
This is the first question the working group will ask.
RAR Metadata and Remediation is already adopted. It has the resource server return a 401 with insufficient_authorization and an authorization_remediation parameter containing the authorization_details the client should go request.
That's the same shape as this draft. Resource server says "you need these authorization details," client goes to the AS, client comes back with a better token.
The differences are real. This draft signs the challenge so a relaying agent can't alter it. It binds the token to one transaction with txn. It uses the token endpoint with deferral instead of sending the user through the authorization endpoint, which is what makes a third-party approver possible.
The draft doesn't mention the remediation draft at all. It should, and it should explain why this isn't a signed, transaction-bound variant of the same error.
What changed since -00
The -00 defined its own transaction_authorization_endpoint with custom pending and polling behavior. The -01 drops all of that for a token endpoint grant plus Deferred Token Response. That's the right call. It removed an endpoint and an AS metadata parameter.
The -01 also adds Section 4.4 on key binding, which is new and is now the most complicated part of the document.
Significant interoperability concerns
The client may have no relationship with the AS the resource server chose. The client learns which AS to use from the challenge. Section 4.6 says the client MUST verify that aud identifies "the authorization server to which the client intends to present the challenge," which is circular. If the client isn't registered at that AS, the flow stops. The draft should say whether this assumes the same AS that issued the original token, or point to something like Client ID Metadata Documents.
The AS has to understand the resource server's RAR types to show an approver anything useful. Section 4.7 requires the AS to verify that "the requested operation is sufficiently described." Nobody can test that. In practice every resource server and AS pair needs a bilateral agreement on types, which is the exact problem the RAR metadata draft exists to solve.
It conflicts with its own normative dependency. When the challenge has cnf, the token is bound to the agent's key. Deferred Token Response requires the token to be bound to the client's DPoP key. The draft says so in an editor's note and states that fixing it requires a change to the other document. Until that happens, a public client can't implement both specs as written.
The AS binds tokens to a key nobody proved to it. With cnf in the challenge, the AS "does not verify possession of the binding key" and relies on the resource server's signed assertion. This is a carve-out from DPoP Section 5.2. It's defensible, because the resource server is also the only party that will ever accept the token. It's still a new trust direction and deserves more than two paragraphs.
Binding the retry to the original request is left to profiles. The resource server checks that the granted details "are consistent with" the challenge. Whether the retried request body has to match the challenged one is left to "application profiles," along with alternative audience bindings and extra challenge claims. That phrase appears seven times. For a payment, this is the check that matters most.
The agent-to-client leg is "deployment-specific." That's half the round trip. It's a fair scoping decision, similar to OAuth leaving user authentication out. But an agent and a client from different vendors won't interoperate on this spec alone.
"Supports HITL, HOTL, and HOOTL" overstates it. Human-on-the-loop means a person can intervene after the action proceeds. The draft has no mechanism for that. Section 5.2 mentions "any re-evaluation" once and never defines it.
Mechanisms that could be removed
Section 4.4.2, establishing a binding key from a bearer token request. This has the resource server accept a DPoP proof alongside a bearer token, which DPoP doesn't define. It adds a binding_key_required error, an algs parameter for the Bearer scheme, and a five-step processing list with a caveat about when the key can't be used. The draft already has the simpler answer in the same section: if you need key binding, require a sender-constrained access token.
Accept-Txn-Challenge. A new HTTP header so the agent can say it supports challenges. Step-up didn't need one. A client that doesn't understand the error code treats it as a failed request either way.
reason_uri. The client and AS MAY dereference it, but nothing fetched from it can override the signed challenge. That leaves it as a link for display, and a server-side fetch of a URL chosen by another party.
The HITL/HOTL/HOOTL definitions. Three defined terms that the protocol never branches on. Section 5 says outright that the oversight level "does not change the protocol."
Writing quality
Good. This reads like it was written by people who have shipped RFCs. Requirements are stated precisely, section references into DPoP and mTLS are exact, and the IANA section is complete.
It's long for what it does. The spec is 37 pages. The agent-must-not-modify rule is stated in Sections 3, 4, 4.5, 4.6, 4.7, 6.1, and 7. The Security Considerations section mostly restates normative text from earlier sections. A third of it could go without losing a requirement.
There are a few rough edges that show it's early. The txn claim definition has a sentence missing its subject: "in response to the challenge MUST contain the same transaction identifier." The acknowledgments section says "TODO acknowledge." The reason and reason_uri JWT claims are registered with generic descriptions for a very specific use.
Background of the authors
I couldn't reach Datatracker during this review, so these profiles come from the spec's own reference list and from earlier reviews on this site, not from a fresh lookup. Brian Campbell's exact counts are missing for that reason.
Yaroslav Rosomakho (Zscaler). As of an August 2026 review, he had published RFC 9850 and had 25 active drafts across WIMSE, TLS, QUIC, MASQUE, and OAuth. He is an IAB member and chairs several IETF groups. Experienced in the IETF, newer to OAuth, writing a lot.
Brian Campbell (Ping Identity). One of the most prolific authors in the working group. He co-authored six of the RFCs this draft cites: DPoP, mTLS, RAR, Token Exchange, Step-Up, and RFC 6755. The careful DPoP carve-outs in Section 4.4 are coming from the person who wrote DPoP.
Karl McGuinness (Independent, formerly Okta). As of mid-October 2026, zero published RFCs, 16 active drafts, 2 expired. Co-author of ID-JAG, an adopted working group document. Not a new author, and writing at a very high rate.
Pieter Kasselman (Defakto Security). As of October 2026, one published RFC and seven active drafts, including Identity Chaining, Transaction Tokens, and SPIFFE client authentication.
This is a strong author list. Two of the four are on adopted working group documents that this draft sits next to, which makes the missing reference to the RAR remediation draft the easiest thing to raise first.