FreeNew: the 58-page Authentication Analytics Whitepaper on the 10 login KPIs that matterDownload
Back to Overview

AI Agent Login: Delegation instead of Impersonation

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.

Vincent Delitz
Vincent Delitz

Created: November 19, 2026

Updated: November 19, 2026

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.

Enterprise Icon

Get free passkey whitepaper for enterprises.

Get for free

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 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.

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. 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 typeExamplesHow it meets your login
Agent browserChatGPT Atlas in agent modeRuns a browser session for the agent and reaches the login form like any other visitor
Computer use agentCodex Computer Use on macOS and Windows, Claude in ChromeOperates the user's own desktop or browser and works on pages where the user is already signed in
Terminal agentClaude Code, Codex CLISkips 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 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 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.

Substack Icon

Subscribe to our Passkeys Substack for the latest news.

Subscribe

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:

  1. The user authenticates in their own browser: the agent connects to the company, for example through an MCP server. The MCP authorization specification 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 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. The granted permissions go into the scope claim (section 4.2):

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

Auth0's 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): 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.
Igor Gjorgjioski Testimonial

Igor Gjorgjioski

Senior Product Lead, VicRoads

We hit 80% mobile passkey activation across 5M+ users without replacing our IDP.

See how VicRoads scaled passkeys to 5M+ users, alongside their existing IDP.

Read the case study

5. Standards for Agent Logins#

Several standards now address parts of the problem:

StandardWhat it addsStatus (Nov 2026)
OAuth 2.0 Token Exchange (RFC 8693)Exchanging a user token for one that names the acting party (act claim)Published RFC, widely supported by identity providers
MCP authorizationOAuth 2.1 based authorization when agents call a company's tools through MCPPart of the MCP specification (version 2026-07-28)
OpenID CIBAApproval of a single action on the user's own deviceFinal specification since 2021
Identity Assertion JWT Authorization GrantAgent access across enterprise apps based on the user's SSO identityIETF draft, mainly for workforce scenarios
Personal Agent Protocol (Poppy)Discovery file at /.well-known/poppy.json, guest and signed-in agent sessions across website, APIs and the company's own agentAnnounced by Sierra and Meta in October 2026, version 1.0 released 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 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.
WhitepaperEnterprise Icon

Enterprise Passkey Whitepaper. Practical guidance, rollout patterns and KPIs for passkey programs.

Get Whitepaper

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 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, the authentication observability layer, measures every login flow on your existing stack, including the ones that fail.

See Login Funnel in Corbado Observe →
  • 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.

Corbado

About Corbado

Corbado is the Passkey Intelligence Platform for large-scale CIAM teams running consumer authentication. We help you see what IDP logs and generic analytics tools can't: where passkeys, passwords, OTP, social login and fallback journeys succeed, stall or fail, which devices and browsers create friction, and when an OS update silently breaks login. Two products: Corbado Observe layers process mining and observability across authentication journeys. Corbado Connect adds managed passkeys with analytics built in alongside your IDP. VicRoads runs passkeys for 5M+ users with Corbado (more than 80% passkey activation rate). Talk to a Passkey Expert →

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.

See what's really happening in your passkey rollout.

Book a Demo

Share this article


LinkedInTwitterFacebook