WebMCP for E-Commerce: How AI Agents Are Starting to Shop, Book, and Buy

Google's Chrome team confirmed this week that Shopify, Etsy, Instacart, Target, Expedia, Booking.com, Credit Karma, and Redfin are all experimenting with WebMCP — the browser-native standard that exposes website tools directly to AI agents. For commerce specifically, this is a more significant shift than it first appears.

WebMCP in a checkout flow isn't just a convenience feature. It's the infrastructure for AI-driven commerce: agents that can search your catalog, check inventory, apply discount codes, and confirm purchases — all through structured tools rather than trying to scrape and click through a UI.

What WebMCP actually exposes in a commerce context

In a standard commerce implementation, a page registers tools via JavaScript that describe what the agent can do on that page. For a product page, that might look like:

// WebMCP tool registration on a product page
navigator.mcp.registerTool({
  name: 'check_availability',
  description: 'Check if this product is in stock in a given size and color',
  parameters: {
    type: 'object',
    properties: {
      size: { type: 'string', enum: ['XS', 'S', 'M', 'L', 'XL'] },
      color: { type: 'string' },
    },
    required: ['size'],
  },
})

navigator.mcp.registerTool({
  name: 'add_to_cart',
  description: 'Add this product to the shopping cart',
  parameters: {
    type: 'object',
    properties: {
      size: { type: 'string' },
      color: { type: 'string' },
      quantity: { type: 'number', default: 1 },
    },
    required: ['size'],
  },
})

Once registered, these tools are discoverable by any MCP-compatible AI client running in Chrome. An agent doesn't need to parse the page HTML, click buttons, or fill forms — it calls check_availability and add_to_cart directly, the same way it would call any other MCP tool.

The typical agent shopping workflow

With WebMCP-enabled pages, an agent assisting with shopping operates very differently from a browser automation script. A user might say: "Find me red trail running shoes under $120 in size 10, and add the best-reviewed option to my cart."

Without WebMCP, an agent would try to navigate pages, parse product listings from HTML, infer availability from DOM state, and simulate clicks — all of which break constantly. With WebMCP, the workflow becomes a clean sequence of tool calls:

1. Agent navigates to the retailer's search page
2. Calls the page's search_products tool with parameters: {query: "trail running shoes", color: "red", max_price: 120}
3. Receives structured results with product IDs, prices, review scores, and availability
4. Navigates to the top result's product page
5. Calls check_availability with size 10
6. Calls add_to_cart
7. Calls get_cart_summary and surfaces it to the user for confirmation

Each step is explicit, auditable, and reversible. The agent presents the cart to the user before any purchase is finalized — which is also required by the MCP Apps spec for any side-effectful actions.

The missing layer: what agents need to know before they can act

WebMCP solves the action problem. It doesn't solve the knowledge problem.

Before an agent can shop effectively on your site, it needs to understand your catalog, policies, and brand. What's the difference between your "Pro" and "Elite" tier? What's the return window? Does your size M run small? Do you offer price matching? These questions aren't answered by a WebMCP tool — they require retrieving and synthesizing content from your site.

This is where indexed RAG comes in. An agent that can query your site's indexed content gets answers to these questions before it starts calling tools:

// Agent reasoning before calling WebMCP tools

// Step 1: understand the site's policies via indexed knowledge
const policy = await ask_site({
  domain: 'store.example.com',
  query: 'What is the return policy for shoes? Do trail running shoes run true to size?'
})
// → "30-day free returns. Trail shoes run half a size small — size up."

// Step 2: now make an informed product search
const results = await webmcp.search_products({
  query: 'trail running shoes red',
  size: '10.5',  // sized up based on what we learned
  max_price: 120
})

// Step 3: check availability and add to cart
await webmcp.check_availability({ productId: results[0].id, size: '10.5' })
await webmcp.add_to_cart({ productId: results[0].id, size: '10.5' })

WebMCP handles what the agent does. Indexed RAG handles what the agent knows. An agent with only one of these either acts blindly or knows but can't act.

What this means for commerce site owners

If you run an e-commerce site, WebMCP adoption by major platforms creates real pressure to implement both layers.

The action layer (WebMCP): Register structured tools on your product, cart, checkout, and search pages. Prioritize the tools agents will call most: search, availability check, add to cart, order status. The Chrome DevTools panel in Chrome 149+ shows you exactly what agents see when they visit your pages — use it to verify your registrations.

The knowledge layer (indexed RAG): Make your product catalog, policies, sizing guides, and FAQs queryable via MCP. An agent helping a user shop will want to pull this context before it starts calling WebMCP tools. If your knowledge isn't indexed, agents will either hallucinate answers or skip your site for one where they can get reliable context.

The combination of the two is what makes a site genuinely agent-ready for commerce — agents can understand your products AND do something about it.

The travel and financial verticals

Commerce isn't the only vertical moving fast here. Google's announcement included Expedia, Booking.com, Credit Karma, and TurboTax — travel and finance.

For travel, WebMCP tools look like: search_flights, check_hotel_availability, get_pricing, hold_reservation. The knowledge layer answers: "What's the cancellation policy? Is this hotel pet-friendly? What's included in the Plus tier?"

For financial services, the tools are more constrained by compliance — read operations like get_account_balance, get_credit_score, and compare_offers are natural starting points. Side effects — actual transfers or applications — will follow the MCP Apps confirmation pattern where the user approves each action explicitly.

The timing question

WebMCP is in an origin trial that runs through Chrome 156. Early adopter investment now is low — registering tools is a few dozen lines of JavaScript. The risk of waiting is being behind the curve when WebMCP ships stable and agents start routing commerce decisions through it.

The practical starting point is to pick the two or three tools that matter most for your use case, implement them on the pages where users make decisions, and verify them in Chrome DevTools. You don't need a comprehensive tool suite on day one — you need enough for an agent to complete the core user journey.

For most commerce sites, that core journey is: search → availability → add to cart → summary. Start there, instrument it with WebMCP, and make sure your product knowledge is indexed so agents arrive informed.