November 18, 2026

AI Agent Authorization: Why Agent Protocols Build on OAuth

How Poppy, MCP, A2A and agentic commerce use OAuth to enable secure AI agent authorization, with Authlete powering the authorization layer.
Headline “Agents are new. The authorization underneath them is not.” beside a mock sign-in page at company.com/sign-in, where a personal agent asks to view bookings and change reservations, with Allow and Deny buttons. Below it, an Authorization server box reads “Powered by Authlete. Standard OAuth, running behind the company’s own sign-in.”

Agents already speak OAuth

Poppy 1.0, the Personal Agent Protocol, launched on November 13, 2026. Like MCP and the agentic commerce protocols before it, Poppy does not invent a new authorization model. Account access is standard OAuth, with a signed session layer on top that identifies the agent and a pseudonymous user.

Take a simple case. An AI agent wants to change a hotel booking on your behalf. It needs permission to access your account, but it shouldn't need your password. The booking service must know which agent is making the request, what it is allowed to do, and when that access should expire.

This is a familiar authorization problem with a new kind of client. That is why agent protocols draw on OAuth and its existing extensions.

Client ID Metadata Documents (CIMD) let a client identify itself with an HTTPS URL instead of pre-registering. Resource Indicators restrict which APIs a token is intended for. Protected Resource Metadata helps clients discover a resource's authorization servers and supported authorization capabilities.

How Poppy, MCP, A2A and agentic commerce use OAuth

Most agent protocols split the work in a similar way: protocol-specific behavior lives in the client and the resource server, and the authorization server stays standard OAuth

Poppy’s first draft minted the session at the token endpoint with a JWT bearer grant (RFC 7523), which pulled protocol-specific logic into the authorization server. Over the later drafts that was addressed. Account access became plain OAuth and everything specific to Poppy, the delegation, the Poppy-Session header, and all of session management, moved into the layer between the agent and the company’s resource server. The authorization server never sees any of it, and nothing about the Poppy session reaches the token endpoint.

  • Personal agents (Poppy). The agent identifies itself through CIMD and works signed out, under a pseudonymous user ID, until the task needs the user’s account. Then the user signs in on the company’s own page and chooses which of the company’s permissions to grant. Access is scoped and revocable, all on standard OAuth and the OAuth Security BCP (RFC 9700).
    • Example: A personal agent checks room availability as a guest, then changes the reservation once the user signs in on the hotel’s website and grants write access.
  • Tools (MCP). MCP authorization follows the same pattern: the MCP server publishes Protected Resource Metadata, accepts tokens bound to its audience through Resource Indicators, and validates them, for example through Token Introspection. These are primitives Authlete already provides.
    • ‍Example: An AI assistant retrieves issues from a company's issue tracker using an access token intended specifically for that service.
  • Agentic commerce (such as UCP). Standard OAuth secures the commerce APIs, as it does for any REST API, and account linking is OAuth delegation of the user’s access. When the AP2 extension is in use, payment authorization sits outside the authorization server as signed mandates (AP2 uses SD-JWT verifiable credentials).
    • Example: With AP2, a shopping agent completes a purchase with a signed mandate covering only that transaction, rather than unrestricted access to the user’s account.
  • Agent to agent (A2A). Standard OAuth for baseline security, as with any REST API. For delegation downstream, a common pattern is Token Exchange (RFC 8693): an agent exchanges its token for a narrower one to call the next agent on the user’s behalf. Here too the authorization server stays standard OAuth.
    • Example: A travel-planning agent delegates a flight search to another agent using a downstream token with appropriately limited permissions.

‍

Four boxes (Poppy 1.0, MCP, UCP and other agentic commerce protocols, and A2A) each point down to one shared bar, a standard OAuth authorization server. The bar lists client identity, user sign-in and consent, scoped audience-bound tokens, token exchange, and introspection and revocation. A footer line says Authlete is the engine and the company keeps its own login, users, consent screens and business logic.
Poppy, MCP, agentic commerce and A2A each add their own behavior in the agent and the resource server. All four sit on the same standard OAuth authorization server.

Across all of them, the authorization server stays standard OAuth, and that is what Authlete powers.

Where Authlete fits

Authlete is a headless OAuth/OIDC engine that handles the complex protocol mechanics through APIs. For years, it has powered authorization for APIs and deployments requiring FAPI security.

That is the layer agent protocols rely on most, without fundamentally changing it. They build agent-specific behavior around a standards-based OAuth authorization server.

But implementing and maintaining that server is not trivial. It requires handling protocol complexity, interoperability, evolving specifications, token lifecycle management, and security requirements. Authlete provides that foundation, while companies retain control over their authentication experience, consent flows, business logic, and deployment architecture.

Why Authlete for AI agent authorization?

Here is what Authlete brings to OAuth for AI agents:
‍

Your login, your domain. Authlete is the engine. Companies retain control of their login experience, user identities, consent screens, and authorization decision logic, all within their own applications and domains. Authlete handles the underlying OAuth and OpenID Connect protocol mechanics through APIs, without imposing a hosted login experience or requiring companies to move their identity systems to another provider. This separation lets companies support agent authorization while maintaining ownership of the customer experience.

Diagram of an AI agent, identified by its Client ID Metadata Document, requesting access from the company’s own sign-in page on company.com. The user signs in there, and an Authlete-powered authorization server issues a scoped token back to the agent. The agent then calls the protected API with that short-lived token.
An AI agent requests access, the user signs in on the company’s own page, and an Authlete-powered authorization server issues a scoped token. The agent never sees the password.

The building blocks these protocols reach for are already there. Authlete supports:

  • Protecting access to resources: audience-restricted tokens via Resource Indicators (RFC 8707), sender-constrained tokens via DPoP (RFC 9449), token validation via Token Introspection (RFC 7662), and Protected Resource Metadata (RFC 9728), which a resource server publishes to point clients at its authorization server.
  • Strong client authentication: private_key_jwt (RFC 7523).
  • Securing the authorization request: Pushed Authorization Requests (PAR, RFC 9126).
  • Fine-grained authorization: Rich Authorization Requests (RAR, RFC 9396).
  • Delegation across services: Token Exchange (RFC 8693).

This is proven infrastructure, not a new agent-specific stack. The same foundation already runs demanding API security deployments, including FAPI environments.

Table mapping agent protocol needs to OAuth standards, with every row marked “Supported” by Authlete:  Poppy 1.0: CIMD, DPoP and PAR MCP: Protected Resource Metadata, Resource Indicators and Token Introspection Agentic commerce: the authorization code flow and standard access tokens A2A: Token Exchange Enterprise agents: OpenID Federation
Each agent protocol requirement maps to an existing OAuth or OpenID standard, and Authlete supports every one.Type image caption here (optional)

The decisions that matter stay with the issuer. But issuing audience-restricted tokens, keeping revocation state, exchanging a token for the next hop, and recording what the user granted all sit with the party that issues the token. Authlete makes those decisions as the issuer. Resource servers enforce them, and can hand the validity and revocation check to Authlete through Token Introspection rather than rebuilding that logic themselves.

Governed agent identity, for enterprises

CIMD is right for public agents on the open web, where the identity is an HTTPS URL the agent controls and its metadata is self-asserted. Identifying an agent is not the same as trusting it, and whether to extend that trust is the company’s decision, not the protocol’s. Authlete applies the company’s metadata policy to each agent’s CIMD, validating it before any trust is extended and rejecting agents that do not meet the policy.

Enterprises need a more governed identity lifecycle for the agents acting in their name. For that, Authlete supports OpenID Federation. An agent’s identity is still a URL with no per-server registration, and it now carries a cryptographic trust chain to an organizational trust anchor. That lets an organization certify, constrain, and revoke its agents’ identities over their lifecycle, with trust marks conveying status and metadata policy applied during trust-chain resolution. It adds this governance without replacing the authorization servers a company already runs.

This is the enterprise-governed option. It is not an industry norm, and no agent protocol requires it. We are engaged with large enterprise customers on governed agent identity, alongside the broader work on non-human and workload identity (SPIFFE, WIMSE).

From Poppy’s first draft to 1.0

Authlete has worked with Poppy since its first draft, implementing against it as it evolved, testing it end to end, and filing implementation feedback as the spec moved to 1.0. That is how we work: we implement standards from their earliest drafts, which is why Authlete carries the broad coverage of OAuth and OpenID Connect in the market. For us, agents are a new surface, not a new way of working.

To show it working, we built “Stays,” a reference Poppy Company running on an Authlete-powered authorization server, with an agent playground that drives the flow and decodes every call on the wire (more on this in our next post).

Poppy 1.0 lets a Company require Pushed Authorization Requests (PAR), as FAPI 2.0 does, which is the same financial-grade ground Authlete has worked for years.

Build with Authlete

If you are starting to think about agent access to your own product, read our guide on authorization for MCP services, look at the CIMD support, and follow our next post for a working Poppy 1.0 Company on Authlete.