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

Review · August 26, 2026

AI Agent Resource Extension for SCIM

draft-wzdk-scim-agent-resource -00View on Datatracker →

Enterprises already push human users into SaaS apps with SCIM. This draft says agents should ride the same rails.

It defines one new SCIM resource type called Agent, with five attributes, at a new /Agents endpoint. That's the whole document. Ten pages, and about half of that is JSON examples.

The problem it's solving

Some services will refuse to let an agent touch anything unless the agent has a record in that service. Today the only way to create that record over SCIM is to lie and call the agent a User.

That works until it doesn't. A User resource wants a job title, a name, and an email address. An agent doesn't have those. It has an owner, and it either is or isn't allowed to run.

So the draft carves out a separate resource type. It deliberately does not define what an agent is, what it can do, or how it proves who it is. It defines a record that is provably not a person.

How it fits with the rest of SCIM

This is the lightest possible footprint. Four normative references: RFC 7643, RFC 7644, JSON, and BCP 14. No OAuth dependencies at all.

No new roles. It's still a SCIM client talking to a SCIM service provider, using the same protocol, the same endpoints, the same lifecycle operations. Nothing about the relationship between the two parties changes. For a spec introducing a new class of principal, that's a strong signal.

It touches existing work in exactly one place. Section 4.4 extends RFC 7643's Group members attribute so a group can contain an Agent. That's what makes the whole thing useful: once agents can be group members, every existing access control system that reads group membership starts working for agents with no changes.

Is it in charter? Not cleanly. The SCIM charter says the WG will "consider publishing extensions to SCIM that have found broad adoption," and lists specific work items. Agents aren't on that list, and the charter was written before this wave of work. Nothing here is a stretch technically, but the WG needs to decide whether it's chartered to do it. That's a chair question, not a criticism of the draft.

One process problem is real. The intended status is Informational, but the document registers an IANA URN, uses REQUIRED and MUST throughout, and modifies an attribute definition in RFC 7643. You can't update a Standards Track RFC's schema from an Informational document with a bullet list and no Updates: 7643 header. Either the status changes or Section 4.4 gets reframed.

What's actually in it

Five attributes.

  • active — boolean, REQUIRED. The off switch.
  • displayName — REQUIRED. Human-readable.
  • agentUserName — REQUIRED. Unique identifier, the agent's answer to userName.
  • description — optional free text.
  • owners — multi-valued, optional. References the id of a User, Group, or another Agent.

That's the whole schema. Then the Group members change so agents can be group members.

The interesting part is what got cut. The predecessor draft, draft-wahl-scim-agent-schema, had entitlements, groups, roles, agenticApplicationId, and an oAuthClientIdentifiers attribute carrying issuer, subject, client_id, and audience for token exchange. It also had a full section on CRUD operations. All of that is gone, the resource type was renamed from AgenticIdentity to Agent, and three co-authors from Microsoft, Okta, and Nextident were added.

This is a deliberate minimalist reboot by a cross-vendor author team. That's the most encouraging thing about it.

Interoperability concerns

The small surface area means implementations are likely to agree on the basics. The problems are in the corners.

active doesn't mean anything specific. It's REQUIRED, and then the text says "the definitive meaning of this attribute is determined by the SCIM service." RFC 7643 has the same hedge for User.active, so this is inherited, not invented. But it matters more for agents. Picture an incident response playbook that sets active: false across every service an agent touches. One service revokes the agent's tokens in seconds. Another just hides it from an admin UI while the agent keeps calling APIs. The client sent the same request to both and has no way to tell the difference. If there's one place this draft should get more prescriptive, it's here.

Nobody knows whether agentUserName shares a namespace with userName. The prose says it MUST be unique "across all Agent resources in the provisioning domain." The schema says uniqueness: server. Neither says whether a User named tour-guide-agent and an Agent named tour-guide-agent can coexist. Some implementations will allow it, some won't, and downstream systems that resolve a name to a principal will get collisions. "Provisioning domain" is also not a term RFC 7643 defines.

Owners can't be changed. owners.value has mutability immutable and $ref is readOnly. The owner is a User resource, and that user will eventually leave the company and get deprovisioned. Now you have an agent whose accountability anchor points at a deleted record, and the only fix is to delete the agent and recreate it. Every enterprise deploying this will hit that within a year. Ownership transfer is table stakes for anything with a lifecycle.

Agents can own agents, and nothing has to terminate at a human. The $ref referenceTypes list includes Agent. There's no text about cycles, no text about depth, and no requirement that an ownership chain resolve to a person or group. If owners is the accountability mechanism, a chain of agents owning each other defeats it.

owners is optional. Each value must have a value sub-attribute, but the attribute itself is not required, so a conformant Agent resource can have zero owners. That's the one attribute that makes agent records governable, and it's the one you're allowed to skip.

The abstract promises more than the schema delivers. It says the schema establishes an identity "so that an agent can subsequently be authenticated and authorized." There is nothing in the resource that binds it to a credential. The predecessor had oAuthClientIdentifiers for exactly this, and removing it widened the gap. Keeping authentication out of scope is the right call, the same way OAuth core leaves user authentication out. But then the abstract needs to stop claiming it. Either add a hook for credential binding or say plainly that binding is out of scope and point at where it happens.

Mechanisms that could be removed

Not much, which is the point.

description carries no interoperability weight. No client behavior depends on it and any implementation can put anything in it. It matches User schema conventions, so it's cheap to keep, but it's the one attribute that could go without anyone noticing.

The Section 4.3 examples run five pages. The /Schemas output is mechanically derivable from the attribute definitions in 4.1 and 4.2. SCIM specs traditionally include it, so this is a judgment call, but the document would read better with the ResourceType and instance examples and a shorter schema dump.

Writing quality

Clean, and it reads like RFC 7643 on purpose. Sentences are well formed. The structure follows SCIM conventions closely enough that a reader who knows 7643 can absorb this in ten minutes. That's not surprising given Mark Wahl wrote the LDAP schema RFCs this whole lineage descends from.

Terminology wobbles. The prose says "agentic identity" throughout Section 4.1 while the JSON schema descriptions say "agent," and the resource type is Agent. Pick one.

Section 5 is two sentences plus inherited privacy text. That's thin for a document creating a new class of non-human principal that can be dropped into groups. Missing at minimum: what happens when an agent inherits privilege through group membership, why the owner reference is the accountability anchor and what breaks when it dangles, and the agents-owning-agents case.

There are no informative references at all. For a document introducing agents into SCIM, not acknowledging any of the surrounding work in OAuth or WIMSE leaves the reader with no map of where authentication and authorization actually happen.

The length is right. Ten pages for five attributes is appropriately concise, and the brevity is the document's main argument for itself.

One thing the WG should notice

There's already an extension written against this draft. draft-kushwaha-scim-agent-governance-00 adds lifecycleState, autonomyLevel, validFrom/validTo, and credentialDiscoveryUri on top of the Agent resource type, and cites this draft by name in its abstract.

So people are building on an unadopted individual submission. If the WG wants a say in the shape of the base resource type, the window for that is now, not after three extensions have shipped against it.

Authors

Four authors, two vendors plus one startup.

Mark Wahl (Microsoft) has 14 RFCs, all from the LDAP and directory era between 1997 and 2004, including LDAPv3 itself. Thirty-two expired drafts. Not remotely a new author. He also wrote the predecessor draft-wahl-scim-agent-schema, which expired in February.

Danny Zollner (Okta) has one RFC, RFC 9865 on SCIM cursor-based pagination, published October 2025. Four active drafts, all SCIM. He's one of the most active current contributors to the working group.

Pamela Dingle (Microsoft) has no RFCs yet and three active drafts spanning SPICE, OAuth, and SCIM. Well established in the identity industry, newer as an IETF author.

Ismael Kazzouzi (Nextident) has no RFCs, one active draft, no expired drafts. New to IETF authorship.

The mix matters here. A schema only works if both the client side and the service side implement it the same way, and this one has authors on both sides of that line.