What a permissionless agent can actually do on a live Shopify store.
A tiny, dependency-free research probe that walks Shopify's new agentic-commerce surface (UCP / MCP) on a live, named storefront, as an unsigned, anonymous agent — no API key, no installed app, no credentials of any kind (only the anonymous access Shopify's design permits), ~one file of code.
⚠️ This is a read + cart research probe. It does NOT complete purchases. It stops at Shopify's documented buyer-approval gate and never callscomplete_checkout. No payment instruments, no PII, no orders.
An anonymous agent, starting from the store's own public text files, can read the full catalog and create a cart — permissionlessly, by Shopify's own design. The wall is at checkout, and it isn't the merchant's access control. It's buyer consent.
| Step | Anonymous, unsigned agent | Corroborated by |
|---|---|---|
Discover (robots.txt → llms.txt → agents.md → /.well-known/ucp) |
✅ open | live |
search_catalog / lookup_catalog (read) |
✅ clean | Shopify docs — catalog access on all tiers |
create_cart (write) |
✅ clean (isError: false) |
Shopify Cart MCP doc: "Cart tools accept unauthenticated requests." |
create_checkout |
isError: true, status requires_escalation |
live |
pay / complete_checkout |
⛔ buyer consent required (requires_buyer_input, hands off via continue_url) — not called |
agents.md: "Checkout requires human approval." |
So: read and cart are open to anyone's agent on a live store. The checkout call bounces straight to a human-approval gate. Your access control is not what protects the transaction — the buyer's consent is, by protocol design.
UCP agents already exist: Shopify's own reference demos, open-source agents, and a credentialed team called CartAI that publicly documented the same read → cart → checkout flow on live Shopify merchants — at the Token tier (full Bearer credentials) — and hit the identical wall at complete_checkout (checkout_completion_ineligible / requires_escalation). See their thread: https://community.shopify.dev/t/seeking-guidance-on-complete-checkout-for-agentic-commerce-platform/34484.
That makes the buyer-consent gate universal across tiers — anonymous and fully credentialed agents both route the payment back to a human.
What this repo adds is the floor: how far an agent gets with no credentials at all, on a named store, and the emphasis that read and cart are permissionless. Treat it as a field report, not a first.
Pure Python 3 standard library — no pip install.
python probe.py # discovery + catalog read (default: allbirds.com)
python probe.py --cart # also create an ephemeral cart
python probe.py --cart --checkout # also attempt checkout -> shows the requires_escalation wall
python probe.py --store gymshark.com --query "running shorts"The script never calls complete_checkout. Other stores known live at time of writing: gymshark.com, kyliecosmetics.com. (Hydrogen/React storefronts like skims.com serve /.well-known/ucp but not the /llms.txt//agents.md text files; non-enrolled stores 404 everything.)
This repo holds two tools with different jobs. They are not variants of each other.
probe.py |
census.py |
|
|---|---|---|
| question | how far does an unsigned agent get on one store? | is the surface there at all, across many hosts? |
| method | discovery → MCP JSON-RPC → catalog read → cart | GET only |
| writes | creates an ephemeral cart | nothing |
| output | a walk, to stdout | .body + .headers per request, MANIFEST.sha256, results.json |
census.py does NOT do what probe.py does. No MCP call, no JSON-RPC, no POST,
no cart, no checkout. It requests fourteen paths per host and stores what comes back.
Run it with --domains panel.txt --out ./run-YYYY-MM-DD, or --store example.com for
a single host.
Its capture contract is inherited, not invented here: response headers, full TLS
chain, the request headers actually sent, TTFB and total, the redirect chain with a
status per hop, DNS answers as received, and a truncation flag. Politeness floor is
3 seconds per host, and reading robots.txt counts against that gate like any
other request.
robots.txt is honoured with a matcher written for the purpose, conformant to
RFC 9309 — longest match wins, * and $ supported, Allow wins ties. Python's
urllib.robotparser is not used: on the project's own fixture set it diverges 11
times out of 37, in both directions. It under-blocks (no */$ support — you would
request what the site forbade) and over-blocks (first rule instead of the most
specific — you would record a prohibition that is not there, and a fabricated null is
a null nobody protests about). python gates.py runs those fixtures.
DNS: NS records only, and that is a declared divergence. The inherited capture
contract asks for A, AAAA, CNAME, NS and MX as received. This census takes only NS.
MX mattered where contact classification was at stake — an own_domain email on a
domain whose mail lives elsewhere is a different thing — and this study does not
classify contacts; A/AAAA/CNAME feed no field here. The one use for DNS is attributing
the zone operator, without which the per-operator concurrency cap cannot be computed,
and NS alone gives that. The reduction is a safety measure, not a convenience: binary
parsing is the part that fails silently, and less surface beats one more test. Two
behaviours are fixed: a malformed, truncated or incomplete answer yields
non_rilevato and never a partial parse — a guessed nameserver would file the
host under the wrong operator's cap and nobody would notice; and a host whose NS does
not resolve falls under the global cap only, recorded as such, rather than being
excluded or assigned to a guessed operator. python gate_dns.py runs real captured
packets plus nine mutilations of each.
No field in this census is produced by a model. Every detector is rule-based, and
the cases a model would resolve — hand-written robots.txt, ambiguous platform
markers — go to incerto and ignoto instead of being interpreted. Capture is
deterministic by construction.
What runs from a fresh clone, and what does not. python gates.py runs the robots
matcher fixtures; python gate_dns.py runs the NS parser against real captured packets
and nine mutilations of each; python differential_robots.py regenerates
DIFFERENTIAL-ROBOTS.md. All three are self-contained. The platform-detector gate is
not: it needs the May 2026 capture set, which is not distributed here because those
files are copies of third-party pages. With the captures absent the gate reports NOT
RUN, which is not the same as failed — reporting a missing input as a divergence
would tell a reader the instrument is broken when the instrument was never exercised.
A declared limitation. census.py carries a platform detector, but its gate is
not blind: whoever wrote it had already read the three May captures it is tested
against, during the review that produced the design. The gate is a regression test,
not an independent validation. The three bodies are also 404 pages without stored
headers, so only the markup half of the detector is exercised offline. Derived fields
are therefore not written during a run — they belong to a separate stage with a
measured error rate, reviewed by someone other than their author.
UCP negotiates an agent's available tools as the intersection of what the agent's profile declares and what the merchant offers. So the profile you present decides your tool surface:
ucp-agent-profile.json— declares onlycatalog.search/catalog.lookup→ you get read tools only (create_cartreturns "Tool not found").ucp-agent-profile-full.json— also declarescart+checkout→ those tools appear and work unsigned (up to the buyer gate).
Both profiles are unsigned, self-hosted JSON — no key, no registration, no signature. Every MCP call still requires a profile URI (served as application/json; this repo's files are delivered via jsDelivr).
- Reads and ephemeral carts only. No purchases. The probe stops exactly where
agents.mdsays agents must stop, and never callscomplete_checkout. - No payment instruments, no buyer PII.
- Uses only the public, default endpoints Shopify ships on every enabled store.
- Identify your agent honestly (the default
User-Agentdoes), and back off on429. - Carts/checkouts created are ephemeral references that expire; nothing is charged.
- Shopify agent docs: https://shopify.dev/docs/agents
- Cart MCP (unauthenticated): https://shopify.dev/docs/agents/carts-and-checkout/cart-mcp · Auth & trust tiers: https://shopify.dev/docs/agents/profiles/auth-and-rate-limiting
- UCP specification: https://ucp.dev
- Token-tier precedent (CartAI): https://community.shopify.dev/t/seeking-guidance-on-complete-checkout-for-agentic-commerce-platform/34484
Built as field research for Selling to Agents (Francesco Marinoni Moretto), a merchant-facing playbook on agentic commerce.
MIT — see LICENSE.