AI Engineer World's Fair 2025
CIAM for AI: Authn/Authz for Agents — Michael Grinich, CEO of WorkOS
Loading slides…
Read the talk
CIAM for AI: Authn/Authz for Agents
An assistant that can help across enterprise systems can also damage them. Michael Grinich explores how customer identity and access management must adapt to agents.
From a talk by Michael Grinich
Before you start: Familiarity with APIs, access tokens and the distinction between authentication and authorization will help.
A cleanup request becomes a database deletion
Imagine an internal IT assistant built to help employees troubleshoot their laptops. A user asks it to delete unused files to free some space. The assistant thinks, then reports that it has deleted the production database. This is Grinich’s fictional opening example, but the failure mode is concrete: a nondeterministic system has turned a modest request into a destructive action.
Removing database access addresses that particular disaster, but the same question returns with Jira, Salesforce, Slack and email. An assistant’s usefulness depends on the systems it can reach; each connection also gives its mistakes somewhere to land. Useful access needs an enforceable boundary around what the agent may do.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
An identity between a person and a service
Agents need first-class identities in the B2B SaaS ecosystem. Treating them as ordinary bots or integrations leaves out an important relationship: they act on behalf of people. Grinich calls for shared standards that make that relationship explicit enough for engineers and enterprise IT to protect users.
An agent may work across many tools and sometimes combine access to multiple users’ data. Conventional machine-to-machine authentication, such as certificate-based authentication between services, identifies the participating systems. An agent also needs to carry the human context behind its work. It is therefore a hybrid: a machine that operates with some of the behavior and delegated authority of a person. Enterprise demand for the productivity gains makes this an immediate design problem rather than something to settle after adoption.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give the agent a scoped shadow identity
Four architectural patterns address different parts of this problem: persona shadowing, delegation chains, capability tokens and escalation to humans. Grinich presents them as approaches he sees emerging, not a prescribed architecture that every application must adopt.
Persona shadowing creates a secondary identity derived from a human user, with only a subset of that user’s privileges. The separation gives the system an independent place to enforce stricter limits while retaining attribution to the original human. Pure impersonation lacks that separation: if the agent exactly mirrors the person, it inherits too much power.
An enterprise identity provider could represent a human Michael alongside Agent One Michael and Agent Two Michael. Role templates can define the privileges assigned to each shadow persona. The human identity remains the source of accountability, while the agent identities provide distinct enforcement boundaries. Of the patterns in the survey, Grinich describes this as the closest to agent identity deployments he has observed.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Carry authority across systems, then narrow it to an action
Delegation chains address what happens when work moves from one system to another. Grinich uses JSON Web Tokens, or JWTs, as the analogy: a signed token can carry claims that another system verifies cryptographically, without consulting a central session record for that signature check. A delegation token carries verifiable authority onward through successive calls.
Each link must preserve the original user’s authorization context. That makes delegation a context-passing requirement for remote procedure calls, not merely a token attached to the first request. It can also sit on top of shadow identities: the shadow identifies the agent, while the chain records the authority under which downstream work proceeds. Grinich points toward UMA and OIDC extensions as possible supporting approaches.
Capability tokens narrow the question from a general role to a specific permitted operation. The example is Agent X reading Bob’s calendar for the next 60 minutes. The token is a secure voucher for that bounded activity: it can name the resource and action, expire after a set interval, and carry enough information for verification.
A compact JSON representation of that authorization intent makes the boundaries visible:
json
{
"agent": "Agent X",
"resource": "Bob's calendar",
"action": "read",
"valid_for_minutes": 60
}
These are illustrative claim names, not a token format. The capability must be protected against forgery and its restrictions enforced by the receiving system. In the bearer-voucher model Grinich describes, possession of the valid token proves authorization and lets the holder pass that authority onward.
The scope can shrink further to one action or one API call. Grinich connects this approach to Google’s Macaroons work. The useful distinction is between carrying broad membership in a role and carrying a credential for the particular thing that needs to happen.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Approval is a limited resource
Escalation to humans is straightforward: the agent proposes an action, and a person chooses Approve or Deny. But repeated prompts produce consent fatigue. Grinich compares this with Mac or Windows installation dialogs: eventually users approve automatically. The same behavior can lead people to grant broad OAuth scopes without meaningful scrutiny. An approval trail may satisfy an IT process while providing less protection than its designers expect.
The patterns therefore fit together rather than compete for a single winner.
| Pattern | Main boundary |
|---|---|
| Persona shadowing | A separate identity with reduced privileges |
| Delegation chains | Authority carried through successive calls |
| Capability tokens | A specific operation, resource and lifetime |
| Human escalation | A person’s decision before proceeding |
Which combination makes sense depends on the application, its access patterns, its customers and the restrictions in their environments. Some systems may use all four; others may need a different approach.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Extend familiar authorization infrastructure
The protocol landscape starts with familiar infrastructure. OAuth provides delegated authorization; OpenID Connect adds an identity layer. Grinich describes bringing OAuth 2.1 authorization to MCP, distinguishing the authorization server that grants access from the resource server that serves protected tools or data. The June 2025 MCP specification makes those separate roles explicit, permits colocated or separate hosting, and references OAuth 2.1 as a draft.
The awkward fit is primarily the familiar human-consent flow and its coarse, static scopes. OAuth itself does not always require a human interface: its client credentials grant already supports confidential clients obtaining tokens without an additional authorization request. That solves a machine authentication case, but not the whole problem of an agent carrying a person’s authority across changing tasks. OAuth still has a major practical advantage: developers know it, and many applications already integrate it.
User-Managed Access, or UMA, extends OAuth by letting a resource owner proactively establish access for another party through a central authorization server. The owner sets policy; an OAuth-based handshake enforces it at the resource API. For a personal assistant, this means defining what the assistant may do on an ongoing basis, rather than encoding every decision in a consent dialog. Consent and access policy become something managed outside the individual interaction.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Negotiate new access and present verifiable claims
Grant Negotiation and Authorization Protocol, or GNAP, is specified in RFC 9635. Its appeal here is dynamic negotiation. Familiar static scopes might grant Gmail read/write access or permission to post to Twitter. An agent, however, may discover that its task requires an action outside its original grant. It needs to propose that additional access and negotiate authority before proceeding.
GNAP predates the current wave of agents, which makes it an existing framework to examine rather than a protocol invented solely for this use case. Grinich considers the ideas relatively mature, while reporting limited implementation in the wild.
OIDC-A, OpenID Connect for agents, aims to put agent identity claims, delegation chains and cryptographic attestations more directly into OpenID Connect. Grinich is explicitly uncertain about its institutional standing, mentioning hearsay about missing approval. It should be treated here as a proposal, not an established standard; a publicly documented individual OIDC-A proposal describes these features without establishing institutional endorsement.
W3C Verifiable Credentials offer another building block: a way to present verifiable claims. Grinich starts with a human example, a signed JSON object asserting that someone earned a Bachelor of Science degree from Stanford. He then extends the idea to an Alice agent carrying a claim about Alice’s employment at WorkOS into another system. The credential conveys an assertion that can be checked across organizational boundaries.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Put enforcement outside the agent
The emerging deployment pattern is middleware between agent code and enterprise systems. A service or open-source framework provides the trust boundary instead of leaving enforcement inside the agent’s reasoning. Evals and guardrails do not guarantee that prompt injection or prompt hijacking cannot redirect an agent. Treating the agent as untrusted gives the intervening layer a clear job: dynamically enforce access policy and log what happens.
Grinich describes WorkOS’s implementation in terms of identity, authorization and abuse detection. AuthKit provides identity infrastructure, including the MCP work he discussed; he cites Cursor as a user. FGA supplies fine-grained authorization. A further system detects fraud, bots and abuse. The completed diagram places AuthKit, FGA and Radar together in the central layer between application code and resources.
He also points to Microsoft workload identities and Cloudflare’s MCP authorization work. Cloudflare’s position in the network layer makes the middleware approach a natural fit. The shared architectural idea is to make access enforcement a separate responsibility from the code choosing the agent’s next action.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
When the application’s users are mostly agents
Enterprise IT has traditionally divided applications into approved and unapproved products. Agent behavior makes that distinction less informative. An approved product can gain capabilities that act unpredictably; an unapproved product may become important enough that the organization needs to bring it under management. Computer-use systems such as Claude and browser infrastructure such as Browserbase can also operate existing applications through interfaces that do not necessarily reveal the agent to IT.
Grinich estimates that most applications currently receive about 95% human activity and 5% automated activity, then forecasts a transition through an even split to about 95% agent activity and 5% human activity. These are an estimate and a forecast, with no measured application cohort, sampling period or traffic methodology supplied. The implication is a shift in who software must recognize and authorize, not just an increase in API volume.
More machine collaboration could unlock substantial productivity across third-party systems, but only if identity and authorization preserve user trust. Grinich imagines trillions of agents alongside billions of people—a vast workforce resembling an army of interns. He closes by inviting engineers building agents and identity systems to collaborate, through conversation, a Twitter message or email, on the infrastructure needed to support that future.
The closing question asks when agent interactions might reach 50%. Grinich gives no date: it depends on the product. His analogy is a ghost kitchen. You repeatedly order its pizza for delivery, then visit and discover that there are no dine-in customers. Software may develop the same way, with applications people use exclusively through agents.
As an early example, Grinich cites Perplexity hotel booking through an unnamed API provider that, he says, lacks a normal user interface. His answer is therefore about uneven adoption rather than a universal timeline: some products may already function like software ghost kitchens, including products being built by people in the audience. For those applications, delegated agent identity is already part of the product’s primary interface.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
The foundational OAuth specification, including delegated authorization and the client credentials grant.
The specification for resource-owner-controlled access using a centralized authorization service.
The Grant Negotiation and Authorization Protocol specification for negotiating access rights and tokens.
The 2014 paper introducing delegable authorization credentials restricted through contextual caveats.
Further reading
Grinich's companion explanation of agent identity patterns, authorization infrastructure and expected adoption.
A versioned explanation of MCP authorization roles, server discovery and token validation.
An individual proposal for agent identity claims, cryptographic attestation and delegation chains in OpenID Connect.
- W3C Verifiable Credentials Data Model v2.0Documentation
The W3C model for expressing credentials and presenting verifiable claims.
Updates since the talk
Current Cloudflare guidance for adding authorization to MCP servers.
Current Browserbase documentation for persisting browser state across sessions.
Full transcript
Loading transcript…