By using this site, you agree to the Privacy Policy and Terms of Use.
Accept
RPABOTS.WORLD
  • RPA & Bot Automation
  • Agentic AI & AI Automation
  • AI Agents & Frameworks
  • uipath tutorial
  • UiPath
  • AI Agent Governance
Subscribe
  • Agentic AI
    • AI Agents & Frameworks
    • Agent Memory & RAG
    • Multi-Agent Systems
    • UiPath Agentic Automation
  • RPA
    • Topics
      • UiPath
        • uipath tutorial
  • Tools & Platforms
    • AI Builder
    • Robot Framework
  • Use Cases
  • Learn
    • UiPath
      • uipath certification
      • uipath interview questions
Reading: Personal Agent Protocol (Poppy): The Complete Guide to Agentic Commerce’s Missing Identity Layer for RPA and Agentic AI Architects (2026)
RPABOTS.WORLDRPABOTS.WORLD
Font ResizerAa
  • Agentic AI
  • RPA
  • Tools & Platforms
  • Use Cases
  • Learn
Search
  • Agentic AI
    • AI Agents & Frameworks
    • Agent Memory & RAG
    • Multi-Agent Systems
    • UiPath Agentic Automation
  • RPA
    • Topics
  • Tools & Platforms
    • AI Builder
    • Robot Framework
  • Use Cases
  • Learn
    • UiPath

Must Read

Databricks Agent Bricks: Enterprise AI Agent Platform Guide 2

Databricks Agent Bricks: Enterprise AI Agent Platform Guide

Tungsten Automation (Formerly Kofax): How the IDP Pioneer Is Betting on Agentic AI to Reinvent Enterprise Document Automation — Complete Guide for Agentic AI Architects (2026)

GitHub Universe 2026: Copilot Fusion, the Agent-First SDLC, and What It Means for Agentic AI Architects

Gartner Hype Cycle for Agentic AI 2026: The Complete Guide

Traversal AI: The $1B AI SRE Unicorn Reshaping How Enterprises Handle Production Incidents — Complete Guide for Agentic AI Architects (2026)

Follow US
RPABOTS.WORLD > Blog > Agentic AI & AI Automation > AI Agents & Frameworks > Personal Agent Protocol (Poppy): The Complete Guide to Agentic Commerce’s Missing Identity Layer for RPA and Agentic AI Architects (2026)
Agentic AI & AI AutomationAI Agents & Frameworks

Personal Agent Protocol (Poppy): The Complete Guide to Agentic Commerce’s Missing Identity Layer for RPA and Agentic AI Architects (2026)

Satish Prasad
By
Satish Prasad
3 weeks ago
Agentic AI & AI Automation AI Agents & Frameworks
No Comments
Share
40 Min Read
SHARE

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.

Contents
  • Table of Contents
  • What Is the Personal Agent Protocol (Poppy)?
    • What the Draft 0.1 Specification Covers
  • Why It Matters Now: The Amazon-Muse Conflict and the Identity Gap
    • Why RPA Architects Should Pay Attention
  • 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
    • Mode 1: Website (Browser-Based)
    • Mode 2: APIs (OpenAPI and MCP)
    • Mode 3: Company Agent (Conversational)
  • The Permission Model: Guest, Read, and Write Access
  • The Conversation Protocol: Structured Agent-to-Business Dialogue
    • Endpoints
    • Message Structure
    • Event Types and Status Tracking
  • 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
    • The Complementarity Argument
    • The Overlap Reality
  • 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

  1. What Is the Personal Agent Protocol (Poppy)?
  2. Why It Matters Now: The Amazon-Muse Conflict and the Identity Gap
  3. Where Poppy Fits in the Agentic Protocol Stack
  4. The Five Building Blocks of Poppy
  5. Technical Deep Dive: OAuth, JWTs, DPoP, and Session Lifecycle
  6. The Three Integration Modes: Website, APIs, and Company Agent
  7. The Permission Model: Guest, Read, and Write Access
  8. The Conversation Protocol: Structured Agent-to-Business Dialogue
  9. The Partner Ecosystem: Who’s In and Who’s Missing
  10. Protocol Comparison: Poppy vs. UCP vs. ACP vs. TAP vs. PACT
  11. What This Means for RPA and Automation Architects
  12. Preparation Checklist: 10 Steps to Get Ready
  13. Frequently Asked Questions
  14. Key Takeaways
  15. 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.

More Read

OpenAI Presence: The Complete Guide to Enterprise AI Agent Deployment (2026)
Microsoft Work IQ and the Work IQ MCP Server: The Complete Guide for Agentic AI Architects (2026)
AI Agents vs. Agentic AI: What’s the Difference?
The Rise of AI Agents: Transforming the Future of Technology 🚀

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 scopes
  • agent: Conversation protocol endpoints
  • apis: Array of API definitions (OpenAPI or MCP) with URLs and descriptions
  • web: Browser session endpoint for web browsing integration
  • extensions: 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_name and logo_uri for display
  • jwks_uri pointing to the agent’s public keys (HTTPS, same domain as client_id)
  • redirect_uris for OAuth callbacks
  • token_endpoint_auth_method: always private_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:

  1. 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_id as iss, the user’s opaque company-specific ID as sub, and a 128-bit random jti to prevent replay attacks.
  2. Renew: Repeat the request with the existing session_id. Expired sessions get fresh tokens without losing context.
  3. 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.
  4. Reuse: Exchange the Account Token for signed-in tokens in new or existing sessions.
  5. 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+jwt
  • alg: ES256 (ECDSA with P-256)
  • The agent’s public key in the jwk header
  • Claims: jti (unique), htm (HTTP method), htu (URL without query), iat, and ath (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:write does not automatically include poppy:read
  • Users may approve fewer scopes than requested, so agents must check the returned scope value
  • 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 conversation
  • POST {endpoint}/{id}/messages: Send a message (202 Accepted, or 201 Created for the first message)
  • GET {endpoint}/{id}/events: Read events with long-polling (cursor and wait) or SSE
  • POST {endpoint}/{id}/handoff: Request a human agent
  • POST {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: Either agent or human — both sides always declare who’s speaking
  • text: Natural language content
  • data: Structured payload for machine-readable details
  • context: 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:

  1. Audit your external-facing APIs. Inventory every API and webhook your automation interacts with. Which ones could expose a poppy.json file? Which currently require screen-scraping that a Poppy integration would replace?
  2. 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).
  3. 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.
  4. 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.
  5. 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.
  6. Design for scope narrowing. Build your automations to handle getting fewer permissions than requested. This means checking the scope value in every token response and degrading gracefully.
  7. 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.
  8. 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.
  9. Watch the reference implementation. Sierra has promised it “within about a month” of October 9. This is what you’ll build against.
  10. 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

  1. Sierra. “Poppy: Personal Agent Protocol.” October 9, 2026. https://sierra.ai/blog/poppy
  2. Personal Agent Protocol Specification, Draft 0.1. https://personalagentprotocol.org/docs/spec
  3. Personal Agent Protocol Overview. https://personalagentprotocol.org/docs/overview
  4. 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
  5. 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/
  6. 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
  7. eesel.ai. “Personal Agent Protocol Explained: What Shipped, What’s Promised.” https://www.eesel.ai/blog/personal-agent-protocol
  8. 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/
  9. 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
  10. cellcog.ai. “Personal Agent Protocol: What Meta and Sierra Announced.” https://cellcog.ai/blog/personal-agent-protocol/
  11. The Next Web. “Sierra Announces Personal Agent Protocol.” https://thenextweb.com/news/personal-agent-protocol-sierra-meta
  12. 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/
  13. eco.com. “Agent Payment Protocols Compared.” https://eco.com/support/en/articles/14839407-agent-payment-protocols-compared
  14. AICoder. “Sierra and Meta Announce Personal Agent Protocol.” https://aicoder.com/news/news-20261007-sierra-meta-personal-agent-protocol-open-standard
TAGGED:MCP
Share This Article
Facebook Print
BySatish Prasad
Follow:
Satish Prasad An NIT Kurukshetra alumnus and Intelligent Automation Architect, Satish brings 15+ years of battle-tested experience deploying over 100 production bots across Investment Banking and Logistics. Today, he bridges the gap between Data Analytics and the frontier of Agentic AI, building autonomous agents that transform complex business logic into intelligent automation. Catch his latest insights on the evolution of tech vibes and digital autonomy.
Previous Article Cisco Webex Agentic AI Platform: Dialog, Claude Managed Agents, and AI Agent 360 — The Complete Guide for Agentic AI Architects (2026)
Next Article AI Agent Security Incidents Are Escalating: The Complete Enterprise Governance Guide for Agentic AI Architects (2026)
Leave a Comment Leave a Comment

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.

You Might also Like

How to Build an Agentic Workflow with n8n and an LLM (2026 Tutorial) 4

How to Build an Agentic Workflow with n8n and an LLM (2026 Tutorial)

TL;DR n8n's AI Agent node (introduced in n8n 1.19.0) lets you build autonomous, tool-using AI…

By
Satish Prasad
26 Min Read

Appian Agentic Automation Platform: MCP Integration, Data Fabric, and Gartner #1 Rankings — The Complete Guide for Agentic AI Architects (2026)

Appian agentic automation explained — MCP integration, Data Fabric, Snowflake partnership, and why Gartner ranked…

By
Satish Prasad
29 Min Read

AI Agent Security Incidents Are Escalating: The Complete Enterprise Governance Guide for Agentic AI Architects (2026)

65% of enterprises report AI agent security incidents. Anthropic's Oct 2026 disclosure, CSA data, FTC…

By
Satish Prasad
39 Min Read
Building an Agent with Long-term Memory

Memory in AI Agents: Unlocking Contextual Intelligence with CrewAI and AutoGen

Understanding AI Agent Memory: A Human Analogy Artificial Intelligence (AI) agents, like human brains, need…

By
Satish Prasad
10 Min Read

Agent Memory and RAG: The Complete Developer Guide to Building AI Agents That Remember

Most agents you build today forget everything the moment a session ends. This guide teaches…

By
Satish Prasad
22 Min Read

Google Gemini Spark Auto Browse: The Complete Guide for Agentic AI Architects

Google Gemini Spark Auto Browse operates your real Chrome with logged-in accounts. Architecture, security, pricing,…

By
Satish Prasad
26 Min Read
RPABOTS.WORLDRPABOTS.WORLD
Follow US
  • About RPABOTS.WORLD
  • Write For Us
  • Contact-us
  • Privacy Policy
  • Cookie Policy
  • Disclosure