---
url: 'https://www.corbado.com/blog/ai-agent-login-delegation'
title: 'AI Agent Login: Delegation instead of Impersonation'
description: 'AI agents now log in to websites on behalf of users. Why blocking or shared passwords fail and how delegated agent sessions work in practice.'
lang: 'en'
author: 'Vincent Delitz'
date: '2026-11-19T18:26:52.162Z'
lastModified: '2026-11-19T19:46:52.912Z'
keywords: 'ai agent login, ai agent authentication, ai agent sign in on behalf of user, agent delegation, agent impersonation, personal agent protocol, computer use agent login'
category: 'Passkeys Strategy'
---

# AI Agent Login: Delegation instead of Impersonation

## Key Facts

- **Personal agents use your website, not only your API:** agent browsers and computer use
  agents click through the same pages as humans. Sooner or later they reach the login form.
  Terminal agents skip the website and call APIs or MCP servers instead.
- **Blocking and looking away both fail:** blocking turns away customers who want to buy.
  Letting agents log in with the user's password or session hands over a credential,
  removes any authorization limit and leaves no record of who acted.
- **Delegation is the third option:** the user authenticates once in their own browser and
  grants the agent a scoped, time-limited session. Every token then carries both the user
  and the agent.
- **Standards are forming fast:** OAuth token exchange already has an `act` claim for the
  acting party. The Personal Agent Protocol (Poppy) from Sierra and Meta reached version 1.0
  in November 2026 and adds discovery and agent sessions across website and API.

## 1. Introduction

A user asks a personal agent to book a flight. The agent opens the airline's website in its
own browser, searches, picks a flight and then hits the login box.

What happens next in most of today's demos is simple. The agent asks for the user's password
and promises to store it securely. The user hands it over because they want the flight
booked. From then on the website sees the agent as the user, with no way to tell the
difference.

This article covers why that happens, why the two common reactions do not work and how
delegated agent logins work in practice. The [passkey](https://www.corbado.com/glossary/passkey) side of the
topic (why a passkey cannot and should not be handed to an agent) is covered in our article
on [AI agents and passkeys](https://www.corbado.com/blog/ai-agents-passkeys).

## 2. Why Agents end up at your Login Form

The clean way for an agent to act for a user is an API with [OAuth](https://www.corbado.com/glossary/oauth2).
Most companies do not expose their full customer journey that way and they will not do so
quickly. Personal agents therefore ship with a browser or take over the user's computer and
use the website like a person would.

### 2.1 Agent Browsers, Computer Use Agents and Terminal Agents

Three kinds of agents now reach consumer accounts:

| Agent type | Examples | How it meets your login |
|---|---|---|
| Agent browser | [ChatGPT Atlas](https://www.corbado.com/blog/chatgpt-atlas-passkeys) in agent mode | Runs a browser session for the agent and reaches the login form like any other visitor |
| Computer use agent | [Codex Computer Use](https://learn.chatgpt.com/docs/computer-use) on macOS and Windows, [Claude in Chrome](https://support.claude.com/en/articles/12902428-use-claude-in-chrome-safely) | Operates the user's own desktop or browser and works on pages where the user is already signed in |
| Terminal agent | [Claude Code](https://code.claude.com/docs/en/mcp), [Codex CLI](https://learn.chatgpt.com/docs/extend/mcp?set=cli) | Skips the website and calls APIs or MCP servers directly. Signs in through an OAuth flow in the user's browser or uses an API key or token the user configures |

The second type matters for CIAM teams because it bypasses the login form entirely. OpenAI's
documentation for Codex Computer Use says it "can interact with pages where you're already
signed in" and advises users to stay present for account and credential-related steps.
Anthropic recommends running Claude in Chrome in a separate browser profile without access
to sensitive accounts. To the website, these sessions look
like the user.

The third type is closest to the clean path. When a terminal agent connects to a remote MCP
server, Claude Code and Codex CLI both start an OAuth login that opens in the user's
browser and store the resulting tokens for later calls. The user signs in on the company's
own login page and the agent receives a token instead of a password. The weak spot is the
alternative many users choose for convenience: pasting a long-lived API key or personal
access token into the agent's configuration. That is a credential handover that often has
no expiry and never has an agent-specific scope.

### 2.2 What changes for the Website

Security vendors report that early adopters no longer visit airline or hotel websites
themselves and that even small business owners without a technical background now run
several agents for sourcing, accounting or social media. Customers will increasingly send
agents instead of coming themselves and those agents will come more often than the user
ever did.

For a CIAM team, three things follow from that:

- **The login form becomes an agent interface:** everything built for humans, from
  CAPTCHAs to [MFA](https://www.corbado.com/blog/mandating-mfa) prompts and session timeouts, now also meets
  software.
- **Volume changes:** one customer can generate the traffic of thousands of sessions.
  Identity systems are designed to authenticate individual users, not thousands of parallel
  sessions acting for the same person.
- **Behavioural assumptions break:** agents are not lazy and not loyal. They compare offers,
  switch providers when the data says so and do not respond to branding. Fraud and
  conversion models trained on human behaviour lose their footing.

## 3. Three Ways to handle an Agent at the Login

### 3.1 Block the Agent

Some companies try to detect and block agent traffic. It is an arms race and it is getting
harder: the systems built to stop bots, for example during limited product drops, are
easier for agents to get around because agents are smarter than the bots they replace. Even
when blocking works, it turns away a customer who was ready to pay.

### 3.2 Look away: Impersonation

The default today is impersonation. It comes in two forms: the user gives the agent their
password or the agent works inside a browser where the user is already signed in. Either
way the agent acts as the user. That creates three problems:

1. **Security:** the user's credential or session now sits with the agent and can be used
   whenever the agent decides to, beyond the task the user had in mind.
2. **Authorization:** the website cannot apply agent-specific limits, so the agent can do
   everything the user can, including changing the email address or payment details.
3. **Audit and liability:** when a dispute comes in, there is no record of whether the user
   or the agent acted.

### 3.3 Delegate

The third option is delegation. A hotel makes the difference clear. Impersonation is giving
your assistant a copy of your room key: the hotel thinks the assistant is you, the assistant
can open every door you can and nobody knows who opened what. Delegation is asking the front
desk for a guest card in your assistant's name, valid for your room only and only for
tonight, with every door it opens logged.

The OAuth standard for token exchange draws the same line.
[RFC 8693, section 1.1](https://www.rfc-editor.org/rfc/rfc8693.html#section-1.1) defines
impersonation as an actor that receives all the rights of the subject and cannot be told
apart from it. With delegation, the actor keeps its own identity separate from the user's.

## 4. How Delegation works for Website Logins

Delegation is well understood for APIs. For web browsing, which is where agents actually
show up, the pattern has three steps:

```mermaid
sequenceDiagram
    autonumber
    actor U as User
    participant UB as User's Browser
    participant A as AI Agent
    participant IdP as Company Login (IdP)
    participant W as Company Website
    A->>IdP: Connect (for example via MCP), OAuth authorization request
    IdP->>UB: Normal login page in the user's own browser
    U->>UB: Authenticate with a strong method (for example a passkey)
    IdP->>UB: Consent screen names the agent and allowed actions
    U->>UB: Approves the agent
    IdP->>A: Tokens (sub = user, act = agent, limited scope)
    A->>IdP: Token exchange for a single-use session transfer token
    IdP->>A: One-time login link (valid for about one minute)
    A->>W: Agent browser opens the link
    W->>A: Web session that knows the user and the agent
```

1. **The user authenticates in their own browser:** the agent connects to the company,
   for example through an MCP server. The
   [MCP authorization specification](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization)
   builds on OAuth 2.1 with PKCE, so the user signs in on the company's normal login page in
   their own browser, not in the agent's. Because this happens once, it can use the strongest
   method available, such as a passkey. The user then sees a consent screen that names the
   agent and the actions it may take.
2. **The agent receives a one-time link:** the agent exchanges its token at the company's login
   service for a short-lived session transfer token. In
   [Auth0's implementation](https://auth0.com/docs/authenticate/single-sign-on/native-to-web/configure-implement-native-to-web)
   this token is single-use, expires after one minute and is passed to the login endpoint
   as a URL parameter or cookie.
3. **The agent opens a session that carries two identities:** when the agent's browser
   opens the link, the website creates a session that knows both the user and the agent.

In the tokens, the user stays the subject and the agent is recorded as the actor, using the
`act` claim from
[RFC 8693, section 4.1](https://www.rfc-editor.org/rfc/rfc8693.html#section-4.1). The
granted permissions go into the `scope` claim
([section 4.2](https://www.rfc-editor.org/rfc/rfc8693.html#section-4.2)):

```json
{
  "sub": "user-12345",
  "act": {
    "sub": "agent:personal-assistant-7f3a"
  },
  "scope": "flights:search flights:book",
  "exp": 1795075200
}
```

[Auth0's Session Delegation](https://auth0.com/docs/authenticate/single-sign-on/session-delegation)
follows this pattern for support staff acting for a user and the same mechanics apply to
agents: the resulting access and ID tokens carry an `act` claim, no refresh
tokens are issued and the exchange fails with `interaction_required` when MFA or consent
would be needed. That last point keeps the human in the loop by design.

With two identities in the session, the website can apply different rules to agent
sessions, for example allowing a booking but not a change of payment details. For high-risk
steps it can still bring the human back in. The OpenID standard for this is
[Client-Initiated Backchannel Authentication (CIBA)](https://openid.net/specs/openid-client-initiated-backchannel-authentication-core-1_0.html):
the website asks the identity provider to send an approval request to the user's own
device and continues only when the user confirms.

Three recommendations follow:

- **Accept agents:** customers will use agents with or without your permission.
- **Name both parties:** put the user and the agent identity in your ID and access tokens.
- **Keep the record:** store that information for later audits and disputes.

## 5. Standards for Agent Logins

Several standards now address parts of the problem:

| Standard | What it adds | Status (Nov 2026) |
|---|---|---|
| [OAuth 2.0 Token Exchange (RFC 8693)](https://www.rfc-editor.org/rfc/rfc8693.html) | Exchanging a user token for one that names the acting party (`act` claim) | Published RFC, widely supported by identity providers |
| [MCP authorization](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization) | OAuth 2.1 based authorization when agents call a company's tools through MCP | Part of the MCP specification (version 2026-07-28) |
| [OpenID CIBA](https://openid.net/specs/openid-client-initiated-backchannel-authentication-core-1_0.html) | Approval of a single action on the user's own device | Final specification since 2021 |
| [Identity Assertion JWT Authorization Grant](https://datatracker.ietf.org/doc/draft-ietf-oauth-identity-assertion-authz-grant/) | Agent access across enterprise apps based on the user's SSO identity | IETF draft, mainly for workforce scenarios |
| [Personal Agent Protocol (Poppy)](https://personalagentprotocol.org/) | Discovery file at `/.well-known/poppy.json`, guest and signed-in agent sessions across website, APIs and the company's own agent | Announced by Sierra and Meta in October 2026, [version 1.0 released](https://sierra.ai/blog/releasing-poppy) on 13 November 2026 |

Poppy is the one to watch for consumer website logins. It describes how a company tells
agents where customers sign in, which actions an agent may take and how an agent can start a
session as a guest (to check stock or a returns policy) or as a signed-in customer through
OAuth. A retailer could, for example, let an agent start a return but not change the card
on file. Version 1.0 is enabled for Shopify merchants and identity providers have started to
add support: Auth0 announced a
[beta program for personal agents](https://auth0.com/blog/auth-for-personal-agents-beta-release/)
in November 2026 in which APIs see both the user and the agent.

## 6. What changes for CIAM Teams

The practical consequences for CIAM teams fall into four points:

- **Know the actor, prove the authority:** a bank or retailer must be able to tell whether
  a customer, a third party or an agent is acting, prove that the customer delegated the
  action and control what the actor does. A company can delegate actions, not
  accountability.
- **Every agent needs an owner:** an agent without a responsible human or organisation
  behind it should not exist in a governed environment.
- **Visibility comes first:** external agents are only visible when they reach your
  boundary, with no model to predict what they will do. Measuring what reaches your login
  is the starting point.
- **The security bar does not drop:** the situation resembles building a motorway while the
  cars are already driving. Closing it is not an option, so the work is adding guardrails
  and speed limits.

## 7. Where Passkeys fit

A passkey cannot be handed to an agent. It requires a user gesture on the user's device and
that is a feature: it rules out the password handover from section 1. In a delegated flow
the passkey belongs in step one, where the user proves who they are before granting the
agent access. It also belongs in step-ups for high-risk actions. Our article on
[AI agents and passkeys](https://www.corbado.com/blog/ai-agents-passkeys) covers this pattern in detail, including
OAuth scopes and human-in-the-loop confirmation.

## 8. How Corbado can help

Before you decide how to treat agents at your login, you need to see what your login
already does when agent browsers start using it.
[Corbado Observe](https://www.corbado.com/observe), the
[authentication observability layer](https://www.corbado.com/blog/authentication-observability), measures every
login flow on your existing stack, including the ones that fail.

[Video: Login funnel](https://www.corbado.com/videos/features/login-funnel.mp4) ([See Login Funnel in Corbado Observe](https://www.corbado.com/observe/login-funnel))

- **Login funnel:** follow each step of the login and see where flows stop, so a change in
  completion after a new agent browser appears shows up as a drop in a specific step.
- **Breakdown by environment:** compare login flows by operating system, version and
  browser to see whether a new client behaves differently from the rest of your traffic.
- **Passkey Errors:** see which errors a client produces when it reaches a passkey or
  step-up prompt it cannot complete.

## 9. Conclusion

Agents already log in to websites for their users, mostly with a shared password or the
user's own signed-in browser. Blocking them loses customers and ignoring them loses
control. Delegation keeps both: the user authenticates once with a strong method, the agent
gets a limited session in its own name and every action can be traced back to both.

The building blocks exist today in OAuth token exchange and the `act` claim. The Personal
Agent Protocol is turning them into a common way for companies to describe how agents may
sign in. Teams that start by measuring how their login handles agent traffic will be in a
better position to decide which of these to adopt.

## Frequently Asked Questions

### How can a website tell whether a user or an AI agent is acting in a session?

Use delegated tokens in which the user stays the subject and the agent is named in the act claim from RFC 8693, section 4.1. With both identities in the ID and access tokens, the website can apply agent-specific rules, for example allowing a flight booking but blocking a change of payment details.

### How does an AI agent get a logged-in web session without the user's password?

The user signs in once on the company's normal login page in their own browser and consents to the agent. The agent then exchanges its token at the company's login service for a single-use session transfer token and receives a one-time link that opens a session for user and agent. In Auth0's implementation this token expires after one minute.

### What is the Personal Agent Protocol (Poppy)?

Poppy is a protocol from Sierra and Meta that tells agents where customers sign in and which actions they may take, through a discovery file at /.well-known/poppy.json. Agents can start guest or signed-in sessions across website, APIs and the company's own agent. Version 1.0 was released on 13 November 2026.

### Why do computer use agents like Codex Computer Use bypass the login form?

Computer use agents operate the user's own desktop or browser and work on pages where the user is already signed in. The website only sees the user's existing session and cannot tell that an agent is acting. That makes it a form of impersonation with no agent-specific limits and no audit trail.

### How can a website ask the user to approve a high-risk action taken by an AI agent?

Use OpenID Connect Client-Initiated Backchannel Authentication (CIBA). The website asks the identity provider to send an approval request to the user's own device and continues only after the user confirms, for example with a passkey. Auth0's Session Delegation also fails with interaction_required when MFA or consent would be needed, which keeps the human in the loop.
