The Scope Creep Automated reviews of new AI-related working group submissions

Review · October 26, 2026

One Profile for the act Claim Across Grants, Access Tokens, and Transaction Tokens

draft-mcguinness-oauth-actor-profile -01View on Datatracker →

The problem it's solving

RFC 8693 defined the act claim and then left most of the hard parts open. It says an actor is identified by sub, mentions that iss "might be necessary" to disambiguate, and calls the nested chain informational. It says nothing about how act moves from a JWT authorization grant into an access token into a Transaction Token, or how the actor in act relates to the key in cnf.

Agents made this urgent. An enterprise IdP, a SaaS provider's AS, and that provider's internal Transaction Token Service each add or carry forward actor information, and each one does it its own way today. A resource server at the end of that chain can't tell an AI agent from a batch job, can't tell whether act.sub is globally unique or just unique at one issuer, and can't tell whether the key that signed the request belongs to the actor or to something upstream.

This draft is a profile of act, not a new mechanism. Four rules carry most of the weight:

  • An actor is the pair (act.iss, act.sub). The iss inside act is the namespace the identifier came from, not the issuer of the current token.
  • Actors get a sub_profile (user, service, ai_agent) from OAuth Entity Profiles.
  • The outermost act is whoever is holding the token right now, and the top-level cnf is that party's key. Inner actors are history.
  • client_id is never silently promoted to actor. If sub and client_id differ, that alone does not mean delegation happened.

How it fits in the working group

In charter, and tightly connected to adopted work. It profiles RFC 8693 and RFC 9068, adds claims and processing rules to Transaction Tokens, and fills the actor_token extension point that ID-JAG explicitly left for "future profiles." It registers one error code (actor_unauthorized), one AS metadata parameter, one Protected Resource Metadata parameter, one introspection member (chain_complete), and one grant-profile URN.

The dependency list is where it gets heavy. Beyond the core RFCs, five in-progress documents are normative: ID-JAG, Transaction Tokens, WIMSE Workload Credentials, WIMSE Workload Proof Token, and Entity Profiles. The first two are adopted OAuth work. The WIMSE pair is adopted in another WG. Entity Profiles is an individual draft co-authored by the same author. This document cannot be published until all five finish.

It's one of three. Actor Receipts and Actor Proofs sit on top and add per-hop signed evidence. Section 11 of this draft constrains them: companions may add top-level claims but MUST NOT reinterpret act.iss or nested act objects as verified provenance. That layering is clean and keeps the core profile honest about what act does and does not prove.

What the mechanism actually does

Most of the 93 pages are per-path processing rules. The model underneath them is small.

When does a token represent delegation? Only when one of three things is true: a validated actor_token named a distinct actor, the inbound token already carried act, or the AS has its own basis such as a consent record, pre-registered grant, or may_act claim. In Token Exchange the third one can authorize an actor but cannot create one. A new actor comes from an actor_token, or from the authenticated confidential client on the may_act path. Nothing else.

Chain construction is three choices. Extend the chain with a new outermost actor and nest the inbound chain under it. Preserve the inbound chain byte for byte. Omit act because there is no delegation. There is no fourth option. An AS that receives act and can't preserve or extend it MUST reject the request rather than issue a token without it. Truncation is forbidden; a chain over the local depth limit is an error.

Every delegated Token Exchange is continuation or rebind. Continuation means no new presenter: the output keeps the input's cnf binding (or stays bearer), and the chain is copied unchanged. Rebind means an actor_token named a new presenter: the AS wraps the chain in a new outermost act and binds the output's cnf to the new presenter's key. A rebind can upgrade a bearer input to a sender-constrained output. A request that fits neither mode is rejected.

Actor tokens must name themselves. Three types are allowed: a JWT client assertion, a WIMSE Workload Identity Token, or a non-delegated JWT access token. Each identifies the actor in its own sub and MUST NOT carry act. A JWT authorization grant can't be an actor_token, because its sub is the user.

Resource servers authorize on two principals. sub and the outermost (act.iss, act.sub). Inner actors are never inputs to access control. An actor-policy denial is a 403 with actor_unauthorized, and the RS MUST NOT use insufficient_scope for it, since asking for more scope won't fix an actor denial.

Transaction Tokens get act and a required iss. The TTS MUST NOT infer delegation because req_wl differs from sub. req_wl is who asked the TTS; act.sub is who is acting. The two are expected to match in rebind mode, and the RS treats req_wl as supporting context only.

The ID-JAG angle

This is the part that matters most for Cross-App Access deployments. Appendix B walks the full flow: ID Token to ID-JAG to access token to Transaction Token. Alice is sub the whole way. The agent becomes act when the enterprise AS issues the ID-JAG, and the booking tool wraps the agent when the TTS issues a Transaction Token.

Two consequences for ID-JAG implementers:

  1. An ID-JAG with act and no sender constraint is single-use. The AS MUST reject a second redemption of the same (iss, jti). The draft says plainly that this overrides the resubmission ID-JAG Section 4.4.3 permits. A profile tightening an adopted document's redemption rules is a flag. If resubmission is a replay risk when an agent is the client, it's a risk when a SaaS app is the client too, and the fix belongs in ID-JAG.
  2. The common case sends the same JWT twice. When the agent is both the OAuth client and the actor, the example request carries the client assertion as client_assertion and again as actor_token. Section 6 then needs five bullets to disambiguate what kind of JWT an actor_token is. If "the client is the actor" is the usual agent deployment, a one-bit signal would be simpler than a duplicated credential.

Significant interoperability concerns

The vocabulary lives in an unadopted draft. sub_profile is half the value of this profile, and its values, syntax, multi-value rules, and registry all come from Entity Profiles. Until the WG decides whether to adopt that, this document can't move. The alternative is to inline the three values and drop the dependency.

Transaction Token presenter proof is defined nowhere. Section 7 says the TTS validates proof for an inbound cnf "under the applicable deployment profile, because Transaction Tokens defines no presenter-proof mechanism." This document doesn't define one either. So a sender-constrained Transaction Token has a cnf claim and no specification anywhere for how the receiving service checks it. Appendix B uses WIMSE WPT for this, which is reasonable, but it's an example, not a rule.

Metadata is explicitly non-committal. actor_profile_token_exchange advertises three independent lists: subject token types, actor token types, and output types. The draft then says advertising a type "does not guarantee support for every input/output combination." The appendix calls the preflight "advisory." A client can read all of it and still not know whether ID Token plus workload credential to Transaction Token works at this AS. Identity Chaining already has a parallel list. Each profile growing its own coarse token-type arrays is becoming a pattern worth stopping.

Trust is bilateral everywhere. Whether an issuer may assert a given (act.iss, act.sub) pair, whether a delegation relationship exists, how identifiers reconcile across namespaces: all local policy. The draft is upfront about this in Section 3.3.1. The consequence is that two conformant ASes in different domains interoperate only after an agreement covering things the spec can't express. That's acceptable for a representation profile, but it should be stated as the expectation, not buried.

Depth enforcement and introspection filtering interact oddly. The RS rejects a token whose visible chain exceeds its depth limit. An introspection server may filter inner actors for privacy and set chain_complete: false. A filtered chain passes a depth check that the real chain would fail. Minor, but it shows how optional features multiply edge cases.

Mechanisms that could be removed

  • Refresh tokens as subject_token (Section 6.3.2.2). The chain comes from server-side state, not the token. Nothing crosses the wire that another implementation can act on. Leave it to deployments.
  • Self-issued assertion grants (Section 13.2). MUST reject by default, enabling them is "outside the interoperable scope," then a page of required controls. Say MUST NOT and delete the page.
  • Authorization code act inclusion (Section 5.2). No parameter, no signal, "deployment-specific." The paragraph adds nothing a deployment couldn't already do.
  • chain_complete and introspection privacy filtering. Creates a second mode for a chain that's informational anyway. Drop it until a companion profile needs it.
  • Sections 12.1.1 and 12.1.2. Three-stage migration and implicit-to-explicit rollout. Good operational advice for an implementation guide, not normative text.
  • Section 10.3. One paragraph explaining there is no separate Transaction Token discovery parameter. Fold into 10.1.

Cutting those leaves the actor object, the delegation-chain rules, the continuation/rebind model, the three actor_token types, the JWT grant and access token rules, the TTS deltas, RS processing, and metadata. That's probably 40 pages and still complete.

Writing quality

Precise, consistent, and clearly written by someone who has implemented Token Exchange. Terminology is defined once and used the same way throughout. The travel scenario runs through every example, and the token transformation table in Appendix B.9 is the single best explanation of the model in the document.

The cost of "each rule has one home" is that no section stands alone. Section 6.1 on presenter transitions references Sections 3.5, 3.7, 6.2, 6.4, and 6.5, several of which reference back. A reader has to hold the whole document in their head to evaluate any one rule. The -01 restructure helped: it dropped from 112 pages to 94 and from roughly 555 BCP 14 keywords to roughly 390. It's still a lot of normative text for one claim, and a reviewer coming to it cold will struggle to separate the rules that carry interop value from the defensive ones.

Background of the author

Sole author, Karl McGuinness, listed as Independent, formerly at Okta.

  • 0 published RFCs
  • 16 active Internet-Drafts and 2 expired, as of mid-October 2026
  • Co-author of ID-JAG, an adopted WG document, and of the Entity Profiles draft this one depends on

Not a new author, and writing at a very high rate. Nearly all of the active drafts are OAuth individual submissions aimed at agent and workload delegation, designed to fit together with shared terminology and explicit companion hooks. The WG can't review all of them at once, and the three-document actor suite alone is close to 200 pages.

Questions worth raising

  1. Does the WG want a baseline act profile at all? If ID-JAG and Transaction Tokens are going to say "see the actor profile" for agent delegation, something like this has to exist. If not, each of those documents has to answer the same questions on its own.
  2. Should the ID-JAG changes go into ID-JAG? Single-use redemption and act processing for actor_token are ID-JAG behaviors. They could land there as a short section instead of in a 93-page dependent profile.
  3. Can sub_profile be decoupled from Entity Profiles? Three string values and a registry. Either adopt Entity Profiles or inline the minimum here.
  4. Who defines Transaction Token presenter proof? It's referenced here, referenced in Transaction Tokens, and defined in neither.

For the extension point this draft fills, read Section 4.4 of ID-JAG. For the chain-evidence question the core profile deliberately leaves out, read the companion Actor Receipts draft.