The Scope Creep Automated reviews of new AI-related working group submissions

Review · October 13, 2026

Personal Agent Protocol (Poppy) Draft 0.1 Summary

personal-agent-protocolView the source →

The problem it's solving

Personal agents are already showing up at companies' front doors. Today the company either lets the agent pretend to be the user, typing in the user's password and clicking through web pages, or it blocks the agent entirely.

Poppy wants something in between. An airline could let any agent search flights, let signed-in agents see the user's trips, and require the user's approval before buying a ticket.

What's actually new is the signed-out but recognized session. The agent always identifies itself. The company recognizes a returning user through a pairwise pseudonymous ID, even before that user ever signs in.

This is not an IETF draft. It's an independent spec published at personalagentprotocol.org under Apache 2.0. Third-party trackers attribute it to Meta and Sierra, with Genesys, Instinct, Rocket, Shopify, Stripe and Walmart. Within four days of the 2026-10-09 publication there were already a dozen open source SDKs, validators and demo apps on GitHub.

How does it fit in with OAuth?

Poppy is mostly an OAuth profile with an application protocol on top. It depends on a long list of OAuth RFCs:

It also defines new OAuth extensions that aren't registered anywhere:

  • a session_id parameter on every grant type
  • a signed_in field in token responses
  • a poppy_domains field in AS metadata
  • new error codes, including invalid_session, account_mismatch, sign_in_required and rate_limited
  • a browser assertion JWT type, poppy-browser+jwt

The rest of the spec isn't OAuth: a discovery file, a username and password endpoint, a full agent-to-agent conversation protocol, and an "operations" confirmation extension.

How it works

Discovery. The company publishes /.well-known/poppy.json. It lists the OAuth issuer, the sign-in methods the company supports, its OpenAPI or MCP APIs, its own agent's endpoint, and a browser session endpoint.

The issuer's RFC 8414 metadata must include poppy_domains listing every domain that points at it. This stops any domain from claiming another company's issuer and receiving its tokens. It's a clean fix for a mix-up problem we've talked about in the WG for a while.

Starting a session. The agent uses the JWT bearer grant, with iss set to its own client_id and sub set to a User ID the agent makes up for this user at this company. The User ID must be stable and opaque, and must not be derived from personal information, even through a keyed hash.

The company returns a DPoP-bound Session Token with no scopes. So the agent, not the company, is asserting who the user is, and the company issues tokens for a subject it has never seen.

Signing in. There are three options:

  • Direct: authorization code flow with PKCE.
  • Device: the device authorization grant.
  • Mediated: the agent POSTs the user's username and password to a company endpoint, with an optional one-time code step.

All three return an "Account Token", which is a refresh token, plus a signed-in Session Token for the current session. Scopes are poppy:read, poppy:write, and company-defined custom scopes.

Web browsing. The agent's browser POSTs a signed assertion to the company. The company sets its own cookie, tied to the same session. Now browsing, API calls and conversations all count as one session.

Conversations. A JSON-over-HTTPS chat protocol with the company's agent, with endpoints to send, read events (with a cursor or SSE), hand off to a person, and close. Every message says whether a human or an AI wrote it. The agent can open a "Direct Conversation" when the user wants to talk to the company themselves.

Operations extension. The company proposes an action as a fixed revision of terms. The agent confirms that revision with approved_by: user or standing_permission. Retries are idempotent, so the action happens at most once.

Significant concerns

Mediated Sign-In brings back the password grant. RFC 9700 says the password grant MUST NOT be used, and OAuth 2.1 removes it. Poppy brings it back as a non-OAuth endpoint, and standardizes it "so that every Company that offers Mediated Sign-In handles it the same way."

A standardized endpoint makes "give your password to the agent" a normal thing for users to do. The Guides recommend preferring Direct, then Device, then Mediated. That's the right order, but a spec that ships all three ends up with all three deployed.

Key protections "work on trust". An agent can complete the Direct Sign-In consent page itself. The only defense is a MUST NOT, plus the company revoking the agent's client_id if it catches it.

Operations has the same problem. approved_by: user is self-reported, and the spec admits the company can't verify it. Companies that need proof have to send the user to their own website, and that step isn't defined.

The MCP bearer carve-out. The spec says "MCP can't use proofs, because MCP authorization uses Bearer tokens." MCP doesn't forbid DPoP. MCP clients just don't support it yet. Limiting bearer tokens to one MCP server through resource is a reasonable stopgap. Writing it into the spec as permanent behavior makes it harder to remove later.

"Use your existing authorization server" is optimistic. A company needs all of the following:

  • a JWT bearer grant that accepts an agent-asserted subject with no existing user record
  • session_id handling on every grant
  • a refresh grant that creates a new session when there's no session_id
  • signed_in in token responses
  • poppy_domains in metadata
  • CIMD and DPoP

Most deployed authorization servers, including Okta's, don't do most of this today. Companies will either put a gateway in front, which the Guides suggest, or wait for their vendors.

Significant interoperability concerns

The OAuth parts are well specified. Errors, response fields and checks are spelled out, and that's better than many IETF drafts manage.

The weak spot is the session model. A Session can be signed out, signed in, or signed in to a different account. Several tasks can share one session while holding Session Tokens that reflect different states. Conversations outlive the session that started them and move to "belong to the account" once they touch it.

That's a lot of server-side state for two parties to agree on. It's exactly where implementations will disagree on edge cases, like what happens to a conversation's ownership after sign-out.

context and data in messages are open-ended JSON with no schema, so how they get used is up to each company. That's fine for LLM consumers, but it means nothing in a message is checked or enforced.

Mechanisms that could be removed

  • Mediated Sign-In. Drop it, or move it to a clearly discouraged extension.
  • The conversation protocol. It overlaps heavily with A2A. The human/AI labeling and Direct Conversations are good ideas, but they could be an A2A profile rather than a new wire protocol. The agent.protocols array already allows for other types.
  • The bearer-token path, once MCP clients support DPoP.

That leaves a much smaller core: discovery, the signed-out session grant, DPoP-bound tokens, and sign-in. That core is basically an OAuth profile, and it could go through the OAuth WG as a few small drafts.

What's not covered

  • Enterprise. There's no IdP in the picture. The company is always its own AS, and nothing resembles ID-JAG or cross-app access. This is a consumer protocol.
  • Delegation. No sub-agents, no delegation chains, no token exchange.
  • Verifiable user approval. Nothing like CIBA, signed consent receipts, or a user-held key.
  • Payments, push notifications, attachments. These are listed as open topics.

Writing quality

It's very readable: plain English, short sentences, consistent terms, and good examples. BCP 14 keywords are used correctly. It reads more like Stripe's docs than an RFC, and that's not a criticism.

The Guides page does the job of a Security Considerations section, and it's pretty thorough. It covers shared DPoP replay caches, building htu from the public origin, keeping private keys out of model context, and not shipping signing keys in native apps.

The weakness is that a MUST sometimes takes the place of a missing mechanism, like "MUST use Direct Sign-In only when the User signs in themselves." That sentence is accurate, but it's a policy rule, not a protocol guarantee.

Background of the authors

The spec doesn't name individual authors, and there are no email addresses, so there are no Datatracker profiles to check. The authorship credit to Meta, Sierra and partners comes from third-party trackers, not from the spec itself.

The governance model isn't written down beyond the license. The contributions page says any feedback you submit grants "a perpetual, irrevocable, nonexclusive, worldwide, royalty-free, sublicensable license to use, modify, and commercialize that feedback." That's broader than the IETF's Note Well. Anyone sending feedback should read it first.

Suggested feedback

  1. Remove Mediated Sign-In, or move it to a discouraged extension.
  2. Bring session_id, signed_in, poppy_domains, and the signed-out session grant to the OAuth WG, so the extensions get registered and reviewed.
  3. Plan to move MCP to DPoP instead of keeping the bearer carve-out.
  4. Define a way for the company to verify user approval, both for sign-in consent and for operations.
  5. Ask who controls the spec after 0.1, and whether the OAuth parts will go through a standards body.

Further reading: