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

Review · November 16, 2026

Workload Authorization Grant (WAG)

draft-carleton-workload-authz-grant -02View on Datatracker →

The Problem

Agent platforms create and destroy agents constantly, one per channel, repository, or pipeline. Registering each one as an OAuth client at every SaaS authorization server does not scale. So every agent in an installation ends up sharing one credential, and nobody can tell which agent did what (Section 1).

This draft lets an authorization server trust the platform once. After that, any agent the platform vouches for gets an access token on its first request, with its own stable identifier.

It covers agents acting on their own behalf only.

How It Fits In

This is an individual draft with a 30 minute slot on the IETF 127 WIMSE agenda.

It is a profile of the RFC 7523 JWT authorization grant. It adds no endpoints and no grant type. It adds one role, the Workload Identity Provider, one typ value, one claim (nickname), and two URNs.

It borrows the aud rule, the scope claim, the tenant claims, and the authorization_grant_profiles_supported metadata parameter from ID-JAG.

It cites no WIMSE document. No SPIFFE, no WIT, no WIMSE identifier. Every reference and every registry it touches is OAuth or JOSE. The closest WIMSE text is AIMS Section 10.5.2, which says an agent acting for itself can use the JWT authorization grant with the agent in sub. WAG is the profile of that one sentence.

Summary

There are three steps (Section 3).

  1. Once: an administrator registers the Workload Identity Provider at the authorization server, recording its issuer identifier and keys. This is not a client registration and yields no client_id (Section 6).
  2. Per agent: the platform creates the agent and assigns an opaque identifier. Nothing is sent to the authorization server.
  3. Per access: the agent gets a WAG from its platform and posts it to the token endpoint with grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer.

The WAG is a JWT with typ of oauth-wag+jwt. iss is the platform, sub is the agent, aud is the authorization server's issuer identifier. exp, iat and jti are required (Section 5.1). The platform can add its own claims, such as roles, and the authorization server maps them to permissions under its own policy (Section 6.2).

The authorization server MUST NOT require a client registration per agent, and MUST NOT issue refresh tokens (Section 5).

How is this different from plain RFC 7523?

Mostly it removes choices.

  • RFC 7523 makes jti and iat optional. WAG requires both.
  • WAG requires a typ. The server MUST reject anything else (Section 6.1).
  • Keys come only from the registration, never from the assertion (Section 6.1).
  • sub is unique per issuer and never reassigned. The server keys its records on issuer plus sub (Section 4).
  • Client authentication is optional in both. WAG goes further and "attaches no meaning to client_id".

How is this different from ID-JAG?

The subject and the client are both different.

  • In ID-JAG, sub is a user and client_id is a required claim naming a client registered at the resource authorization server. In WAG, sub is the agent and there is no client.
  • ID-JAG defines how the grant is obtained, by token exchange at the IdP. WAG leaves that out of scope and only reserves a token type URN in case token exchange is used (Section 5).
  • ID-JAG rejects a request that has neither client authentication nor a sender-constrained grant (ID-JAG Section 4.4). WAG requires neither.

How does it differ from SPIFFE client authentication? That draft makes the workload credential a client credential. WAG makes it a grant, so the client disappears.

Interoperability

Significant interoperability concerns

The grant is a bearer token with no second factor. No client authentication, no proof of possession, and replay checking is still optional. All three are listed as open issues (Section 9). A WAG copied from a log is good for an access token until it expires. jti is required in the JWT but the server does not have to check it.

Nobody is the client. Section 5 attaches no meaning to client_id. The draft does not say what the access token or an introspection response carries as the client. RFC 9068 access tokens require a client_id claim. Two servers will fill it differently, and resource servers that log or rate limit by client will see different things.

Tenant matching is configured by hand. When platforms share an issuer, a claim tells them apart. The draft does not fix the claim's name (Section 6.3). It recommends tenant and leaves the rest "out of band".

Revocation is not mentioned. There is no way for the platform to tell the server an agent was deleted. Short assertion lifetimes are the only control, and the access token lifetime rule is a SHOULD NOT with "a significant period" (Section 5).

Mechanisms that could be removed

  • nickname. It is display only, and takes one claim definition plus a full security consideration about spoofing.
  • The error_description and error_uri guidance in Section 7. Section 10 admits it tells any unauthenticated presenter which platforms a server trusts.

Writing Quality

The draft is short, about 11 pages of content, and reads like IETF text. Scope is stated clearly and the open issues are listed honestly.

Some loose ends:

  • The title says workload. The normative text says Agent. "Agent" is only defined in passing under "Platform" (Section 2).
  • ID-JAG is an informative reference, yet Sections 5.1 and 8 depend on it.
  • Section 11.1 registers a media type with no registration template.

Authors

From their Datatracker profiles:

  • Paul Carleton (Anthropic). No published RFCs. This is his only active draft.
  • Nick Steele (OpenAI). No published RFCs. 2 active drafts, this one and WIMSE AIMS.
  • Aaron Parecki (Okta). 2 RFCs, RFC 9728 and RFC 10017. 18 active drafts, including ID-JAG.
  • Arndt Schwenkschuster (Defakto Security). No published RFCs. 8 active drafts, including WIMSE Workload Credentials and OAuth SPIFFE Client Authentication.
  • Brian Campbell (Ping Identity). 14 RFCs, including RFC 7523 and RFC 8693. 9 active drafts, including ID-JAG and WIMSE AIMS.

Questions for the Working Group

So what should the WIMSE session decide?

  • Which working group owns this? It profiles an OAuth grant, depends on an OAuth draft's metadata parameter, and registers OAuth URNs. It references no WIMSE document. That points to OAuth, with WIMSE review.
  • Should it be a document at all, or a section of AIMS? The Note to Readers says this is open.
  • Which hardening is required: client authentication by the platform, a sender-constrained grant, or mandatory jti replay checks? Shipping with none is hard to defend.
  • What does the authorization server record as the client?
  • How does a WAG relate to WIMSE credentials? Can a WIT or JWT-SVID be exchanged for one, and should the draft say so?