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.

A mock chat window with an empty file area and the reply, “Great idea. I went ahead and deleted ‘prod’,” followed by a smiling glasses emoji.Open full source frame
The chat assistant reports that it deleted “prod.”

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.

0:521:03
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:52 · section reference included

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.

2:002:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:00 · section reference included

Sessions, changing permissions and accountability

Authentication starts with headless login: signing in without a person typing into a browser. That does not mean every agent uses only APIs. A computer-use agent may need an authenticated session in an application’s front end, then click through the interface. Its session must survive unattended work without becoming a permanent credential. Where are credentials stored? Who refreshes them? How is persisted session state protected? Grinich raises Browserbase as a concrete setting in which those custody questions matter.

Authorization introduces a different tension. A narrowly scoped task might require sending one email or reading a limited dataset. An exploratory task might require an entire codebase, bug backlog and customer conversation history. Grinich argues that permissions fixed too narrowly in advance do not readily fit nondeterministic work: the agent can discover a legitimate need only after it begins. The requirement is dynamic authorization, with access that can change as the task develops.

Slide titled “Least Privilege,” showing a pale starburst icon connected through short horizontal bars to a purple sphere icon.Open full source frame
Least Privilege illustrated with a small stack of bars between two icons.

Accountability remains necessary after access is granted. If an agent deletes a database, the organization needs a record of which agent acted and which human it was acting for. Grinich invokes SOC 2 and human code review to ask what happens when agents review code; the useful architectural question is how responsibility survives automation, rather than assuming a universal requirement that all code receive human review.

Speed compounds the problem. Grinich jokes about computers making mistakes ten thousand times per second, then points to agents spawning other agents. That multiplication makes visibility essential: agent activity has to reach the enterprise’s logging and monitoring systems, where operators can reconstruct what happened across the resulting chain of work.

3:393:46
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:39 · section reference included

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.

6:066:17
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:06 · section reference included

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.

7:528:05
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

7:52 · section reference included

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.

PatternMain boundary
Persona shadowingA separate identity with reduced privileges
Delegation chainsAuthority carried through successive calls
Capability tokensA specific operation, resource and lifetime
Human escalationA 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.

9:419:50
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:41 · section reference included

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.

10:5011:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:50 · section reference included

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.

13:0613:16
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:06 · section reference included

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.

A logo above three stacked boxes labeled “AuthKit,” “FGA,” and “Radar,” connected horizontally to partially cropped icons on either side.Open full source frame
AuthKit, FGA, and Radar form the central layer in the diagram.

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.

15:1815:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:18 · section reference included

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.

16:4916:59
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:49 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…