Can an AI agent actually buy from your website? We tested it.

Short answer: Often, no — not yet, and usually for boring, fixable reasons. When we run a real browser agent through four basic buyer tasks (find a product, read its price, choose between variants, and begin checkout), it tends to stall at the same places a screen-reader user would: prices that only exist as rendered pixels, "Add to cart" buttons wired to JavaScript the agent can't trigger, modal login walls, and forms with no machine-readable labels. The shift toward agentic commerce — ChatGPT's Instant Checkout, merchant protocols — raises the stakes, because the question is moving from "does an assistant mention you" to "can an agent transact with you." Below are the four tasks, the failure modes we see most, and the fix for each.

Why this is suddenly a real question

For a decade, "can a machine use my site" was an accessibility concern that most teams under-prioritized. That calculus is changing because the machine is now a buyer's proxy. In late 2025 OpenAI and Stripe launched Instant Checkout in ChatGPT, powered by the Agentic Commerce Protocol — an open standard for letting an agent complete a purchase on a user's behalf, with Stripe issuing a scoped "shared payment token" so the agent never sees the buyer's card. Google has its own agent-payments work. The direction is clear: a growing slice of commerce will be initiated by software acting for a person.

Protocols like ACP smooth the payment handshake for participating merchants. But most of the buyer journey still happens on your ordinary pages — and that's where agents get stuck today. You don't have to adopt a protocol to be tested by an agent; you only have to have a website.

How we tested

We drove a real browser (headless Chromium under an LLM controller) — not a simulated one — at a set of storefronts and small-business sites, and recorded every step: the DOM the agent saw, what it clicked, where it stalled, and screenshots at each stage. Then we scored four tasks, pass/fail, several runs each so a single lucky attempt couldn't flatter the result (the same anti-noise discipline we apply to visibility scores). The four tasks are deliberately the minimum a buyer's agent must do.

The four buyer tasks (and where they break)

1. Find the product

The agent has to locate the right item from a natural-language goal ("a waterproof barn jacket, men's medium").

Common failures: search that only works through a JavaScript widget with no crawlable results page; category navigation built entirely from onClick handlers with no real links; infinite-scroll grids where products never appear in the DOM until a human scrolls.

Fixes: give search a real URL with server-rendered results (/search?q=barn+jacket). Make navigation real <a href> links. Ensure product listings exist in the initial HTML, not just after client hydration — the same rendering check from can ChatGPT read your website applies here.

2. Parse the price

The agent has to read the price as data, including currency, and tie it to the right variant.

Common failures: the price is composited from CSS pseudo-elements or sprite images, so it's pixels, not text; "from $49" with the real price hidden until a variant is chosen via script; tax/shipping ambiguity with no structured breakdown; A/B price experiments that render differently per session.

Fixes: render the price as plain text in the DOM, and back it with Product + Offer JSON-LD carrying price, priceCurrency, and availability. Structured pricing is the single highest-leverage fix here — see the JSON-LD that actually matters for AI.

3. Choose between options

The agent has to select a variant (size, color, plan) and understand what changes.

Common failures: custom dropdown widgets (divs styled as selects) that don't respond to standard interaction; variant state held only in client memory with no URL or DOM reflection, so the agent can't tell which option is active; out-of-stock variants that look selectable but silently fail.

Fixes: use native <select> and <input> controls, or ARIA-complete custom controls with real roles and states. Reflect the chosen variant in the URL or a readable DOM attribute. Mark unavailable options as disabled and expose stock status in structured data.

4. Start checkout

The agent has to add to cart and reach the first checkout step.

Common failures: "Add to cart" bound to a JS event with no form submission the agent can trigger; a mandatory account-creation or login modal before checkout; CAPTCHA on add-to-cart; a cart that lives in localStorage only, invisible to a fresh agent context.

Fixes: make add-to-cart a real form POST (progressive enhancement — JS can still intercept it for humans). Offer guest checkout. Move bot-protection challenges off the critical add-to-cart path, or allow-list verified agents. Persist cart state server-side so it survives a navigation.

Diagram — the four-task funnel with drop-off: A horizontal funnel of four stages — Find → Price → Choose → Checkout — with a tally of how many test runs survive each stage, narrowing left to right. Under each stage, a short stack of its top failure modes (e.g. under Price: "pixel price," "variant-gated price," "session A/B price"). The visual point: each stage sheds runs, and the biggest, cheapest wins are the ones that are pure rendering/markup problems rather than redesigns.

The pattern behind every failure

Notice what the fixes have in common. None of them is "redesign your store." Every one is make the real action available without JavaScript, and describe it in structured, machine-readable terms. That's the same property that makes a site accessible to screen readers and crawlable by search engines. Agent-readiness is mostly accessibility and structured data, finally given a business reason loud enough to get prioritized.

A useful gut check: turn off JavaScript in your browser and try to buy your own product. If you can't complete the four tasks with JS disabled, an agent that doesn't execute scripts can't either — and even script-running agents trip over the custom-widget and login-wall failures above.

What to do with this

You don't need to wait for a protocol mandate. Run the four tasks against your own site, in order, and fix the first failure before moving on — the funnel means an early break hides everything downstream. The wins are unglamorous (real links, text prices, native form controls, guest checkout) and they compound: the same changes that let an agent buy also make you more crawlable, more accessible, and more likely to be cited in the first place.

That's exactly the loop EchoRanked automates — we run the buyer tasks with a real agent, show you the replay at the precise step it failed, and name the exact change that fixes it. Watching an agent fail to buy from your own site is a more honest motivator than any score.

Frequently asked questions

Do I need to adopt the Agentic Commerce Protocol for an agent to buy from my site?

Not for most of the journey. Protocols like ACP streamline the payment handshake for participating merchants, but finding the product, reading the price, choosing options, and reaching checkout all happen on your ordinary pages. Fix those first — real links, text prices, native form controls, guest checkout — and you're agent-ready regardless of any protocol.

Why does an agent fail to check out when my site works fine for me?

Usually because critical actions depend on JavaScript or human-only interactions the agent can't perform: add-to-cart wired to a JS event with no form submission, custom dropdowns that ignore standard input, login or CAPTCHA walls before checkout, or a cart that only lives in browser storage. Try buying with JavaScript disabled to reproduce most agent failures.

What's the single highest-impact fix for agentic commerce readiness?

Expose your price and product details as both visible text and Product/Offer JSON-LD. Unparseable pricing is the most common hard stop, and structured data lets any agent read the price, currency, and availability unambiguously — while also helping you get surfaced in AI search.

Where to go next

Make your prices and products machine-legible with the JSON-LD that actually matters, and measure your results honestly using confidence intervals instead of a single score.