Skip to content
frmorettoPublic

About

Field report: how far an unsigned, anonymous agent gets on a live Shopify store via UCP/MCP. Read + cart are permissionless; checkout is gated by buyer consent. Reads-only, never completes a purchase.

Topics

Resources

Stars

2 stars

Watchers

0 watching

Forks

Repository files navigation

ucp-probe

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 calls complete_checkout. No payment instruments, no PII, no orders.


The finding (verified May 2026, against allbirds.com)

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 ⚠️ returns a reference but 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.


This is not a "first" — and the gate is universal

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.


Reproduce it

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.)


Two stages, two files

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.

How the tool surface works (capability negotiation)

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 only catalog.search / catalog.lookup → you get read tools only (create_cart returns "Tool not found").
  • ucp-agent-profile-full.json — also declares cart + 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).


Responsible use

  • Reads and ephemeral carts only. No purchases. The probe stops exactly where agents.md says agents must stop, and never calls complete_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-Agent does), and back off on 429.
  • Carts/checkouts created are ephemeral references that expire; nothing is charged.

References

Built as field research for Selling to Agents (Francesco Marinoni Moretto), a merchant-facing playbook on agentic commerce.

License

MIT — see LICENSE.

About

Field report: how far an unsigned, anonymous agent gets on a live Shopify store via UCP/MCP. Read + cart are permissionless; checkout is gated by buyer consent. Reads-only, never completes a purchase.

Topics

Resources

Stars

2 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages