Aizii Learn · AI Search

[← Back to Learn](https://aizii.ai/learn)

# How AI shopping actually works

AI shopping works in three moves. First, a shopper asks an assistant a question in plain words, and the assistant searches the web for pages that answer it. Second, the assistant reads the pages it finds, checks the price and stock it can verify, and compares the options. Third, the shopper either buys on the store site through a link, or the agent completes the purchase through a checkout connection the store has set up, with the shopper's permission. The assistant never invents the price or the stock. It can only work with what it can read and verify on the day the question is asked.

That third move is the one most stores have not set up yet. A store can be easy to find in AI answers and still be impossible to buy from through an agent, because finding and buying run on different machinery. Finding runs on crawlers and indexes. Buying runs on checkout protocols and payment handoffs.

## How it works

It starts with a question. A shopper types or speaks something like "trail running shoes for wet weather, size 10, under 150 dollars, in stock." The assistant turns that question into searches. Google describes this in its guide to generative AI features as retrieval augmented generation, where the system retrieves relevant pages from its search index and then reviews the information on those pages to generate an answer, and as query fan out, where the model issues several related queries at once to cover the angles of the original question. The answer that comes back carries links to the pages that support it.

For your store to be in that answer, two things have to be true. The pages have to be in an index the assistant can search, and the facts on the pages have to be readable. The index comes from crawlers. Each assistant runs its own. OpenAI runs OAI-SearchBot for ChatGPT search and GPTBot for training, and the two settings are independent, so a store can allow search while opting out of training. Perplexity runs PerplexityBot to surface and link sites in its results, and it states that PerplexityBot is not used to crawl content for training. Anthropic runs Claude-SearchBot to improve search result quality. Google runs Googlebot for search. If a crawler cannot reach a page, that page cannot be retrieved, and no amount of good copy fixes it.

Once a page is retrieved, the assistant has to trust the facts on it. The price, the stock status, the sizes, the shipping terms: these are the facts a shopping answer stands on. The assistant reads them from the page itself, from structured data on the page, and from product feeds the store supplies to shopping surfaces. Structured data means markup in a standard format, JSON-LD using schema.org vocabulary, that states the product name, the price, the currency, and whether the item is in stock, in a form a machine can read without guessing. A product feed is the same idea at catalog scale. When the page, the markup, and the feed disagree, the assistant has no way to know which one is right, so it may cite the wrong price, skip the product, or pick a competitor whose facts agree with each other.

Then comes the purchase, and here the path splits. The simple path is the one every store already has: the assistant shows the product with a link, the shopper clicks through, and checks out on the store site like any other visitor. The agent path is different. On the agent path, the assistant completes the purchase without sending the shopper to a checkout page, by talking to the store through a standard protocol. Two open protocols cover this today. Google's Universal Commerce Protocol, UCP, is an open standard that lets an AI surface such as AI Mode in Search or the Gemini app discover a store, build a cart, and complete a purchase, with the store remaining the merchant of record and keeping the customer relationship. The store publishes a profile at a standard address on its own domain, and the agent reads that profile to learn what the store can do. The Agent Commerce Protocol, ACP, developed by Stripe and OpenAI, is an open standard for programmatic commerce flows between buyers, AI agents, and businesses, and it covers physical and digital goods, subscriptions, and asynchronous purchases. With ACP, the business stays the merchant of record, and payment moves through a delegated token, so the agent never sees the shopper's raw card details. Stripe is the first compatible payment provider for ACP, with its Shared Payment Token.

Both protocols share one idea: the agent does not log in as the shopper and does not scrape a checkout form. It calls a defined checkout session on the store, the store returns totals and fulfillment options, the shopper confirms, and the payment provider settles the payment. The shopper stays in control, because the agent acts only with the permission the shopper gave for that purchase, and the store stays in control, because it decides which products can be sold this way and how orders are fulfilled. Any agent shops an Aizii-optimized site via MCP/API, which is the same principle stated plainly: the agent uses a defined interface the store provides, not a scraped page.

## The steps

**Step 1. Let the search crawlers in.** Open your robots.txt file and confirm that the search crawlers are allowed: OAI-SearchBot, PerplexityBot, Claude-SearchBot, and Googlebot. Keep the training decision separate. Disallowing GPTBot opts your content out of OpenAI training, and OpenAI states that each setting is independent, so blocking training does not block search. Check the vendor docs in Sources for the current token list before you copy a rule from any article, including this one.

**Step 2. Put the facts where an agent can read them.** Every product page should show the name, the price with currency, the stock status, and the available options in the visible page text, and should carry the same facts in Product structured data. The visible text is what the shopper sees. The structured data is what the agent reads without guessing. The two must agree, every time, including during a sale.

**Step 3. Keep one source of truth for price and stock.** Decide which system owns the price and the stock status, and make the page, the structured data, and the product feed all read from it. When a price changes, change it in that one place and check that all three outputs changed. A stale feed is worse than no feed, because the assistant will cite the stale price with confidence.

**Step 4. Decide how an agent may buy from you.** Talk to your developer about the checkout options for your platform. On Google surfaces, that means UCP, starting with the profile the store publishes and the checkout endpoints behind it. For ChatGPT, that means ACP, starting with a structured product feed. For your own brand agent, that means a defined API or MCP interface. Check the vendor docs in Sources for the current integration path. Do not build a checkout flow that depends on an agent filling in your web forms, because that is the brittle path the protocols exist to replace.

**Step 5. Set the permission rules before the first agent order.** Decide what an agent may do without asking, what needs the shopper to confirm, and what it may never do, such as changing an address or applying a discount code without approval. Write these rules down as part of the checkout setup, not as a note after launch.

**Step 6. Test the whole journey as a shopper would.** Ask an assistant for a product like yours, with a price limit and a stock requirement, and see what comes back. Then click through, and check that the price and stock on the landing page match what the assistant said.

## The machine-readable piece

This is a Product structured data block for a hypothetical product page. It uses the schema.org Product type with an Offer that states the price, the currency, and the stock status. Replace the placeholders in square brackets with your own values, and make sure the price and stock here match the price and stock on the visible page. The availability value InStock comes from the schema.org vocabulary, and the price currency uses the three letter code for the currency.

```
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Ridgeline Trail Shoe",
  "description": "Trail running shoe with a grippy outsole for wet weather.",
  "image": "https://[yourdomain.com]/images/ridgeline-trail-shoe.jpg",
  "url": "https://[yourdomain.com]/products/ridgeline-trail-shoe",
  "brand": {
    "@type": "Brand",
    "name": "[Your Brand]"
  },
  "offers": {
    "@type": "Offer",
    "price": "139.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://[yourdomain.com]/products/ridgeline-trail-shoe"
  }
}
```

Check the block after you add it: open the product page, confirm the visible price matches the price in the block, and confirm the stock status matches too. A block that disagrees with the page teaches the assistant not to trust either one.

## What it looks like when it works

On the page, a shopper sees the product name, the price, the sizes in stock, and the shipping terms, all in plain words, with no pop up in the way. Under the surface, the page carries structured data that states the same facts, the robots.txt file allows the search crawlers, and the product feed agrees with the page. When a shopper asks an assistant for a trail shoe under a set price in their size, the assistant can find the page, read the price and stock, and name the store with a link. If the store has a checkout connection set up, the assistant can also offer to complete the purchase, and the shopper confirms the order and the payment in the conversation. If the store has no checkout connection, the assistant sends the shopper to the product page, and the shopper checks out there. Either way, the price the assistant quoted is the price the shopper pays.

### A hypothetical example

Say you run a hypothetical trail running shoe store. Your best seller is a waterproof trail shoe, priced at 139 dollars with sizes 9 through 12 in stock. A shopper asks an assistant for waterproof trail shoes under 150 dollars in size 10, in stock, that ship to Seattle. Your robots.txt allows the search crawlers, your page shows the price and sizes in plain text, and your structured data states the same price and stock. The assistant retrieves your page, checks the facts, and recommends your shoe with a link, ahead of a competitor whose page hides the price behind a size selector the crawler cannot read. Nothing about the shoe changed. What changed is that every fact the assistant needed was readable, current, and in agreement.

### The fundamentals

These mechanics are shared across every store and covered in full in their own guides:

-   •The llms.txt format and a complete sample, see our [guide to writing a good llms.txt file](https://aizii.ai/learn/ai-search/how-to-write-a-good-llms-txt-file)
-   •The markup AI systems read to verify facts, see our [product schema guide](https://aizii.ai/learn/ai-search/how-to-add-product-schema-markup-for-ai-search)
-   •The complete crawler rule reference, see our [robots.txt guide for AI search](https://aizii.ai/learn/ai-search/how-to-write-robots-txt-for-ai-search)

## What this guide does not cover

This guide covers how AI shopping works from the shopper's question to the completed purchase: discovery, retrieval, comparison, and the checkout protocols. It does not cover building a UCP or ACP integration step by step, which is a developer job with its own vendor docs, and it does not cover the llms.txt file, the robots.txt rules for each crawler, or the product schema reference in full. Those are separate guides. It also does not cover monitoring: prices change, stock runs out, and feeds go stale, and a setup that works today can quietly break after a catalog update.

## Check your own store now

Run the free scan. One click, no signup, and it shows whether AI crawlers can read your store today: aizii.ai/aeo-scan

[Run the free scan](https://aizii.ai/aeo-audit)

## Sources

-   OpenAI, Overview of OpenAI crawlers (specific): [https://platform.openai.com/docs/bots](https://platform.openai.com/docs/bots)
-   Perplexity, Perplexity crawlers (specific): [https://docs.perplexity.ai/guides/bots](https://docs.perplexity.ai/guides/bots)
-   Google Search Central, Optimizing your website for generative AI features on Google Search (specific): [https://developers.google.com/search/docs/fundamentals/ai-optimization-guide](https://developers.google.com/search/docs/fundamentals/ai-optimization-guide)
-   Google, Universal Commerce Protocol guide (specific): [https://developers.google.com/merchant/ucp](https://developers.google.com/merchant/ucp)
-   Agentic Commerce Protocol, official site (specific): [https://agenticcommerce.dev](https://agenticcommerce.dev/)
-   Schema.org, Product type (specific): [https://schema.org/Product](https://schema.org/Product)

Note: links marked specific point to the page that supports the claim in this guide. Links marked general docs point to the vendor's general docs section for that topic, not to a page that proves every step. Check the vendor docs for the current path before relying on a menu name or click path in this guide.
