"AI agents will shop for your customers" covers three very different situations. In one, an assistant compares running shoes and the shopper buys on your site. In another, an agent fills a cart and the shopper taps to confirm. In the third, an agent buys concert tickets the moment they go on sale, with nobody watching, because the shopper set a budget the week before.
Each of these asks something different of your store. In this article, we separate the three modes, show what each one needs, and explain why the order in which you prepare matters.
Three modes
- Assisted. The agent researches; the person decides and buys. This is what most AI shopping looks like today: a question, a short list, a click to a store.
- Supervised. The agent prepares the purchase; the person approves it. The agent picks the item, size and delivery option and builds the cart. The person sees the final basket and confirms.
- Autonomous. The agent buys on its own, within limits the person set in advance: which stores, which items, what budget. Nobody confirms the final basket.
The line between them is who approves the final purchase, and when. That line matters for liability, for fraud rules and for what you can measure.
The payment side already draws this line
The Agent Payments Protocol (AP2) makes the distinction explicit. Its documentation describes two kinds of signed mandates, each in two stages. An open mandate captures the user's constraints and goals before a specific cart exists, for autonomous execution. A closed mandate captures the authorization for one specific, finalized checkout.
In other words, a closed mandate is the supervised mode written down, and an open mandate is what makes the autonomous mode possible. AP2 also organizes its samples into "human present" and "human not present" flows. We covered the mandates in detail in what the payment protocol handovers mean for stores.
What the assisted mode needs
An assistant that only recommends needs to read and trust your store.
- Product name, price, currency and availability in the first HTML, plus complete structured data.
- Delivery times and return terms stated in numbers.
- Pages open to search and user agents, at robots.txt and at the firewall.
- One price everywhere: page, markup and feed.
What to do: treat this as the foundation. If the agent can't read a fact, it can't recommend you on that fact, and none of the later modes can work. Our guide to machine-readable product pages starts here.
What the supervised mode needs
An agent that builds a cart for a person to confirm needs to act on your store.
- An add-to-cart button that exists in the HTML and can be reached without hover menus.
- A cart link that is easy to find, and a checkout that doesn't require an account before the person sees the total.
- Variants as real form elements, each with its own price and stock.
- A total, with shipping and taxes, shown before the final step.
This is where our own field study found the stops: a checkout button the agent couldn't see, a cart link that was hard to find, a "sign in or continue as guest" screen. Shopify's ChatGPT integration shows the supervised shape on the platform side: shoppers find products in ChatGPT and complete the purchase through an in-app browser, with the merchant's checkout customizations carried over.
What to do: walk your path from product page to the last step before payment, as an agent would. See where agents drop the cart and guest checkout and AI agents.
What the autonomous mode needs
An agent that buys with nobody watching needs to rely on your store without a person to catch mistakes.
- Prices and stock that are exact at the moment of purchase, not a cached guess.
- A way to recognize the agent and what it is allowed to do, rather than a challenge built for humans.
- Fraud rules that don't treat a missing human signal as fraud by default; see agent orders are reaching your fraud filter.
- Clear rules for cancellation, returns and disputes, because the person may only see the order afterward.
What to do: for most stores, this is a watch item, not a project. Ask your payment provider and platform whether they plan to accept signed mandates, and how the evidence will be stored with the order. Our post who pays when a shopping agent gets it wrong lists the questions.
A quick self-check
Answer three questions for one best-selling product.
- Assisted: if you view the page source, can you find the price, stock, delivery time and return window as text? If not, an assistant can't recommend you on those facts.
- Supervised: can you go from that product page to the last step before payment without hovering, guessing a URL or creating an account? If not, an agent that builds a cart for a shopper will stop where you stopped.
- Autonomous: if an order for that product arrived at 3 a.m. with no browsing session before it, would your fraud rules let it through, and could you show what the shopper approved if they disputed it? If you don't know, that is the question to take to your payment provider.
Most stores will answer the first question with "partly", the second with "mostly" and the third with "we don't know". That is a normal place to be, and it tells you where to start.
Why the order matters
The modes stack. A supervised agent first has to do everything an assisted one does; an autonomous agent first has to do everything a supervised one does. A store that prepares for autonomous payments while its prices load in JavaScript has built the top floor first.
It also helps to be honest about measurement. Our own simulation runs in the supervised shape and stops before payment: it shows whether an agent can reach checkout, not whether it would complete an autonomous purchase. Nobody can test the autonomous mode on your store yet without real orders.
The bottom line
Agent shopping is three modes, not one. Assisted needs readable, trustworthy data. Supervised needs a cart and checkout an agent can operate. Autonomous needs prices, identity and dispute rules that hold up with nobody watching. Prepare them in that order, and every step pays off in the modes that already exist.
Specoria measures the first two: whether agents can read and trust your product, delivery and return data, and where a browser agent stops on the way to checkout. Start with a free readiness test.
Sources
- AP2, Agent Payments Protocol documentation, accessed October 21, 2026.
- Shopify, Millions of merchants can sell in AI chats, March 24, 2026.
- Specoria Insights, We sent AI agents shopping in a real browser 40 times
- Specoria Insights, AP2 moved to the FIDO Alliance and x402 to the Linux Foundation