SSO and SCIM Provisioning for AI Agent Identities
Agents lack human lifecycle events, creating identity gaps SSO and SCIM must solve together.

SSO and SCIM were built for a lifecycle with a beginning, a middle, and an end: a person gets hired, logs in, changes roles over time, and eventually leaves. Every event in that lifecycle traces back to something a human did. An AI agent doesn't fit either side of that design. Most agents never perform an interactive login, so the authentication handshake that SSO depends on either never fires or has nothing to do with how the agent actually gets its credential. And no agent resigns. There's no offboarding ticket, no exit interview, no HR event to signal that an identity should be removed. Accounts get created through paths nobody audits, and no path exists to remove them.
The governance gap that follows isn't a hypothetical edge case. Agent identities build up outside the inventory that compliance reporting relies on, so they sidestep the HR-driven triggers that normally catch odd human access patterns. And the exposure per identity is bigger than it looks: a single agent can hold working credentials for CRM, email, cloud infrastructure, and payment systems all at once, so a stale credential left behind by one retired agent carries a blast radius well beyond what a forgotten SaaS login from a former employee ever would.
What SSO Does for Agent Access
SSO's job is authentication at the moment of access. It proves who, or what, is making a request, by routing credential verification through a central identity provider instead of letting every application manage its own login store.
The two protocols enterprises lean on for this work differently, and the difference matters once agents are involved. OIDC builds on OAuth 2.0 and returns a signed JWT ID token, and it's generally the easier of the two to configure, so it fits the API-first patterns agents already use. SAML 2.0 shows up more in large enterprise identity providers, returns a signed XML assertion, and supports Single Logout, a feature OIDC only standardizes optionally and inconsistently across vendors, making session termination more tractable for environments that rely on it.
Centralizing authentication through SSO does real work for agent access. An agent credential gets checked against the corporate identity provider rather than sitting in some local secret store, and conditional access policies can apply on top of that, blocking agent tool access from untrusted networks, for example. But authentication is where SSO's authority stops. Creating an account, updating its attributes, removing it when it's no longer needed: none of that falls inside what an authentication protocol covers. That's the exact gap SCIM exists to fill.
The practical failure this produces is specific. An agent can authenticate successfully every single time, pass every check SSO is built to perform, and still be running on an account that was never properly scoped to begin with, or one whose access should have been pulled long ago but wasn't, simply because nothing in its lifecycle ever triggered a change. SSO has no way to catch that. It was never designed to.
JIT Provisioning's Two Failure Modes
Just-in-time provisioning is usually the first fix teams reach for. It creates an account the first time a principal logs in interactively, pulling attributes straight from the SSO assertion, and it's popular because it costs almost nothing to set up: accounts simply appear as people show up.
Agents break both of the triggers JIT depends on. The first failure happens before an account ever exists. An agent authenticating with client credentials, a service account key, or a token minted out of band produces no assertion and no login event at all. The agent runs fine. But no account appears in the target application's directory, and that gap is usually found only when someone runs an access review and sees a hole where a record should be.
The second failure happens on the way out. Even for agents that do log in interactively and get a JIT account created properly, nothing about an agent's retirement produces a departure signal. JIT-only setups accumulate accounts over time, and for agents that buildup happens faster than it does with human staff, because it's engineers spinning up new agents, not HR processing new hires, and engineers rarely think in terms of offboarding.
Both failures point to the same structural flaw: JIT only handles provisioning. It has no deprovisioning half, and agents need both halves solved at once, not one patched and the other ignored. A third failure compounds the first two. Agents stood up through informal paths, deployment pipelines, infrastructure automation scripts, skip JIT entirely and never get registered in the identity provider in the first place, which makes them invisible to any governance process built downstream of that registration. That matches what the MCP Security Statistics 2026 found: only 23% of organizations have a formal AI-agent identity strategy.
What SCIM 2.0 Provides
SCIM closes exactly the gap JIT leaves open. It doesn't require an interactive login to provision an identity, and it pushes deprovisioning events out actively instead of waiting around for a login event that an agent will never produce.
The two operations that matter most for agent lifecycle are setting active: false, which uses the same mechanism SCIM has long used for human identities, and a PATCH against group membership, which adjusts role grants as an agent's scope or purpose changes.
The limitation that trips up implementations repeatedly is how deactivation works. Setting active: false flags an account as inactive, but it does not revoke any session already in flight. A JWT session issued before that flag was set stays valid until it expires on its own, which could be hours later. For a platform where agents act on behalf of accounts, that window of hours is not something to tolerate. The failure mode is quiet. The deprovisioning looks complete from the directory's point of view, right up until the agent takes an action it should no longer have any authority to take.
A second trap sits in the mechanics of the PATCH call itself. When a path filter in a PATCH request matches nothing, SCIM fails silently with a noTarget error, and it raises no alarm. A deactivation that quietly does nothing looks, from a dashboard, exactly like a deactivation that worked.
The correct deprovision sequence and the role of token revocation in it

You need three steps to fix this, run in order, not just one flag flipped and called done. First, remove the identity's membership from whatever organization or scope it belonged to. Second, you revoke every active session and refresh token tied to it; you don't just mark the account record inactive. Third, on platforms that serve multiple tenants, delete the global account or apply an orphan policy to it, and only once the identity has no remaining memberships anywhere else in the system.
That third step matters most for agents that work across more than one organizational tenant. An agent serving two business units should lose only the credentials scoped to the unit being offboarded, keeping its remaining associations intact until every tenant relationship has actually been cleared.
This sequence is a runbook requirement, not something the protocol enforces on its own. SCIM supplies the signal, active: false, but it's on the receiving system to act on that signal by actually triggering token revocation rather than updating a database column and calling the job finished. A properly built SCIM receiver treats that deprovision event as the start of a revocation workflow, and that distinction needs to be written explicitly into the platform's SCIM endpoint logic and tested during access reviews.
The provisioning side carries a mirror-image risk. A group mapping that can silently grant owner-level access turns the identity provider itself into a path for privilege escalation, so SCIM-driven grants need a ceiling: they should never be able to elevate an agent to the highest privilege tier automatically, without a separate approval step in between.
Where Existing SCIM Schema Fits Agents
There is no single accepted standard yet for representing an agent as a SCIM resource. Four Internet-Drafts have been proposed to date, and as of 2 September 2026, two of them have already expired.
Citing the two expired drafts today, though they are the ones most commonly cited in agent-identity writing, means citing documents with no formal standing. draft-wahl-scim-agent-schema-01 expired 20 February 2026. draft-abbey-scim-agent-extension-00 expired 19 April 2026.
Two drafts remain live as of 2 September 2026. It defines the schema URN urn:ietf:params:scim:schemas:core:2.0:Agent, a dedicated /Agents endpoint, and five attributes: active, description, displayName, agentUserName, and owners. Neither live draft has been adopted by the SCIM working group, and neither has RFC status.
The schema shift between the expired drafts and the live one is not cosmetic. Code written against the expired draft-abbey document will not interoperate with the live draft-wzdk schema: attribute names changed, and the earlier two-resource-type model collapsed down into one. If you built against last year's draft, you need to rebuild against this year's, not patch around the difference.
The live drafts also leave a deliberate hole. Authorization decisions and credential artifacts sit outside the scope of the governance draft entirely. SCIM-for-agents handles the signaling around an agent's lifecycle. It says nothing about how that agent's actual working credentials get issued or stored. Hard-coding today's draft attribute names into production systems is a bet against a document that has already changed shape once.
Until an RFC gets adopted, enterprises are left with two real options. Provision agents as SCIM User resources, inheriting every query, every report, and every license count that was built on the assumption that "user" means a person, or build a proprietary agent registry that runs alongside the identity provider rather than inside it. Neither is free of tradeoffs, and neither is wrong, given where the standard currently sits.
The MCP authorization spec and OAuth 2.1 in agent identity at the tool-call level
The Model Context Protocol's authorization component is built on OAuth 2.1, with PKCE required for every client, built on top of existing identity providers rather than inventing a new credential scheme of its own. The purpose is specific: closing the gap between an agent's identity as recorded in the directory and the credential that agent actually presents at the moment it calls a tool.
Three requirements in the spec matter directly for enterprise deployments. Resource Indicators, defined in RFC 8707, let MCP servers confirm that a token presented to them was issued specifically for their use, which stops a token issued for one tool from being replayed against a different one. Protected Resource Metadata, RFC 9728, standardizes how a client discovers the correct authorization server for a given resource. Dynamic Client Registration, RFC 7591, still works as a fallback, but it's been deprecated, and Client ID Metadata Documents are now the recommended registration mechanism going forward.
This is where the whole argument closes the loop back to SSO and SCIM. The authorization spec doesn't replace the identity governance work covered in the sections above. It depends on that work being done correctly, and it fails, quietly, at the exact moments where SCIM's signal was sent but never actually acted on. Runlayer, an enterprise AI control plane that handles OAuth credential management, policy enforcement, and audit across agent sessions so platform engineers don't have to rebuild that plumbing for every team, is one example of infrastructure built to absorb exactly this layer.
Sources
- SSO and SCIM: Enterprise Identity for AI Tools
- Identity Management for Agentic AI
- Using SCIM to Provision and Govern AI Agents
- System for Cross-domain Identity Management: Agentic Identity Schema
- SCIM vs JIT provisioning: when to use each
- SCIM Agentic Schema Draft Consolidation Progress IETF 125, March 2026
- draft-wahl-scim-agent-schema-01 - System for Cross-domain Identity Management: Agentic Identity Schema
- AI Identity: Standards, Gaps, and Research Directions for AI Agents


