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

Review · October 13, 2026

Making the act Claim Mean the Same Thing in Every Token

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

The problem it's solving

Alice tells an AI travel agent to book a trip. The agent gets a token from her enterprise IdP, trades it at the travel provider's AS for an access token, and calls a booking tool. The booking tool gets a Transaction Token and calls an internal inventory service.

By the time the inventory service sees a request, three different issuers have touched the token. Each one had to decide whether to say "Alice, via the agent, via the booking tool," and how.

RFC 8693 gave us the act claim for exactly this and then stopped. It doesn't say what makes an actor identifier unique, how to tell an AI agent from a service account, how act survives being converted between a JWT grant, an access token, and a Transaction Token, or how the actor relates to the key in cnf. Everyone filling in those blanks today does it differently.

This draft fills them in. It's a profile of act, not a new mechanism. The headline rules:

  • Every actor object MUST carry iss alongside sub, so the pair (act.iss, act.sub) is the actor's identifier.
  • Actors get classified with sub_profile (user, service, ai_agent) from OAuth Entity Profiles.
  • The outermost act is the current presenter, and the top-level cnf is that presenter's key.
  • client_id is never the actor by default. The AS MUST NOT add act just because sub and client_id differ.

How it fits in the working group

This is squarely in charter. It profiles a published RFC and fills extension points that two adopted WG drafts deliberately left open.

ID-JAG accepts actor_token in its Token Exchange request and says processing it, and whether the ID-JAG ends up with an act claim, is for "future profiles or extensions." This is that profile. Transaction Tokens has req_wl but no actor model. This adds one, and says req_wl is supporting context, not a substitute for act.sub.

That makes it directly relevant to Cross-App Access. XAA is ID-JAG. The moment an agent, rather than a human-driven app, is the one exchanging the ID Token, the question "who is the actor in this ID-JAG and how does the resource AS know" has to be answered. Appendix B walks through exactly that flow: ID Token to ID-JAG to access token to Transaction Token, with Alice as sub the whole way and the agent and then the booking tool as actors.

The dependency surface is large. RFC 6749, 7519, 7521, 7523, 7662, 7800, 8414, 8693, 8705, 9068, 9449, 9728, OpenID Connect Core, plus three in-progress drafts as normative references: ID-JAG, Transaction Tokens, and the individual Entity Profiles draft. The last one is a problem, covered below.

New registrations: the actor_unauthorized error, the urn:ietf:params:oauth:grant-profile:actor-profile value, actor_profile_token_exchange AS metadata, actor_profile_required resource metadata, and a chain_complete introspection member.

How it compares to the other delegation drafts

The last two months brought a pile of agent delegation drafts. Most of them either ignore act or invent a parallel structure.

draft-hamr-oauth-agent-delegation defines its own HTTP header and never mentions RFC 8693. draft-asor-wimse-agent-delegation-chain builds cryptographic parent links into a new JWT structure. draft-mishra-oauth-agent-grants uses act but leaves chain processing as implementation detail.

This draft goes the other direction. It takes act as given, keeps RFC 8693's rule that nested actors are informational only, and specifies every step of how act gets validated, extended, preserved, and consumed. That's the right starting point. Whatever the WG ends up doing about verifiable chains, it needs an agreed baseline for the plain act claim first.

Karl's other active draft in this space, Identity Continuation Assertion, covers a different problem: how a downstream workload gets the next ID-JAG after the user is gone. The two would compose, but neither references the other's processing.

The three-draft suite

Actor Profile is the core. Two companions sit on top of it:

  • Actor Receipts adds an actor_receipts claim. Each AS that adds a hop signs a receipt, hash-linked to the previous one, so a recipient can verify each issuer's contribution independently instead of trusting only the outermost issuer's signature.
  • Actor Proofs adds actor_proofs. Here the actor itself signs its participation and target at each hop, so a dishonest AS can't fabricate an actor that never agreed to anything.

The layering is clean. The core profile says inner act entries are only as trustworthy as the outer token issuer, full stop. Section 11 then constrains companions: they MUST NOT reinterpret act.iss or nested act objects as verified provenance, and SHOULD put their evidence in separate top-level claims. Deployments that don't care about per-hop verification never see the companions.

That's a much better answer to the "act doesn't prove the chain" complaint than redefining act. It's also nearly 200 pages across three documents.

What the mechanism actually does

Most of the document is processing rules for each token path. The parts worth understanding are these.

Actor identifiers are pairs. act.iss is defined as the namespace context for act.sub, explicitly not the issuer of the current token. A TTS can sign a token whose actor has act.iss set to the AS that issued that tool's workload credential. Comparing act.sub to sub alone is insufficient: the draft says if (act.iss, act.sub) equals (iss, sub) there's no delegation.

Delegation has to be established, not inferred. A token represents delegation only if a validated actor_token named a distinct actor, an inbound token already carried act, or the AS has an independent basis (consent record, pre-registered grant, may_act, policy). In Token Exchange, an independent basis can authorize an actor but can't create one. Only an actor_token or the authenticated client on the may_act path does that.

Presenter continuation versus rebind. This is the most useful part of the draft. Every delegated Token Exchange is exactly one of two things:

  1. Continuation: no new presenter. The output keeps the input's presenter, either the holder of its cnf key or, for a bearer input, the authenticated outermost actor. The act chain is copied byte for byte.
  2. Rebind: an actor_token names a new presenter. The AS wraps the inbound chain under a new outermost act and binds the output's cnf to the new presenter's key.

Anything that fits neither mode is rejected. The draft also says that if processing of a delegated request fails, the AS MUST NOT fall back to issuing a token without act. Silently dropping the chain is exactly the bug you'd expect implementations to ship, so it's good to see it called out.

Actor tokens must name themselves. Three actor_token types are allowed: a JWT client assertion, a WIMSE workload credential, or a non-delegated JWT access token. Each must identify the actor in its own sub, and none may carry act. A JWT assertion grant can't be an actor_token, because its sub is the user.

Resource servers authorize on (sub, outermost act). Inner actors are not inputs to access control. An RS that accepts a token for delegated access MUST NOT ignore act. Enforcing the (sub, act.sub) pair on every request is a SHOULD for security-sensitive access.

What changed since -00

The Document History says -01 is a restructure, and it is. It's about 1,000 lines shorter (111 pages down to 93), and the reduction came from consolidating, not dropping features.

Structural changes:

  • The Conformance section is gone. It restated rules from elsewhere in per-role checklists.
  • Token Exchange inputs now share one processing algorithm (Section 6.2) instead of each subsection repeating it.
  • The error section went from a four-column table with AS-specific and TTS-specific triggers to a short ruleset plus a simple table.
  • The count of BCP 14 keywords dropped from about 490 to about 340.

Substantive changes:

  • Inner actors can no longer feed decisions. -00 had a "Validate Inner Actors Used for Decisions" step that let local policy use nested act entries for issuance decisions. -01 removes it. Nested actors are prior-actor context only, matching RFC 8693 Section 4.1.
  • Error codes realigned. -00 used invalid_grant broadly, including on Token Exchange. -01 uses invalid_request on Token Exchange per RFC 8693, invalid_grant only on JWT bearer grants, and defines precedence for client auth and DPoP errors.
  • Bearer assertion grants become single-use. An assertion grant without an enforced grant-level sender constraint MUST be rejected on a second (iss, jti) redemption.
  • New actors only from actor_token or may_act. A policy rule can no longer conjure a new actor in Token Exchange.
  • Refresh tokens keep the chain. A refresh token issued alongside a token with act MUST record the chain, and a refresh that can't carry it forward fails.
  • client_id is now required in delegated JWT access tokens, per RFC 9068.
  • may_act.iss is used as the identifier context when present.
  • The ID-JAG token type was added to the metadata, and several references (RFC 6749, RFC 7800, OIDC Core, ID-JAG) moved to normative.

The -00 problems that -01 actually fixed are the ones that would have produced conflicting implementations: error codes that disagreed with RFC 8693, and an optional path for using unverified inner actors in authorization. Both were real.

Significant interoperability concerns

The classification vocabulary lives in an unadopted draft. sub_profile is half the value proposition, and its values, semantics, multi-value rules, and registry all come from draft-mora-oauth-entity-profiles, an individual draft that Karl co-authors. As a normative dependency, this profile can't advance ahead of it. The WG should either adopt Entity Profiles first or decide whether sub_profile belongs in this document at all.

It overrides ID-JAG behavior. Section 4.2 makes a bearer ID-JAG carrying act single-use, and says so explicitly: "including an ID-JAG that Section 4.4.3 of [ID-JAG] would let a client re-submit." That's a profile changing an adopted WG document's redemption rules. If ID-JAG resubmission is a replay risk once agents are involved, it's a replay risk without agents too, and the fix belongs in ID-JAG.

Too many optional paths. Table 2 lists five subject_token types, three actor_token types, and three output types. Section 3.3.3 says implementations "need not support every combination." The actor_profile_token_exchange metadata advertises each list separately, and the draft admits that advertising a type "does not guarantee support for every input/output combination." A client can read the metadata and still have no idea whether ID Token plus workload credential to Transaction Token works. Identity Chaining already has its own parallel identity_chaining_requested_token_types_supported. This is becoming a pattern of each profile defining its own coarse token-type lists.

The client-as-actor pattern is awkward. Because the draft forbids treating the authenticated client as the actor by default, the main ID-JAG example (Appendix B.4) sends the same client assertion JWT twice in one request, once as client_assertion and once as actor_token. Section 6 then needs five bullets of disambiguation rules to figure out what kind of JWT an actor_token is. If the common case is "the client is the agent," a simpler explicit signal than a duplicated JWT would cut a lot of text.

Every trust decision is local policy. Whether an issuer may assert an (act.iss, act.sub) pair, whether a delegation relationship exists, how identifiers reconcile across namespaces: all deployment-specific. That's defensible for a representation profile, and the draft is upfront about it in Section 3.3.1. It does mean two conformant ASes in different domains will only interoperate after a bilateral agreement covering things this document can't express.

Mechanisms that could be removed

  • Self-issued assertion grants (Section 13.2). The draft says MUST reject by default, and enabling them is "outside the interoperable scope." Then it spends a page specifying minimum controls. Say MUST NOT and stop.
  • Authorization code actor inclusion (Section 5.2). The draft defines no actor-selection parameter for the code flow and says actor determination there is deployment-specific. A paragraph allowing act under an independent basis adds nothing a deployment couldn't already do.
  • Refresh tokens and ID Tokens as subject_token. Both are "identity-only" inputs that can't support continuation. The ID Token path is needed for the ID-JAG flow. The refresh token path adds a separate set of rules for recorded chain state and could be left to deployments.
  • chain_complete and privacy filtering in introspection. Letting the AS hide inner actors creates a second mode every RS has to handle, for a chain that's informational anyway.
  • Migration staging (Section 12.1.1). The three-stage rollout is good advice and belongs in an implementation guide.

Writing quality

Precise and consistent, and very dense. This reads like someone who has implemented token exchange and knows where the edge cases are. The terminology is carefully defined, the examples share one travel scenario across every section, and Appendix B's token transformation table is the clearest single explanation of the whole model.

The density is the problem. Section 3.5's definition of when a token "represents delegation" takes three numbered conditions plus two clarifying paragraphs plus an exception for Token Exchange. Section 6.1 needs to be read three times. Cross-references are constant, often several per sentence, so following any one rule means jumping across the document. The -01 consolidation helped, and "each rule has one home" is the right goal, but the cost is that no section stands alone.

Ninety-three pages to profile one claim is a lot. With the two companions it's nearly 200. Some of that is unavoidable: there are genuinely many token paths. But a reviewer coming to this cold will struggle to tell which rules carry the interop value and which are defensive belt-and-suspenders.

Background of the author

Sole author, Karl McGuinness, listed as Independent. Previously at Okta. His Datatracker profile shows zero published RFCs, 16 active Internet-Drafts, and 2 expired.

Zero RFCs undersells his involvement. He's a co-author of ID-JAG alongside Aaron Parecki and Brian Campbell, which is a WG document, and of the Entity Profiles draft this one depends on. Most of the other 14 active drafts are his own OAuth individual submissions, many of them aimed at agent and workload delegation: client instance identifiers, AI agent instances, client attesters, mission-scoped authorization, Token Exchange cnf, and the three-draft actor suite.

That's an enormous amount of active writing for one person. The upside is that these drafts are designed to fit together, with consistent terminology and explicit companion hooks. The downside is that the WG can't realistically review all of them, and the actor suite alone is a full working group cycle of material.

The right next step is probably to split the question. Is there WG interest in a baseline act profile that ID-JAG and Transaction Tokens can point at? If so, this draft is a strong starting point, and the review should focus on cutting it down to the paths people are actually deploying. The companions can wait until the core settles.