Sierra published version 1.0 of Personal Agent Protocol on 13 November, and the distribution attached to it is the part worth your attention: every Shopify store now publishes the protocol’s discovery file automatically, and Meta’s Muse agent looks for that file first on every site it visits. The file sits at /.well-known/poppy.json, and it is not a sitemap, a feed, or an SEO trick.
It answers a question your site has never been asked before: an AI agent has arrived on behalf of a customer, and what is it allowed to do here?
I run two sites that sell nothing through a cart, and I still looked. The moment an assistant can transact for a person, “can this be read by a machine” stops being an SEO question and becomes an access-control question.
The short version
- Poppy is an open protocol (Apache 2.0) for how a personal AI agent identifies itself to a company and asks what it may do.
- The company answers with one file at
/.well-known/poppy.json, listing channels, capabilities and sign-in options. - Shopify turned it on for every merchant with no opt-in, so the file is already live on millions of stores.
- It does not move money or change checkout. That still belongs to Universal Commerce Protocol (UCP).
- The spec is released as 1.0 but still labelled draft, so treat it as a moving target and do not build a business on it yet.
What Poppy actually is
Poppy is short for Personal Agent Protocol. It is the handshake that happens before anything else, and it has three parts that matter to a site owner.
Discovery. A company publishes the JSON file at a fixed path. The file names the company, lists the ways an agent can reach it (an API described by OpenAPI or MCP, the company’s own agent, or plain web browsing), and lists the OAuth scopes an agent may request. Sierra built it on existing standards rather than inventing new ones, which is why the file is short and boring.
Sessions. When an agent visits, it sends a signed Session header identifying itself and a pseudonymous customer ID. According to the specification, that ID is stable at your company but different at every other company, so you can recognise a returning agent customer without ever learning who they are. That is a better privacy story than most tracking scripts on your site right now.
Sign-in. If a task needs the customer’s account, standard OAuth handles it. The customer signs in on your page and grants specific scopes, or the agent shows a link and a code they open on another device. The agent never holds the password, and access can be revoked.
The clever part is the scope_hints block. Each scope can be tagged as changing nothing, making a reversible change, or being irreversible, and as touching personal data. An agent reading it knows which actions must interrupt the customer for a yes.
What the file looks like
Here is the shape of a Shopify-served file, trimmed to the parts that matter:
{
"protocol_version": "0.4",
"organization": { "name": "Your Store", "domain": "www.yourstore.com" },
"auth": {
"scopes": {
"dev.ucp.shopping.checkout:manage":
"Lets the agent prepare checkouts as the signed-in customer."
},
"scope_hints": {
"dev.ucp.shopping.checkout:manage": {
"changes": "irreversible",
"personal_data": true
}
}
},
"agent": {
"protocols": [
{ "type": "ucp", "endpoint": "https://www.yourstore.com/.well-known/ucp" }
]
},
"web": {},
"extensions": { "ucp": [{ "version": "1" }] }
}
Notice what is missing: no product data, no prices, no stock. Everything commercial lives in the UCP profile it points at. And the version in Shopify’s file was still 0.4 on 14 November, the day 1.0 shipped.
What it does not do
This is where I would push back on the launch-week enthusiasm.
- It does not handle payments. Sierra’s roadmap lists payments, push notifications and attachments as open. Checkout stays with UCP.
- It does not enforce anything by itself. The spec includes a
web.disabledflag to ask agents not to browse your site, and says plainly that this is not enforceable. It is a polite request, not a wall. - It is not a finished standard. Sierra calls it 1.0 while the specification and implementation kit still label the document draft 1.0, permitted to change in ways that are not backward compatible.
- It is not evidence that agents are already shopping for you. Distribution is real: more than 175 countries on Shopify, and Muse, which The Next Web reports has passed ten million people who set it up. But an agent that can discover your store is not an agent that will show up tomorrow.
There is also a version gap worth knowing about if you run a store. One index that scanned 129 Shopify retailers on 14 November found the file on 104 of them, all declaring 0.4. The 1.0 spec makes a description field mandatory on every entry under agent.protocols, and the Shopify files do not have one. An agent built strictly to 1.0 may read those files and find nothing it trusts. The same scan found 13 of 14 custom, headless storefronts returning a 404. If you pay someone for a headless build, that is a question to send them this week.
If you sell on Shopify, check four things
| Check | Where | What a bad answer means |
|---|---|---|
| The file exists | https://yourdomain/.well-known/poppy.json |
404 on a Shopify Online Store means the theme or domain is not what you think it is. |
| The domain matches | organization.domain in the file |
A file that names a different host cannot speak for your domain. |
| The UCP profile resolves | /.well-known/ucp |
Poppy is only pointing at something broken, and the agent has no store to shop. |
| Your policies are machine-readable | Returns, shipping, contact page | An agent quoting an outdated return policy to a customer is your problem, not its. |
If you run a WordPress site with nothing to sell
Then you have no file to publish and no reason to rush. The kit lets any company implement Poppy itself, but I would not hand-roll that on a client site for a protocol still labelled draft. Watch it for a quarter.
What you can do now is decide, deliberately, what machine traffic your site welcomes. Two things I did on my own sites after reading the spec:
Write the policy down. Whether you want AI crawlers reading your pages is a business decision, not a plugin toggle. If agent traffic might bring customers, do not block it, and say plainly on the page what you do and who you serve. If you do not want it, block it on purpose and remember robots.txt is a request, not an enforcement mechanism.
Read your own access log. An agent arriving with an identifying header looks different from a scraper that pretends to be Chrome. I keep a rolling habit of scanning for unfamiliar user agents, and it is the same muscle I wrote about in how to read access logs and spot a brute-force attack. New agents will show up there before they show up in your analytics, because most analytics tools either drop them or file them under “direct”.
This is the mirror image of what to let an AI agent touch in your WordPress admin. That was outbound, an agent holding your credentials. This is inbound, an agent holding someone else’s. Same question, opposite direction: decide the permissions yourself, in writing, before you need them.
What I would do this week
- If you run a Shopify Online Store, open your
poppy.jsonand your/.well-known/ucptoday. Five minutes, and it tells you whether your store is legible to the agent layer at all. - If you run a headless storefront, test both paths on the customer-facing domain, not the admin one.
- If you run any other kind of site, write one sentence on your position on AI crawlers and put it where you will find it. Mine: reading is fine, quoting with attribution is fine, anything needing an account asks first.
- Check that the policy page an agent would quote actually matches what you do in practice.
The uncomfortable part is that a protocol file is now a public statement about your business, in a format no customer reads but every agent does. The comfortable part is that it is still yours to write. Assume the first version will be wrong in a way that only shows up in the logs.









