What is the Personal Agent Protocol (Poppy)?

How Poppy agents identify themselves with a client_id, sign a Poppy-Session token per request, and sign in through your OAuth server.

19 min read
In short: The Personal Agent Protocol (Poppy) lets a person's AI agent act at a business on their behalf. The agent identifies itself with an HTTPS client_id that points to its metadata and keys, signs a short-lived Poppy-Session JWT for each request, bound to the method and URL, and signs in through the business's own OAuth server with scopes the person approves. A verified session proves which agent sent the request and that it acts for one of its users. It doesn't identify the user, whose ID is pseudonymous and different at each business, and doesn't prove that the user approved the action. Arcjet verifies sessions for agents vetted in the well-known-bots catalog and reports kind AI_AGENT, evidence SIGNATURE, the agent's domain as operator, and delegated true.

What is the Personal Agent Protocol?

The Personal Agent Protocol (Poppy) is an open protocol that lets a person's AI agent identify itself to a business and act there on that person's behalf. The agent names itself with an HTTPS client_id that points to its metadata, signs a short-lived Poppy-Session token for each request, and signs in through the business's own OAuth server with scopes that the person approves, instead of with the person's password.

Poppy answers a question that a User-Agent string can't: which personal agent sent this request, and is it acting for one of its users? A verified session ties the request to the agent's published keys and to one method and URL. It doesn't tell you who the user is, and it doesn't prove that the user approved the specific action. Those limits shape how you use it, and most of this guide is about them.

The protocol's own site calls it "Personal Agent Protocol, or 'Poppy' for short". Sierra and Meta introduced it on October 6, 2026 as an open standard that they develop with industry partners. Specification 1.0 was published on November 14, 2026. The rest of this guide covers why agents need their own identity, how a session works on the wire, what a verified session proves, how Poppy relates to OAuth and Web Bot Auth, and how to verify sessions with Arcjet.

For more information about the other ways to identify AI agents, see how to identify AI agents and bots.

Why do agents need their own identity?

Agents need their own identity because the two ways they reach a business without one both fail. An agent that signs in with the person's password is indistinguishable from the person, and an agent that browses anonymously is indistinguishable from a scraper. Neither lets the business give a person's assistant the access it needs while keeping automated abuse out.

Consider a person who asks a personal agent to exchange a pair of shoes. Without a protocol, the agent has the following options:

  • Use the person's credentials. The agent types the password into the login form, or reuses a session cookie. The business sees the person, can't tell that an agent is acting, and can't limit what the agent does. The person has handed a third party a credential with no scope and no expiry.
  • Browse without signing in. The agent fills in forms from a cloud browser that looks like Chrome. Bot defenses that work as intended block it, and those that let it through can't tell it apart from a credential-stuffing script on the same network.
  • Use a private integration. The business builds an API for one agent vendor. That works for one pair of companies and doesn't scale to every business and every agent.

Poppy replaces these with a shared contract. The agent proves which agent it is with keys on its own domain. The person grants the agent named scopes through the business's own sign-in page. The business sees an agent, a pseudonymous user, and a token with limited scopes, and decides what that combination may do.

For more information about the delegation model behind this, see AI agent on-behalf-of identity.

How does a Poppy session work?

A Poppy session works in four steps, in the order a request meets them. The business publishes a discovery document, the agent publishes its metadata and keys, the agent signs a delegation that authorizes a short-lived session key, and every request carries a session token signed by that key. The following sections show each step with the shapes from the 1.0 specification. Values in uppercase are placeholders.

Step 1: The business publishes poppy.json

A business opts in by publishing a discovery document at https://DOMAIN/.well-known/poppy.json over HTTPS. The document names the organization, describes the scopes that the business offers, and points to the business's APIs and endpoints. A minimal document looks like the following:

{
"protocol_version": "1.0",
"organization": {
"name": "Example Shop",
"domain": "shop.example"
},
"auth": {
"scopes": {
"orders:read": "See your orders and returns",
"orders:write": "Exchange or return items"
},
"scope_hints": {
"orders:read": { "changes": "none", "personal_data": true },
"orders:write": { "changes": "irreversible", "personal_data": true }
}
}
}

The agent checks that organization.domain matches the host that served the document. If the business offers sign-in, the agent finds the OAuth issuer through protected resource metadata at /.well-known/oauth-protected-resource, and the issuer publishes standard RFC 8414 authorization server metadata. The scope_hints field says whether a scope makes changes, and whether those changes are reversible. The specification is explicit that hints are the business's claims, not the user's approval.

An agent sends sessions only to businesses that publish this file. A site without poppy.json receives ordinary browser traffic from the same agent.

Step 2: The agent publishes its metadata and keys

The agent's client_id is an HTTPS URL that returns its metadata document. The format follows the OAuth Client ID Metadata Document draft, so the agent doesn't register with each business in advance:

{
"client_id": "https://agent.example/agent.json",
"client_name": "Example Agent",
"jwks_uri": "https://agent.example/jwks.json",
"redirect_uris": ["https://agent.example/oauth/callback"],
"token_endpoint_auth_method": "private_key_jwt"
}

Section 4.1 of the specification sets the following rules:

  • client_id must equal the URL that the document was fetched from.
  • jwks_uri and redirect_uris must be HTTPS URLs on the same domain as client_id.
  • The agent authenticates to the business's token endpoint with a client assertion signed by a key from jwks_uri.
  • Businesses must accept ES256 and PS384 signatures.

Each business decides which agents it accepts. The specification defines how an agent proves its identity, not which identities a business has to trust.

Step 3: The agent signs a delegation

The long-lived keys in jwks_uri don't sign requests directly. Instead, the agent signs a delegation: a JWT that authorizes a short-lived key to sign sessions. The delegation header names the jwks_uri key that signed it:

{
"alg": "ES256",
"typ": "poppy-delegation+jwt",
"kid": "AGENT_KEY_ID"
}

The delegation claims carry the delegated public key in cnf.jwk:

{
"iss": "https://agent.example/agent.json",
"cnf": {
"jwk": {
"kty": "EC",
"crv": "P-256",
"x": "DELEGATED_KEY_X",
"y": "DELEGATED_KEY_Y"
}
},
"iat": 1792140000,
"exp": 1792161600,
"jti": "DELEGATION_ID"
}

Replace the following:

  • AGENT_KEY_ID: the kid of the signing key in the agent's jwks_uri
  • DELEGATED_KEY_X and DELEGATED_KEY_Y: the coordinates of the short-lived P-256 public key
  • DELEGATION_ID: a unique identifier for this delegation

The delegation is signed with ES256 or PS384, and exp can be at most 24 hours after iat. A delegation contains nothing about the user or the business, and each delegated key signs for one user ID only. If a delegated key leaks, the damage is limited to one user's sessions for at most 24 hours.

Step 4: Every request carries a Poppy-Session token

The agent sends a Poppy-Session header on every request to the business's APIs, conversations, and protocol endpoints. A signed-in request also carries the access token from the business's OAuth server:

POST /orders/ORDER_ID/exchanges HTTP/1.1
Host: api.shop.example
Poppy-Session: SESSION_JWT
Poppy-Version: 1.0
Authorization: Bearer ACCESS_TOKEN

Replace the following:

  • ORDER_ID: the order that the request changes
  • SESSION_JWT: the session token for this request, signed with the delegated key
  • ACCESS_TOKEN: the OAuth access token, sent only when the user signed in

The session JWT carries the delegation in its header as poppy_dlg, and its kid is the thumbprint of the delegated key:

{
"typ": "poppy-session+jwt",
"alg": "ES256",
"kid": "DELEGATED_KEY_THUMBPRINT",
"poppy_dlg": "DELEGATION_JWT"
}

The session claims bind the token to one request:

{
"iss": "https://agent.example/agent.json",
"aud": "https://auth.shop.example",
"sid": "SESSION_ID",
"sub": "USER_ID",
"htm": "POST",
"htu": "https://api.shop.example/orders/ORDER_ID/exchanges",
"iat": 1792150000,
"jti": "REQUEST_ID",
"ath": "ACCESS_TOKEN_HASH"
}

The claims have the following meanings:

  • iss is the agent's client_id, and aud is the business's issuer.
  • sid identifies the session. The agent picks a random value and uses it for one session only.
  • sub is the user ID, a pseudonymous value that's different at each business.
  • htm and htu are the request method and URL, without the query string or fragment, as in DPoP.
  • iat is when the agent signed the token. The business accepts only a fresh value, inside a window it chooses, such as one minute.
  • jti is a unique, unguessable token ID.
  • ath is the SHA-256 hash of the access token. It's absent when the request has no token.

The agent signs a session JWT for every request. A copied token works only for the same method and URL, and only until it falls out of the freshness window.

How does a business verify a session?

A business verifies a session from the outside in. It reads poppy_dlg, finds the jwks_uri key that its kid names, and verifies the delegation, its type, issuer, and lifetime. It then verifies the session JWT with the key in cnf.jwk and checks that the session's kid is that key's thumbprint. Finally, it checks typ, aud, htm, htu, and iat against the request, and ath against the access token when one is present. Any failure returns 400 with {"error": "invalid_session"}. The business can also reject a jti that it has already seen.

What does a verified session prove?

A verified Poppy session proves which agent sent the request and that the agent is acting for one of its users. It doesn't reveal who that user is, and it doesn't prove that the user approved the action in the request. Treat a verified session as strong evidence of the client's identity, and as no evidence at all about the user's intent.

The following list separates what a session establishes from what it leaves to you:

  • It proves the agent. Only the holder of a private key in the agent's jwks_uri can sign the delegation, and only the holder of the delegated key can sign the session. A valid chain ties the request to the domain that publishes the client_id.
  • It proves the request. htm, htu, and iat bind the token to one method, one URL, and a short window. A token captured from one request can't be moved to a different endpoint.
  • It proves a user exists. The agent signs for a user ID, and each delegated key serves one user ID. That's the delegation: the agent acts for someone, not for itself.
  • It doesn't identify the user. The sub is a pseudonymous ID that's stable for one user at one business and different at every other business. The specification forbids deriving it from personal information, even hashed. An agent can also issue a fresh user ID for each anonymous browsing session.
  • It doesn't prove approval. A session says the agent acts for a user. It doesn't say the user asked for this exchange, this payment, or this recipient. The specification says that a message from the agent doesn't authorize the account action it requests.

The last point is the one that matters in production. A prompt injection, a malicious page, or a planning error can still steer an agent that holds a valid session. The session stays valid while the agent does something its user didn't ask for.

That's why the access token and its scopes stay with your authorization server, and why agent identity feeds your authorization decision rather than replacing it. The session tells your code which agent is asking and that it represents a user. The access token tells your code which account and which scopes the user granted. Your handler holds the rest: the order, the amount, the account's history, and whether the action can be undone. For more information about gating consequential actions, see prevent irreversible AI agent actions.

How is Poppy different from OAuth and Web Bot Auth?

Poppy builds on OAuth for account access and sits next to Web Bot Auth for operator identity. OAuth answers what the user allowed, Web Bot Auth answers which operator's infrastructure sent the request, and the Poppy session answers which agent sent it and that it acts for a user. A Poppy request can carry all three.

Poppy and OAuth

Poppy uses standard OAuth for sign-in: the authorization code grant with PKCE, the device grant for agents without a browser, refresh tokens, revocation, and optional DPoP-bound tokens. The specification adds the following to plain OAuth:

  • A stricter client identity. The client_id is a URL that the agent controls, clients authenticate with private_key_jwt, and redirect URIs must match exactly.
  • Discovery. poppy.json tells the agent where to sign in and what each scope means, with hints about changes and personal data.
  • Sessions. The Poppy-Session header is a signed JWT, not an OAuth grant. It works for signed-out requests, where there's no access token at all.

Sessions and account access are independent. A signed-out request carries only the session. A signed-in request carries the session and the access token, and ath binds the two together.

Poppy and Web Bot Auth

Web Bot Auth signs each request with RFC 9421 HTTP Message Signatures, using keys that the operator publishes at /.well-known/http-message-signatures-directory. It proves which operator holds the key. When the operator is a hosted browser platform, such as Browserbase, the signature proves that the request came through that platform, not which customer's agent sent it.

Poppy's specification recommends that agents also sign with Web Bot Auth, and that the signature cover the poppy-session header and the authorization header when present. The operator signature gives traffic-management tools a way to recognize the agent, and the session gives the business a delegated identity. A missing operator signature doesn't make a session invalid.

For a side-by-side comparison, see Web Bot Auth vs Personal Agent Protocol.

How do you verify Poppy sessions with Arcjet?

Arcjet verifies Poppy sessions inside the detectBot rule, next to Web Bot Auth signatures and IP checks, and reports the result in one bot identity. A verified session gives the identity kind AI_AGENT, evidence SIGNATURE, operator set to the agent's domain, and delegated set to true. You read it in your route handler, where the user, the cart, and the account are already in scope.

Arcjet verifies sessions only for agents that are vetted in the open source well-known-bots catalog. The catalog records each agent's client_id. Arcjet doesn't fetch a client_id that a request supplies, so a request can't make Arcjet fetch a URL of the sender's choosing. A session that fails verification, or comes from an agent that isn't in the catalog, doesn't change the identity. Arcjet decides the request with the other bot signals.

Arcjet checks the session against the request: the delegation chain, the signatures, the method and URL, and freshness. It doesn't check aud or the access token. Your authorization server checks the token and its scopes, because only your authorization server issued them.

Only Arcjet Cloud computes the identity, so a decision that the SDK makes locally has none. The identity is available in the JavaScript, Python, and Go SDKs.

Check for a delegated agent in JavaScript

The following Express route allows search engines and AI agents, finds the AI agent identity, and reads delegated:

import arcjet, {
detectBot,
type ArcjetBotIdentity,
type ArcjetDecision,
} from "@arcjet/node";
import { isAiAgent, isSpoofedBot } from "@arcjet/inspect";
import express from "express";
const aj = arcjet({
key: process.env.ARCJET_KEY!,
rules: [
detectBot({
mode: "LIVE",
allow: ["CATEGORY:SEARCH_ENGINE", "CATEGORY:AI_AGENT"],
}),
],
});
// Return the identity of the AI agent that sent the request, if any
function aiAgent(decision: ArcjetDecision): ArcjetBotIdentity | undefined {
for (const result of decision.results) {
if (isAiAgent(result) && result.reason.isBot()) {
return result.reason.identity;
}
}
return undefined;
}
const app = express();
app.get("/orders", async (req, res) => {
const decision = await aj.protect(req);
if (decision.isDenied() || decision.results.some(isSpoofedBot)) {
res.status(403).json({ error: "Forbidden" });
return;
}
const agent = aiAgent(decision);
if (agent?.delegated) {
// A verified Personal Agent Protocol session, for example:
// META_MUSE SIGNATURE muse.ai true
console.log(agent.botId, agent.evidence, agent.operator, agent.delegated);
}
// Check the access token and its scopes with your authorization server.
res.json({ orders: [] });
});
app.listen(3000);

Check for a delegated agent in Python

The following FastAPI route does the same with is_ai_agent and reason_v2:

import os
from arcjet import (, is_spoofed_bot
BotCategory,
BotIdentity,
Decision,
Mode,
arcjet,
detect_bot,
is_ai_agent,
)
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
aj = arcjet(
key=os.environ["ARCJET_KEY"],
rules=[
detect_bot(
mode=Mode.LIVE,
allow=[BotCategory.SEARCH_ENGINE, BotCategory.AI_AGENT],
),
],
)
app = FastAPI()
def ai_agent(decision: Decision) -> BotIdentity | None:
"""Return the identity of the AI agent that sent the request, if any."""
for result in decision.results:
reason = result.reason_v2
if is_ai_agent(result) and reason.type == "BOT":
return reason.identity
return None
@app.get("/orders")
async def orders(request: Request):
decision = await aj.protect(request)
if decision.is_denied() or any(
is_spoofed_bot(r) for r in decision.results
):
return JSONResponse({"error": "Forbidden"}, status_code=403)
agent = ai_agent(decision)
if agent is not None and agent.delegated:
# A verified Personal Agent Protocol session, for example:
# META_MUSE SIGNATURE muse.ai True
print(agent.bot_id, agent.evidence, agent.operator, agent.delegated)
# Check the access token and its scopes with your authorization server.
return {"orders": []}

Check for a delegated agent in Go

The following net/http handler uses decision.IsAIAgent() and reads the identity from result.Reason.Bot.Identity:

// aiAgent returns the identity of the AI agent that sent the request, if any.
func aiAgent(decision arcjet.Decision) *arcjet.BotIdentity {
if !decision.IsAIAgent() {
return nil
}
for _, result := range decision.Results {
if bot := result.Reason.Bot; bot != nil && bot.Identity != nil &&
bot.Identity.Kind == arcjet.BotKindAIAgent && !bot.Identity.Spoofed {
return bot.Identity
}
}
return nil
}
http.HandleFunc("GET /orders", func(w http.ResponseWriter, r *http.Request) {
decision, err := aj.Protect(r.Context(), r)
if err != nil || decision.IsDenied() {
http.Error(w, "Forbidden", http.StatusForbidden)
return
}
if agent := aiAgent(decision); agent != nil && agent.Delegated {
// A verified Personal Agent Protocol session, for example:
// META_MUSE SIGNATURE muse.ai true
log.Println(agent.BotID, agent.Evidence, agent.Operator, agent.Delegated)
}
// Check the access token and its scopes with your authorization server.
w.Write([]byte(`{"orders":[]}`))
})

The aj client uses the same detectBot rule as the preceding examples, with arcjet.BotCategorySearchEngine and arcjet.BotCategoryAIAgent in Allow.

delegated is true only with SIGNATURE evidence. For more information about how Arcjet ranks identities when a request matches several bots, see AI agent evidence levels. For the full reference, see agents that act for a user in the Arcjet docs.

Which agents support Poppy?

As of November 2026, Meta's Muse is the one personal agent with a published Poppy client_id. Instinct, Manus, Meta, and OpenAI are the personal-agent design partners that the protocol's path to 1.0 page lists, and that page also lists the businesses and platforms that partner on the company side. Check it for the current list, because it changes faster than this guide.

The following list describes the agents that matter for verification as of November 2026:

  • Meta Muse. Muse launched on September 8, 2026. Meta's Poppy post calls it "the first personal agent to support Poppy". Muse publishes the client_id https://muse.ai/poppy/agent.json and Web Bot Auth keys at https://muse.ai/.well-known/http-message-signatures-directory. Arcjet reports it as META_MUSE. For more information, see how to detect Meta's Muse AI agent.
  • OpenAI, Instinct, and Manus. These are design partners with no published client_id. ChatGPT agent and Manus sign their cloud browser requests with Web Bot Auth, so Arcjet identifies them as CHATGPT_AGENT and MANUS_BOT with SIGNATURE evidence, without delegated.
  • Agents in the person's own browser. Claude in Chrome and Perplexity Comet drive the person's own browser, with that person's cookies and IP address. A server can't identify them from the request, with or without Poppy.

Muse requests that carry no session or signature, such as requests to a site that doesn't publish poppy.json, look like Chrome on Linux. For those, the SwiftShader and ARM signals in the Muse guide are the fallback.

An agent joins the catalog through a pull request to the well-known-bots repository that names the client_id its operator publishes. The catalog is public, so you can read which agents Arcjet verifies and how.

What policy fits a delegated agent?

A delegated agent fits a tier between anonymous automation and a signed-in person: more access than an unidentified bot, scoped by the OAuth grant, and gated on consequential actions. The session identifies the agent, the access token defines the account access, and your handler decides each action with the facts that only it has.

The following defaults work for most applications:

  • Allow delegated agents on public content and account reads. A person who asks an agent to track an order is your customer. Let the verified agent read what the granted scopes cover.
  • Require the access token for account actions. delegated says the agent acts for a user. Only the token says which account, and which scopes the user granted. Check both before you return account data.
  • Rate limit each agent. Key a rate limit on the bot ID so that one agent can't use up capacity your other visitors need. For more information, see the rate limiting guide.
  • Gate irreversible actions. Purchases, payments, deletions, and address changes need your own checks, such as spend limits, fraud checks, or a confirmation that the person completes. For more information, see human approval gates for agent actions.
  • Don't promote a claim. A request that claims to be Muse in a header, without a verified session or signature, has UNVERIFIED or no identity. Give it the same treatment as any other automation.
  • Start in DRY_RUN. Measure how many delegated requests each route receives before you change what they get.

For more information about applying these tiers to a checkout flow, see agentic commerce bot protection. To start, follow the Arcjet bot protection quick start and read the identity in your handler.

Frequently asked questions

Is Poppy the same as the Personal Agent Protocol?

Yes. Poppy is the short name for the Personal Agent Protocol, an open protocol that Sierra and Meta introduced in October 2026. Specification 1.0 was published on November 14, 2026 at personalagentprotocol.org.

Does Poppy identify the user?

No. The session's sub is a pseudonymous user ID that's stable for one user at one business and different at every other business. The specification forbids deriving it from personal information, even hashed. A verified session proves that the agent acts for one of its users, not who that user is.

Do I need an OAuth server to support Poppy?

Only to offer sign-in. A business opts in by publishing /.well-known/poppy.json, and agents send a Poppy-Session header on signed-out requests without any access token. To let agents act on a person's account, you run an OAuth authorization server that publishes the metadata the specification lists, and the agent signs in with scopes the person approves.

Can a Poppy session be replayed?

Only briefly, and only against the same request. The agent signs a session JWT for each request, bound to the method and URL with htm and htu, and the business accepts it only inside a freshness window such as one minute. The business can also reject a jti that it has already seen.

What happens if an agent isn't vetted?

Arcjet verifies Poppy sessions only for agents vetted in the open source well-known-bots catalog, and doesn't fetch a client_id that a request supplies. A session from an agent outside the catalog, or one that fails verification, doesn't change the bot identity, and Arcjet decides the request with the other bot signals.

Does Poppy prove that the user approved a purchase?

No. A verified session proves the agent and that it acts for a user. The access token says which scopes the user granted. Whether this purchase, amount, or recipient is acceptable stays a decision for your own code, with spend limits, fraud checks, or a confirmation the person completes.

Does Poppy replace CAPTCHAs?

For agents that present a verified session, a CAPTCHA adds friction without adding information, because the session already identifies the agent cryptographically. Poppy doesn't cover agents that don't send a session, such as agents running in a person's own browser, so keep advanced signals and rate limits for that traffic.

Application security in your code

Protect your application with Arcjet

Read the delegated agent identity in the handler that also holds the access token and the order, so a verified agent gets the access its scopes allow and no more.