Personal Agent Protocol (Poppy): The Complete Guide to Agentic Commerce’s Missing Identity Layer for RPA and Agentic AI Architects (2026)
On September 20, 2026, Amazon blocked Meta’s personal AI agent, Muse, from completing purchases on its marketplace. Amazon’s objections were specific: Muse didn’t identify itself, didn’t ask permission, and appeared to capture and store customer credentials. Within sixteen days, Sierra and Meta published Draft 0.1 of the Personal Agent Protocol — nicknamed Poppy — an open, OAuth-based standard that gives AI agents a front door to businesses instead of forcing them to sneak through the browser like a human. By October 9, the partner list had swelled to over 40 organizations, including Bank of America, Visa, Mastercard, PayPal, Walmart, Target, Nordstrom, OpenAI, Okta, Cloudflare, and Zapier.
- Table of Contents
- What Is the Personal Agent Protocol (Poppy)?
- Why It Matters Now: The Amazon-Muse Conflict and the Identity Gap
- Where Poppy Fits in the Agentic Protocol Stack
- The Five Building Blocks of Poppy
- 1. Discovery: The poppy.json File
- 2. Sessions: One Identity Across Channels
- 3. Sign-In: OAuth with Three Methods
- 4. Getting the Job Done: Three Integration Modes
- 5. Extensions: A Future-Proof Architecture
- Technical Deep Dive: OAuth, JWTs, DPoP, and Session Lifecycle
- Agent Identity Verification
- Session Token Lifecycle
- DPoP Proof of Possession
- MCP-Specific Token Handling
- The Three Integration Modes: Website, APIs, and Company Agent
- The Permission Model: Guest, Read, and Write Access
- The Conversation Protocol: Structured Agent-to-Business Dialogue
- The Partner Ecosystem: Who’s In and Who’s Missing
- Founding Partners (October 6, 2026)
- Design Partners (October 9, 2026)
- Notable Additions and Overlaps
- Who’s Not Listed
- Protocol Comparison: Poppy vs. UCP vs. ACP vs. TAP vs. PACT
- What This Means for RPA and Automation Architects
- 1. The Shift From UI Automation to Authenticated API Access
- 2. Agent-to-Agent Conversations Are a New Integration Pattern
- 3. Credential Management Gets Standardized
- 4. Permission Scoping Changes the Automation Design Pattern
- 5. Your Automation Platform Is About to Become a “Company Agent”
- Preparation Checklist: 10 Steps to Get Ready
- Frequently Asked Questions
- Does the Personal Agent Protocol handle payments?
- How does Poppy relate to MCP (Model Context Protocol)?
- Can a business block all AI agents under Poppy?
- Is Poppy only for consumer shopping?
- What’s the difference between Poppy and Visa’s Trusted Agent Protocol (TAP)?
- Key Takeaways
- References
For RPA and agentic AI architects, the implications are immediate. The protocol that wins the identity layer will determine how every agent — from a simple invoice-processing bot to a multi-step procurement orchestrator — authenticates with external services. If you’re building automation that touches commerce, customer service, or any cross-organization workflow, Poppy is the specification you need to understand right now, even while it’s still in draft.
This guide breaks down the full Draft 0.1 specification, maps Poppy’s position in the emerging protocol stack alongside MCP, A2A, UCP, ACP, and Visa TAP, and gives you a concrete preparation checklist so your automation architecture is ready when the reference implementation ships.
Table of Contents
- What Is the Personal Agent Protocol (Poppy)?
- Why It Matters Now: The Amazon-Muse Conflict and the Identity Gap
- Where Poppy Fits in the Agentic Protocol Stack
- The Five Building Blocks of Poppy
- Technical Deep Dive: OAuth, JWTs, DPoP, and Session Lifecycle
- The Three Integration Modes: Website, APIs, and Company Agent
- The Permission Model: Guest, Read, and Write Access
- The Conversation Protocol: Structured Agent-to-Business Dialogue
- The Partner Ecosystem: Who’s In and Who’s Missing
- Protocol Comparison: Poppy vs. UCP vs. ACP vs. TAP vs. PACT
- What This Means for RPA and Automation Architects
- Preparation Checklist: 10 Steps to Get Ready
- Frequently Asked Questions
- Key Takeaways
- References
What Is the Personal Agent Protocol (Poppy)?
Poppy is an open protocol, licensed under Apache 2.0, that standardizes how a customer’s personal AI agent discovers a business, authenticates on the customer’s behalf, and completes tasks through the business’s website, APIs, or the company’s own AI agent. The name “Poppy” is the protocol’s internal codename, and the discovery file that businesses publish lives at /.well-known/poppy.json.
The core principle is a two-sided contract: customers decide what access to give their personal agents, and companies set the parameters for what those agents can do. The protocol doesn’t move money, process payments, or handle product discovery. It handles something more fundamental — identity, consent, and scope.
Think of it this way: MCP (Model Context Protocol) is the tool-access layer that lets agents call APIs. A2A is the agent-to-agent communication layer. Payment protocols like ACP and UCP handle checkout and settlement. Poppy sits alongside all of them as the identity and session layer — the part that answers “who is this agent, who does it represent, and what is it allowed to do?”
What the Draft 0.1 Specification Covers
The specification, published October 9, 2026 at personalagentprotocol.org/docs/spec, defines sixteen areas:
| Area | What It Specifies |
|---|---|
| Discovery | The poppy.json schema that businesses publish at a well-known URL |
| OAuth Server Verification | How agents verify a business’s OAuth issuer to prevent impersonation |
| Agent Identity | How agents prove who they are using client_id metadata and private_key_jwt |
| Token Types | Short-lived DPoP-bound Session Tokens and long-lived Account Tokens |
| Session Lifecycle | Start, renew, sign in, reuse, and sign out flows |
| JWT Assertion Format | Claims structure for session start and renewal |
| DPoP Proof of Possession | Cryptographic binding of tokens to the presenting agent (RFC 9449) |
| Bearer Tokens for MCP | MCP-specific token handling since MCP cannot use DPoP |
| Three Sign-In Methods | Direct (authorization code + PKCE), Device, and Mediated |
| Permission Scopes | Standard poppy:read and poppy:write plus custom scopes |
| Account Token Refresh | Token rotation, narrowing scopes, secure storage requirements |
| Web Browsing Join | How an API session extends to browser-based interactions |
| API Integration | OpenAPI (DPoP) and MCP (Bearer) integration patterns |
| Conversation Protocol | Structured agent-to-business dialogue with handoff to humans |
| Extension Mechanism | How companies and agents add capabilities like payments |
| Token Error Reference | Standardized error codes and HTTP status codes |
This is not a white paper or a press release with aspirational language — it’s a real specification with JWT claim formats, DPoP proof structures, and HTTP error codes. That level of detail is what separates Poppy from the wave of “we’ll publish a spec eventually” announcements that have characterized the agentic commerce space.
Why It Matters Now: The Amazon-Muse Conflict and the Identity Gap
The catalyst for Poppy was a real-world incident that exposed the absence of an identity standard for personal AI agents. Here’s the timeline:
September 8, 2026: Meta releases Muse, a personal AI agent that can browse the web, make purchases, and manage tasks across email, calendar, and commerce services. Payments run through Stripe’s Link, which creates a one-time virtual card for each transaction. Muse runs in a secure cloud virtual machine with its own browser and uses a monitoring agent called Sentinel to approve outbound traffic.
September 15, 2026: Muse hits #1 in Apple’s US App Store.
September 20, 2026: Amazon blocks Muse. Amazon’s stated objections, as reported by GeekWire, include that Muse doesn’t identify itself as an agent when browsing, that Meta didn’t get Amazon’s consent, and that the agent appears to capture and store customer credentials. Amazon’s spokesperson argued that “third-party shopping apps should operate openly and respect service provider decisions about whether or not to participate.”
October 6, 2026: Sierra and Meta announce the Personal Agent Protocol with initial partners Genesys, Instinct, NiCE, Rocket, Shopify, Stripe, and Walmart.
October 9, 2026: Sierra publishes Draft 0.1 of the specification, along with 35 new design partners including Bank of America, Visa, Mastercard, OpenAI, Okta, Wells Fargo, Target, Nordstrom, United Airlines, and Zapier.
The pattern is clear: the “chaos” Bret Taylor described — where agents log in as users and click through web pages designed for humans — had real consequences. Amazon’s decision to block Muse wasn’t just a business dispute; it was a structural problem. Without a standard for agent identity, every interaction between an agent and a business is either a hack (pretending to be the user) or a bespoke integration (building a custom API for each agent provider). Neither scales.
Why RPA Architects Should Pay Attention
If you’ve built RPA automations that interact with external websites or services, you’ve lived this problem. Your bots log in with stored credentials, navigate UIs designed for humans, and break when those UIs change. The identity gap that Poppy addresses isn’t unique to consumer shopping agents — it’s the same gap that makes enterprise automation fragile. A standard identity layer could transform how automation interacts with SaaS platforms, vendor portals, and partner systems.
Where Poppy Fits in the Agentic Protocol Stack
The agentic AI ecosystem is rapidly developing a layered protocol stack. Understanding where each protocol sits prevents the confusion of treating them as competitors when they’re mostly complementary layers.
| Layer | Protocol(s) | What It Handles |
|---|---|---|
| Identity & Session | Poppy (PAP), Visa TAP, PACT | Who is this agent? Who does it represent? What can it do? |
| Tool Access | MCP (Model Context Protocol) | How agents call tools, read resources, and access data |
| Agent-to-Agent | A2A (Agent-to-Agent Protocol) | How agents delegate tasks across vendors and organizations |
| Commerce Journey | UCP (Universal Commerce Protocol) | Discovery → checkout → post-purchase across the full buyer flow |
| Payment Authorization | AP2, ACP, Mastercard Agent Pay | User consent, payment tokens, and settlement |
| Settlement | Existing payment rails (Visa/MC/Stripe/PayPal) | Moving money between accounts |
Poppy explicitly positions itself as complementary to all of these. From the Sierra blog post: “Universal Commerce Protocol focuses on shopping — from product discovery through checkout and order management. Poppy covers how an agent identifies itself, gets permission, and works with a company on any task, from buying a sweater to applying for a mortgage.”
The key insight for architects is the word “any task.” UCP is scoped to commerce. Poppy is scoped to identity across all interactions — commerce, customer service, insurance claims, mortgage applications, medical appointments. That breadth is what makes it relevant beyond shopping bots.
The Five Building Blocks of Poppy
1. Discovery: The poppy.json File
Every participating business publishes a single JSON file at https://{domain}/.well-known/poppy.json. This file tells agents how to interact with the company, how customers sign in, and what the agent can do. The specification requires HTTPS and allows redirects only to HTTPS URLs.
The top-level fields include:
protocol_version: Currently"0.1"organization: Company name and domain (must match the request host)auth: OAuth issuer, supported sign-in methods (direct, device, mediated), and custom scopesagent: Conversation protocol endpointsapis: Array of API definitions (OpenAPI or MCP) with URLs and descriptionsweb: Browser session endpoint for web browsing integrationextensions: Optional capability extensions
For RPA architects, this is analogous to a robots.txt for agents — but instead of “don’t crawl these pages,” it says “here’s how to interact with us properly.” The single-file approach makes adoption straightforward: publish one JSON file, and every compliant agent knows how to find you.
2. Sessions: One Identity Across Channels
When an agent starts interacting with a business, it creates a session. The session can begin as a guest (no sign-in required) and upgrade to an authenticated session when the user signs in. Crucially, the same session token works across the business’s APIs, website, and company agent. A question asked before sign-in and an order placed after sign-in belong to the same visit.
Sessions use short-lived OAuth access tokens, DPoP-bound (Demonstration of Proof-of-Possession, RFC 9449), which means the token is cryptographically tied to the specific agent presenting it. Stolen tokens can’t be replayed by a different client.
3. Sign-In: OAuth with Three Methods
Poppy supports three sign-in methods, each suited to different interaction contexts:
| Method | How It Works | Best For |
|---|---|---|
| Direct | Standard OAuth authorization code flow with PKCE (RFC 7636). The user signs in via browser. | First-time setup, high-trust actions |
| Device | Device authorization grant (RFC 8628). Agent shows a code; user opens a URL on any device. | Headless agents, voice interfaces |
| Mediated | Agent posts credentials to a specific endpoint. Fields marked secret must never be logged. |
Repeat interactions where credentials are pre-stored |
The specification is explicit that Direct and Device Sign-In must only be used when the user personally completes the sign-in. This prevents agents from using stored credentials to silently authenticate — precisely the behavior Amazon objected to with Muse.
4. Getting the Job Done: Three Integration Modes
Once authenticated, the agent interacts through one or more channels chosen by the business (detailed in the section below).
5. Extensions: A Future-Proof Architecture
The specification includes a formal extension mechanism. Companies and agents list supported extensions in their discovery files and metadata. Spec-defined extensions use plain names; third-party extensions use a domain the author controls (e.g., example.com/gift-wrap). This is how payments, push notifications, and industry-specific capabilities will be added without breaking the core protocol.
Technical Deep Dive: OAuth, JWTs, DPoP, and Session Lifecycle
This section is for architects who need to understand the wire-level protocol. If you’re looking for the business implications, skip to the RPA Architect Implications section.
Agent Identity Verification
Every agent has a client_id that is an HTTPS URL pointing to its metadata document. This document follows the OAuth Client ID Metadata Document draft and includes:
client_nameandlogo_urifor displayjwks_uripointing to the agent’s public keys (HTTPS, same domain asclient_id)redirect_urisfor OAuth callbackstoken_endpoint_auth_method: alwaysprivate_key_jwt
Client authentication uses RFC 7523 (private_key_jwt), signed with a key from the agent’s published JWKS. This means every API call from an agent carries a cryptographic proof of the agent’s identity — a direct answer to Amazon’s complaint that Muse didn’t identify itself.
Session Token Lifecycle
The lifecycle follows five states:
- Start a Session: The agent requests a signed-out Session Token from the company’s token endpoint using a JWT bearer grant (RFC 7523). The JWT assertion includes the agent’s
client_idasiss, the user’s opaque company-specific ID assub, and a 128-bit randomjtito prevent replay attacks. - Renew: Repeat the request with the existing
session_id. Expired sessions get fresh tokens without losing context. - Sign In: Use one of the three sign-in methods. This returns an Account Token (long-lived refresh token) and a signed-in Session Token.
- Reuse: Exchange the Account Token for signed-in tokens in new or existing sessions.
- Sign Out: Revoke the Account Token at the revocation endpoint (RFC 7009). Sessions continue in signed-out state.
DPoP Proof of Possession
All non-MCP API calls require DPoP proofs (RFC 9449). Each proof is a JWT with:
typ: dpop+jwtalg: ES256(ECDSA with P-256)- The agent’s public key in the
jwkheader - Claims:
jti(unique),htm(HTTP method),htu(URL without query),iat, andath(SHA-256 hash of the Session Token)
The company verifies the signature, checks key binding against the token, validates method and URL match, confirms iat is within its acceptance window (typically 60 seconds), and rejects reused jti values. This makes token theft largely useless — a stolen token can’t be used from a different agent.
MCP-Specific Token Handling
MCP cannot use DPoP (its transport doesn’t support the required headers), so MCP access uses standard Bearer tokens. The specification requires that each Bearer token be scoped to a single MCP server using RFC 8707 resource indicators. Companies must accept Bearer tokens only on MCP APIs and must require DPoP everywhere else. This is a pragmatic compromise that keeps MCP integration simple while maintaining security on all other endpoints.
The Three Integration Modes: Website, APIs, and Company Agent
Businesses choose which channels to offer agents. Most will offer more than one, and the choice shapes how automation architects design their integrations.
Mode 1: Website (Browser-Based)
The agent navigates the business’s existing web pages using a browser it controls. The session is joined to the browser via a special JWT assertion (type poppy-browser+jwt) delivered as a form POST. The company sets a Secure, HttpOnly, SameSite cookie that reflects the session state and applies the user’s permissions to each page.
For RPA architects: This is the closest mode to traditional RPA. Your bot navigates web pages, but with a crucial difference — it identifies itself as an agent, carries authenticated session state, and operates within permissions the user explicitly granted. No more credential scraping or pretending to be a human.
Mode 2: APIs (OpenAPI and MCP)
The structured integration path. Businesses expose OpenAPI endpoints (using DPoP tokens) or MCP servers (using Bearer tokens). Each API keeps its own schema, and MCP servers must publish RFC 9728 protected resource metadata.
Standard HTTP error handling applies: 401 invalid_token for expired or invalid tokens, 403 sign_in_required when authentication is needed, and 403 insufficient_scope when the agent’s permissions are too narrow (with the required scope returned in the response).
For RPA architects: This is the path you should plan for. As businesses publish Poppy-compliant APIs, the value of UI-based automation drops. Instead of maintaining fragile selectors on a checkout page, you call a structured API with proper error codes and scope management.
Mode 3: Company Agent (Conversational)
The most novel integration mode. The personal agent hands off complex, dialogue-heavy tasks — warranty claims, mortgage applications, insurance disputes — to the business’s own AI agent. The conversation protocol supports text, structured data, status tracking, streaming via SSE, human handoff, and “direct conversations” (sub-conversations that lock the parent while open).
Each message carries a sender field (agent or human), so both sides always know whether they’re talking to an AI or a person. The context field carries locale, timezone, and user availability — critical for customer-service interactions.
For RPA architects: Agent-to-agent conversations are the next frontier beyond API integrations. If you’re building customer-facing automations — chatbots, support agents, or service desk workflows — this protocol mode defines how your agent will interact with your customers’ personal agents.
The Permission Model: Guest, Read, and Write Access
Poppy defines a tiered permission model that maps cleanly to enterprise access-control patterns:
| Tier | Authentication | What the Agent Can Do | Example |
|---|---|---|---|
| Blocked | N/A | Nothing — the business doesn’t participate | A business that opts out entirely |
| Guest | Agent identifies itself, no user sign-in | Read public information | Check stock, read return policy, view store hours |
| Signed-in, Read | OAuth sign-in, poppy:read scope |
View account information | Check order status, view balances, see appointments |
| Signed-in, Write | OAuth sign-in, poppy:write scope |
Make changes to the account | Start a return, rebook a flight, update payment method |
| Custom Scopes | OAuth sign-in, company-defined scopes | Fine-grained access to specific actions | addresses scope for address changes only |
The specification enforces several important constraints:
- Scopes are independent — granting
poppy:writedoes not automatically includepoppy:read - Users may approve fewer scopes than requested, so agents must check the returned
scopevalue - Re-signing in with additional scopes replaces the Account Token (the old one should be revoked)
- The
poppy:prefix is reserved for protocol-defined scopes
For enterprise scenarios, the beri.net analysis recommends a four-tier permission matrix: guest read (public data), signed-in read (account data), signed-in write reversible (returns, rescheduling), and signed-in write irreversible (purchases, transfers) — with the irreversible tier kept closed until payments arrive in a future spec version.
The Conversation Protocol: Structured Agent-to-Business Dialogue
The conversation protocol is one of Poppy’s most architecturally significant components. It defines a structured, bidirectional dialogue format that goes well beyond simple request-response patterns.
Endpoints
POST {endpoint}: Start a new conversationPOST {endpoint}/{id}/messages: Send a message (202 Accepted, or 201 Created for the first message)GET {endpoint}/{id}/events: Read events with long-polling (cursorandwait) or SSEPOST {endpoint}/{id}/handoff: Request a human agentPOST {endpoint}/{id}/close: Close the conversation
Message Structure
Each message carries:
id: Chosen by the sender, unique per user. Retries with identical content are idempotent.sender: Eitheragentorhuman— both sides always declare who’s speakingtext: Natural language contentdata: Structured payload for machine-readable detailscontext: Locale (RFC 5646), timezone (IANA), user availability
Event Types and Status Tracking
Conversations emit typed events: message, state (working/idle/queued/closed), authorization (sign-in triggered mid-conversation), user_requested (the business wants the user involved), direct_opened, and direct_closed. Agents skip unknown event types, which enables forward-compatible extensions.
The “direct conversation” pattern is particularly relevant for complex workflows: a personal agent can open a sub-conversation with a business agent for a specific sub-task (like a warranty claim within a broader support interaction), and the parent conversation is locked until the sub-conversation closes. Only one direct conversation can be open per parent at a time.
The Partner Ecosystem: Who’s In and Who’s Missing
The coalition behind Poppy expanded dramatically between the October 6 announcement and the October 9 draft publication. The partner list now spans financial services, retail, insurance, travel, technology, and media.
Founding Partners (October 6, 2026)
Meta, Sierra, Genesys, Instinct, NiCE, Rocket, Shopify, Stripe, Walmart
Design Partners (October 9, 2026)
Adyen, Atomic, Bank of America, BBVA, Chime, Cigna, Cloudflare, Comcast, DIRECTV, ElevenLabs, FOX, Gap Inc., GEICO, Hertz, Insurify, Klaviyo, Liberty Mutual, Mastercard, Nordstrom, Notion, Okta, OneSignal, OpenAI, PayPal, Plaid, SiriusXM, Synchrony, Target, United Airlines, Venmo, Visa, Wells Fargo, Zapier, Zendesk, 1Password
Notable Additions and Overlaps
OpenAI joining as a design partner is significant. The initial announcement conspicuously excluded OpenAI and Anthropic — Bret Taylor (Sierra co-founder and OpenAI board chair) had said he expected them to join. OpenAI’s inclusion in the October 9 design partner list signals convergence rather than fragmentation.
Cross-protocol participation is common. Shopify, Stripe, and Walmart sit on UCP’s governing council, Visa backs both TAP and the Poppy coalition, and Stripe co-developed ACP with OpenAI. This hedging suggests the industry expects a layered stack rather than a winner-take-all protocol war.
Who’s Not Listed
As of October 12, 2026:
- Anthropic is absent. As the creator of MCP, their absence from the identity layer is notable.
- Amazon is absent — unsurprising given the Muse conflict, but significant since Amazon controls roughly 40% of US e-commerce.
- Google is absent. Google backs UCP and A2A, and its Gemini agent platform is a potential competitor.
- No European-headquartered retailers or banks beyond Stripe (which is dual-headquartered in Dublin and San Francisco).
Protocol Comparison: Poppy vs. UCP vs. ACP vs. TAP vs. PACT
The agentic commerce protocol landscape is crowded. This comparison table maps each protocol’s scope, backers, and current status.
| Protocol | Primary Backers | Layer | Scope | Spec Status (Oct 2026) |
|---|---|---|---|---|
| Poppy (PAP) | Sierra, Meta, 40+ partners | Identity & Session | Agent authentication, consent, session management across any business task | Draft 0.1 published Oct 9 |
| UCP | Google, Shopify, Walmart, Target, Visa, Stripe, PayPal | Commerce Journey | Full purchase lifecycle: discovery → checkout → post-purchase | Available, announced NRF 2026 |
| ACP | OpenAI, Stripe | Checkout | Shared Payment Token for agent-initiated checkout (one-use, time-bounded) | Spec published; ChatGPT Instant Checkout retired Mar 2026 |
| Visa TAP | Visa, Cloudflare, Microsoft, Stripe, Shopify | Agent Identity + Payment | HTTP Message Signatures (RFC 9421) for agent identity and payment authorization | Launched Oct 2025; connected to ChatGPT Jun 2026 |
| AP2 | Google, PayPal | Payment Authorization | Signed user mandates with merchant ID, amount, expiry | Production-ready |
| PACT | Decagon, Instinct | Consent & Trust | A2A Agent Cards for discovery, scoped agent JWTs, signed receipts | Open-source spec at openpactprotocol.org |
| MCP | Anthropic → AAIF (Linux Foundation) | Tool Access | Agent-to-tool data plane: tools, resources, prompts | Production, broadest adoption |
| A2A | Google → AAIF (Linux Foundation) | Agent-to-Agent | Cross-vendor task delegation via task envelopes | v1.0 published; 150+ orgs in production |
The Complementarity Argument
Sierra positions Poppy as complementary to all of these. The argument is that MCP handles tool access, A2A handles agent-to-agent delegation, UCP handles the commerce journey, payment protocols handle settlement, and Poppy handles identity across all of them. The Forkast analysis frames it as: “the gateway becomes a protocol multiplexer that must support PAP, MCP, A2A, Visa TAP, and possibly ACP.”
The Overlap Reality
Despite the complementarity framing, there is real overlap in the identity space. Visa TAP also handles agent identity via HTTP Message Signatures. UCP could absorb the identity layer. PACT provides consent and trust with actual open-source code. The market hasn’t decided whether identity will be a separate protocol or a feature of the commerce and payment protocols.
What This Means for RPA and Automation Architects
1. The Shift From UI Automation to Authenticated API Access
Poppy’s three integration modes — website, APIs, and company agent — map directly to the evolution every RPA team is navigating. Today’s UI-based bots are the equivalent of Poppy’s “website” mode, but with none of the identity infrastructure. As businesses publish poppy.json files and expose MCP or OpenAPI endpoints, the value proposition of screen-scraping drops. Copilot-style agent architectures that already use structured APIs will have a natural migration path.
2. Agent-to-Agent Conversations Are a New Integration Pattern
The conversation protocol is something RPA architectures don’t typically model. When a personal agent negotiates a mortgage pre-approval with Rocket’s agent (as demonstrated at Sierra Summit), that’s not an API call or a web page navigation — it’s a stateful, multi-turn dialogue with structured data exchange, human handoff capability, and session persistence. If you’re building customer-service or sales automations, this pattern will become a requirement, not an option.
3. Credential Management Gets Standardized
One of the most painful aspects of enterprise RPA is credential management — storing passwords, rotating tokens, handling MFA. Poppy’s OAuth-based model replaces this with standard token flows. The specification requires that Account Tokens be stored as secrets and kept out of model context, messages, logs, and URLs. For regulated industries, this is a significant compliance improvement over the status quo of bots holding user passwords in credential vaults.
4. Permission Scoping Changes the Automation Design Pattern
In traditional RPA, a bot that logs in as a user inherits all of that user’s permissions. With Poppy, permissions are explicitly scoped — poppy:read, poppy:write, or custom scopes. This means automation architects need to design for minimum required scope rather than full user access. The specification even enforces this: users may approve fewer scopes than requested, so agents must handle narrowed permissions gracefully.
5. Your Automation Platform Is About to Become a “Company Agent”
If you build customer-facing automations — chatbots, IVR agents, support desk bots — you’re building what Poppy calls the “company agent.” Personal agents will arrive at your front door expecting to converse through the Poppy conversation protocol. Your automation platform needs to understand sessions, handle the sender field (is it talking to an agent or a human?), support direct conversations for sub-tasks, and gracefully hand off to human agents when needed.
Preparation Checklist: 10 Steps to Get Ready
Poppy’s reference implementation hasn’t shipped yet, but the draft specification is detailed enough to start preparing. Here’s what to do now:
- Audit your external-facing APIs. Inventory every API and webhook your automation interacts with. Which ones could expose a
poppy.jsonfile? Which currently require screen-scraping that a Poppy integration would replace? - Map your current OAuth infrastructure. Poppy sits on OAuth 2.0, JWTs, and DPoP. Assess whether your identity stack (Okta, Azure AD, Auth0) supports DPoP (RFC 9449) and device authorization grants (RFC 8628).
- Inventory credential vault dependencies. List every automation that stores user credentials. These are candidates for migration to Poppy’s token-based model. Prioritize the ones where credential rotation is already a pain point.
- Define your permission tiers. Use the four-tier matrix: guest read, signed-in read, signed-in write (reversible), and signed-in write (irreversible). Map your current automation actions into these tiers.
- Evaluate your MCP readiness. Poppy uses MCP as one of its API integration modes, with Bearer tokens scoped per server via RFC 8707 resource indicators. If you’ve already invested in MCP infrastructure, you’re ahead.
- Design for scope narrowing. Build your automations to handle getting fewer permissions than requested. This means checking the
scopevalue in every token response and degrading gracefully. - Plan your company agent architecture. If you run customer-facing bots, sketch how they’d expose a Poppy conversation endpoint: message handling, status tracking, streaming, and human handoff.
- Log agent identity separately. Start tagging interactions from automated agents differently from human users in your analytics. When Poppy goes live, you’ll want historical data on agent traffic patterns.
- Watch the reference implementation. Sierra has promised it “within about a month” of October 9. This is what you’ll build against.
- Track the coalition. OpenAI joined as a design partner. If Anthropic and Google follow, Poppy becomes the de facto identity layer. If they don’t, plan for supporting multiple identity protocols.
Frequently Asked Questions
Does the Personal Agent Protocol handle payments?
No. Draft 0.1 explicitly excludes payments. Sierra lists payment extensions as future work alongside push notifications and finer-grained permissions. For now, Poppy handles identity and session management; payment settlement stays with existing protocols like ACP, AP2, and the standard card networks. The extension mechanism is designed so industries can add payment capabilities without breaking the core protocol.
How does Poppy relate to MCP (Model Context Protocol)?
MCP is one of the API integration modes within Poppy. When a business publishes MCP server endpoints in its poppy.json, agents connect to those servers using Bearer tokens (since MCP’s transport doesn’t support DPoP). Poppy adds the identity and session layer that MCP itself doesn’t provide — authentication, consent, and cross-channel session persistence. They’re designed to work together, not replace each other.
Can a business block all AI agents under Poppy?
Yes. Poppy explicitly supports a “Blocked” tier where businesses choose not to participate at all. Businesses also have fine-grained controls: they can operate allowlists or blocklists by agent client_id, rate-limit specific agents, require agent registration before access, and revoke access at any time. The protocol is designed to give businesses control, not to force them open.
Is Poppy only for consumer shopping?
No, and this is a common misconception. While the Amazon-Muse commerce dispute triggered Poppy’s development, the protocol is designed for any agent-to-business interaction. Sierra’s blog gives examples ranging from retail returns to mortgage pre-approvals to flight rebookings. The partner list includes banks (Bank of America, Wells Fargo, BBVA), insurance companies (GEICO, Liberty Mutual, Cigna), airlines (United Airlines), and enterprise SaaS providers (Zendesk, Notion, 1Password). Any scenario where a personal agent needs to authenticate with a business and complete a task is in scope.
What’s the difference between Poppy and Visa’s Trusted Agent Protocol (TAP)?
TAP uses HTTP Message Signatures (RFC 9421) to sign agent identity and payment data into HTTP requests. It’s focused on the moment of payment — verifying that a specific agent is authorized to transact on a user’s behalf. Poppy covers the broader session — discovery, authentication, ongoing interaction across multiple channels. They could coexist, with Poppy handling the session and TAP handling the payment authorization within that session. Notably, Visa is a design partner for both protocols.
Key Takeaways
- Poppy (Personal Agent Protocol) is the first draft specification for an agent identity layer — it standardizes how AI agents discover businesses, authenticate on behalf of users, and operate within explicitly granted permissions.
- Draft 0.1 is technically detailed, specifying OAuth flows, JWT assertion formats, DPoP proof-of-possession, MCP Bearer token handling, a full conversation protocol, and an extension mechanism. This is a buildable specification, not a position paper.
- The coalition is massive and growing fast — from 9 founding partners to 40+ in three days, including major banks (Bank of America, Wells Fargo), payment networks (Visa, Mastercard, PayPal), retailers (Walmart, Target, Nordstrom), and notably OpenAI.
- Poppy sits alongside MCP and A2A, not above them. MCP provides tool access, A2A provides agent-to-agent communication, and Poppy provides the identity and session layer that answers “who is this agent and what can it do?”
- For RPA architects, the implications are structural — from UI automation shifting to authenticated API access, to credential management getting standardized, to your customer-facing bots needing to support the Poppy conversation protocol as incoming personal agents become a channel.
- Payments are not in Draft 0.1, but the extension mechanism is designed to add them. The protocol’s value is in the identity layer, not the settlement layer.
- Start preparing now — audit your APIs, map your OAuth infrastructure, evaluate MCP readiness, and design for scoped permissions. The reference implementation is expected within a month.
References
- Sierra. “Poppy: Personal Agent Protocol.” October 9, 2026. https://sierra.ai/blog/poppy
- Personal Agent Protocol Specification, Draft 0.1. https://personalagentprotocol.org/docs/spec
- Personal Agent Protocol Overview. https://personalagentprotocol.org/docs/overview
- Yahoo Tech. “Sierra and Meta’s Personal Agent Protocol Gives Commerce a Common Front Door.” https://tech.yahoo.com/ai/meta-ai/articles/sierra-meta-personal-agent-protocol-024451270.html
- Forkast. “The Personal Agent Protocol Is Not a Standard War — It’s the Missing Identity Layer.” https://forkast.news/the-personal-agent-protocol-is-not-a-standard-war-its-the-missing-identity-layer/
- beri.net. “Meta’s Personal Agent Protocol Signs Walmart Before It Has a Spec.” https://www.beri.net/article/meta-sierra-personal-agent-protocol-oauth-guest-read-write-access-vs-ucp-acp-trusted-agent-protocol-retail-banks
- eesel.ai. “Personal Agent Protocol Explained: What Shipped, What’s Promised.” https://www.eesel.ai/blog/personal-agent-protocol
- Datafloq. “Meta and Sierra’s Personal Agent Protocol Starts With Login, Not Payments.” https://datafloq.com/meta-and-sierras-personal-agent-protocol-starts-with-login-not-payments/
- DEV Community / TechAIWire. “Sierra and Meta Propose a Standard for Personal AI Agents.” https://dev.to/techaiwire/sierra-and-meta-propose-a-standard-for-personal-ai-agents-59p5
- cellcog.ai. “Personal Agent Protocol: What Meta and Sierra Announced.” https://cellcog.ai/blog/personal-agent-protocol/
- The Next Web. “Sierra Announces Personal Agent Protocol.” https://thenextweb.com/news/personal-agent-protocol-sierra-meta
- PPC Land. “Amazon Blocks Meta’s Muse AI Agent from Shopping on Its Site.” https://ppc.land/amazon-blocks-metas-muse-ai-agent-from-shopping-on-its-site/
- eco.com. “Agent Payment Protocols Compared.” https://eco.com/support/en/articles/14839407-agent-payment-protocols-compared
- AICoder. “Sierra and Meta Announce Personal Agent Protocol.” https://aicoder.com/news/news-20261007-sierra-meta-personal-agent-protocol-open-standard

