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

Review · November 10, 2026

Mission-Bound Authorization, a Task Record That Gates Every Token an Agent Gets

draft-mcguinness-oauth-mission -02View on Datatracker →

The problem it's solving

OAuth has grants and tokens. It has no object for "the task the user approved." An agent working on a multi-step job collects tokens for several audiences, refreshes them, and hands narrowed copies to sub-agents. Nothing ties those back to one approval that can be switched off.

This draft adds that object and calls it a Mission. The client describes the task. The AS turns it into RAR authorization_details. The user approves that authority. Every later token is a subset of it, carries a mission claim, and is only issued while the Mission is active.

Revoking a Mission stops new tokens and refreshes. It does not recall tokens already issued. The draft says this in the abstract and repeats it throughout.

How it fits in the working group

It is an OAuth extension that composes existing pieces. The client side is PAR plus RAR. The token is an RFC 9068 JWT access token. Delegation is Token Exchange. There are 19 OAuth-family RFCs in the normative references, plus OpenID Connect Core, JCS, and three drafts: the adopted RAR metadata remediation draft, and the author's own unadopted Actor Profile and Client Instance ID.

It creates a lot of new behavior. There are three conformance roles, four optional capabilities, a ten-check issuance procedure, four new OAuth parameters, one error code, one JWT claim, one introspection member, two metadata parameters, and three new IANA registries.

It also adds a new AS duty that reaches outside the flow. A resource can be marked "Mission-governed," and the AS then must not issue a token for it outside a Mission on any grant type.

This is the base document of a family. It cites 14 Mission companion drafts by the same author: architecture, security model, shaping, runtime, metering, status, cross-domain, approval governance, submission evidence, and more. The changelog lists 16 further companions that -02 stopped citing.

It defines no authorization_details type of its own. Every example uses mission_resource_access from a companion draft.

What the mechanism actually does

The client submits a Mission Intent through PAR. A new mission_intent parameter carries a JSON envelope. The Intent has a goal string, target_resources, and expires_at, with optional task_bounds, purpose, and goal_lang. The client can propose concrete authority in the standard authorization_details parameter in the same push.

The AS derives an Authority Set. In narrowing mode it trims the client's proposal to policy. In configured-mapping mode there is no proposal, and the AS looks up entries keyed on purpose or target_resources. The prose is inert. The AS must derive the same authority for two Intents that differ only in goal or task_bounds.

The Approver consents to the Authority Set, not the prose. The AS shows the derived authority beside the goal text. On approval it creates the Mission Record, computes three hashes (intent_hash, proposal_hash, authority_hash), and binds the authorization code to the Mission server-side. The Approver can be someone other than the Subject, such as an admin.

Every issuance is gated. Code redemption, refresh, and Token Exchange each resolve the Mission from the presented grant, check it is active, and check the requested authority is a subset. The client never supplies a mission_id to get a token. Token lifetime is capped at the Mission's expiry.

The token carries authorization_details and a mission claim. The claim is id and issuer, with optional expires_at. It is a correlation handle. The authority is the RAR entries.

The resource server enforces from the token alone. It must understand the RAR type, and an entry it can't fully enforce grants nothing. A resource server that wants live Mission state introspects.

Delegation is optional and takes two Token Exchanges. The agent exchanges its sender-constrained token for a short-lived "designation" naming the sub-agent's client_id. The sub-agent authenticates and redeems it for a delegated token bound to its own key, with an act chain. Public clients can't be delegates.

Lifecycle is two states. Active and terminated, with a reason of revoked or expired.

So what does a deployment get that RAR plus PAR doesn't give it?

Three things. A durable ID that joins tokens across refreshes, audiences, and delegates. One switch that stops issuance across all of them. A rule that sub-agents only ever get a subset.

What it doesn't get is a way to flip the switch. The AS MUST accept revocation by mission_id, and "the wire shape of that revocation is out of scope." The state that makes a Mission useful to a resource server is in introspection or a companion Mission Status draft.

Most of the 166 pages describe what happens inside the AS. On the wire, a client sees one request parameter and three response members. A resource server sees one claim.

Significant interoperability concerns

The Intent-to-authority step is local policy. The draft says so directly: different authorization servers can derive different Authority Sets from the same Intent, and "interoperability begins at the derived Authority Set." A client can't predict what a given AS will grant. In configured-mapping mode the available mappings are published as "deployment documentation" with no metadata signal.

There is no common authority type. Resource server conformance "implies support for no particular type." An AS and a resource server can both conform and share nothing they can enforce. Real interop needs the Resource Access companion, which is a separate unadopted draft.

Revocation has no protocol. It is the headline feature and the only mandatory piece with no interface. A user dashboard at Okta can't revoke a Mission at another vendor's AS without a bilateral API.

Too much is settled by documentation. Appendix B lists what each deployment decides and how other parties learn it. Many rows read "no protocol signal": derivation mode, per-type narrowing and delegation capabilities, which resource servers process the act chain, designation redemption counts, the approval-authentication floor. Capabilities are discovered "out of band or by attempt."

Admin approval has no wire representation. When the Approver isn't the Subject, how the AS learns the Subject is "a deployment matter."

The downgrade protection depends on classification the client can't see. A resource is Mission-governed by metadata or by private AS configuration. A client finds out about the second kind when a refresh or client credentials request fails with invalid_target.

Delegation rests on an unadopted draft. The act chain shape comes from the Actor Profile. The AS must also know, by configuration, that each audience processes the chain before it issues a delegated token.

Mechanisms that could be removed

  • Intent Submission Evidence. The core defines no evidence type. Every AS still has to implement the dispatch-and-refuse rules and a dedicated error code. This belongs entirely in its companion.
  • Integrity anchors, canonicalization rules, the three-species commitment taxonomy, and the test vectors. authority_hash left the token in -01, and -02 lets the record omit the anchors. No party in this document verifies them across a trust boundary. They serve companions.
  • authority_source, approval_basis, and the standing-consent hooks. These are record-keeping inside the AS for creation paths this document doesn't define.
  • Transformation capability declarations. Three booleans per type, three possible carriers, and a precedence rule, where "deployment documentation is always a sufficient carrier."
  • The Cross-Domain conformance bar. Six requirements for a capability whose mechanism is in another draft.
  • Opaque tokens and the introspected consumption mode. Start with JWT access tokens and add this when someone needs it.
  • Three new IANA registries. Lifecycle states has two entries. Termination reasons has two. Intent members has six.
  • Section 16, Appendix B, and Appendix C. Implementation guidance and design notes.
  • mission_error. A SHOULD-level diagnostic next to the standard error code.

What's left is the mission_intent parameter, the Authority Set and subset rule, the grant binding, issuance gating, the mission claim, the two metadata flags, and a revocation endpoint that actually has a wire format. That is a document a working group can review.

Writing quality

The draft is precise, internally consistent, and written in proper IETF style. The error tables and the processing order are careful. The repeated statement that revocation doesn't recall issued tokens is honest about the main limit.

It is far too long. -00 was roughly 77 pages. -02 is 166, after two revisions that each moved material out to companions. The -02 changelog cites GitHub issue numbers past #2000.

The vocabulary is hard to hold. Mission-bound, Mission-derived, Mission-referenced, Mission-governed, and Mission-aware are five different things. "Derivation" means one token issuance and "Authority Set derivation" means computing what the user approves, and the terminology section admits the two collide. Most paragraphs point to three or four other sections, so no section reads on its own.

Several rules exist to close edge cases a first version doesn't need, such as a response prepared before a revocation was committed and released after it.

Background of the author

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

The Datatracker profile could not be fetched for this review. The figures below are from the profile as checked for the October reviews.

  • 0 published RFCs
  • 16 active Internet-Drafts and 2 expired, as of mid-October 2026
  • Co-author of ID-JAG, an adopted WG document

Not a new author, and writing at a very high rate. The count is higher now: this draft alone cites 17 of his other drafts, most of them Mission companions submitted since.

Questions worth raising

  1. Is a task object the right layer for the WG, or is this a grant ID with policy attached? The wire-visible parts are close to RAR plus a grant identifier. FAPI Grant Management already defines grant_id with query and revoke, and -02 dropped its citation.
  2. Can the base be useful without a revocation interface and a common authority type? Both are out of scope here and both are needed for two vendors to interoperate.
  3. What does the Intent add if the prose is inert? The machine-readable content is target_resources, expires_at, and an opaque purpose key. The consent screen text could ride in the RAR entries.
  4. How would the WG adopt one document of a family this size? The base keeps hooks for a dozen companions. Reviewing it means deciding which of those hooks the WG is committing to.
  5. How does this line up with the other agent-authorization proposals? AAuth is cited informatively, and several agent delegation and revocation drafts are in front of the WG at the same time.

For the type every example depends on, read the Mission Resource Access draft. For the delegation chain format, read the Actor Profile.