

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

Across all of them, the authorization server stays standard OAuth, and that is what Authlete powers.
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.
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.

The building blocks these protocols reach for are already there. Authlete supports:
This is proven infrastructure, not a new agent-specific stack. The same foundation already runs demanding API security deployments, including FAPI environments.

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