Action Schema: Implementing Potential Action for AI Agents

An AI agent lands on your product page. Does it know how to buy?

If the answer is no, you are missing the ground floor of zero-friction commerce. Schema.org's Action Schema and its potentialAction property can describe what an agent may do on a page. In 2026 they sit beside the commerce protocols agents use.

The first wave of AI in e-commerce was about assistance. Better search. Smarter chatbots. Personalized recommendations. We optimized our sites so humans and crawlers could read what we sell.

The next wave is different. It has started: Google lets merchants enable checkout in AI Mode and Gemini through the Universal Commerce Protocol (UCP), Microsoft launched Copilot Checkout in the US in January 2026, and ChatGPT surfaces products through OpenAI's Agentic Commerce Protocol (ACP). The question shifts from "is my site discoverable?" to "is my site actionable by machines?"

Standard schema is read-only

Current e-commerce structured data describes things. Price, availability, SKU. It is passive. It tells an agent what something is, not how to act on it.

For an AI to run a task, the site must declare executable pathways. That means moving from "this is a shoe" to "here is the API endpoint to buy this shoe."

SEO is still relevant, but it is changing. See is SEO still relevant? and semantic search in SEO. We have to treat the DOM and URL structure as a public API for agents.

What agents use in 2026

• Commerce protocols. UCP merchants publish capabilities in a JSON manifest at /.well-known/ucp and reuse their Merchant Center feeds. ACP gives ChatGPT structured catalog data.
• The page itself. Browser agents read screenshots, raw HTML and the accessibility tree, so semantic buttons, labeled fields and a stable layout matter.
• WebMCP. A proposed standard for exposing site tools to browser agents. Chrome opened an origin trial in Chrome 149 in June 2026.

Action Schema still states intent in a shared vocabulary. Treat it as a supplement to these, not a replacement.

potentialAction: the bridge

potentialAction connects a passive entity (a product) to an active capability (buying it). Embed it in your product markup and you tell any visiting agent that a task can run here.

If you are writing this markup for the first time, our free schema JSON-LD builder produces a valid block you can paste and adapt.

For e-commerce, two action types matter most:

• BuyAction. For retail products.
• ReserveAction. For bookings, appointments, or rentals. We publish one on our Humans for Agents page; a human confirms scope before any work starts.

A BuyAction gives the agent the exact URL endpoint. For example, a product page with the SKU preselected.

Implementing BuyAction

Your goal is to remove friction between intent and purchase. TikTok advertising shortens the path for human buyers. Action Schema does the same for machines.

When a user says "buy those running shoes I was looking at," the agent should not have to browse your site to find the checkout button.

Here is a JSON-LD example layered on existing product schema. Scenario: a "Premium Coffee Maker" page where you want an agent to land on the right SKU.

JSON

{
  "@context": "https://schema.org/",
  "@type": "Product",
  "name": "Premium Pour-Over Coffee Maker",
  "image": ["https://example.com/photos/coffee-maker.jpg"],
  "description": "Artisan glass pour-over coffee maker with reusable filter.",
  "sku": "CM-12345",
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/product/coffee-maker",
    "priceCurrency": "USD",
    "price": "49.99",
    "availability": "https://schema.org/InStock"
  },
  "potentialAction": {
    "@type": "BuyAction",
    "target": {
      "@type": "EntryPoint",
      "urlTemplate": "https://example.com/product/coffee-maker?sku=CM-12345",
      "actionPlatform": [
        "http://schema.org/DesktopWebPlatform",
        "http://schema.org/MobileWebPlatform",
        "http://schema.org/IOSPlatform",
        "http://schema.org/AndroidPlatform"
      ]
    }
  }
}

If your site runs on a flexible CMS, this is straightforward to add. See what is WordPress if you are weighing a migration.

The business case

Why prioritize this work now? First-mover advantage in the agent economy.

1. Frictionless checkout

Every click a human makes is a chance to bounce. A direct BuyAction endpoint lets agents skip navigation. They jump straight to the transaction.

2. A new sales channel

Treat agents as a new customer demographic. You already use AI SEO tools to win human traffic. Optimize for autonomous buyers too.

If your competitor's site is readable but yours is actionable, the agent picks the path of least resistance. That is your site.

3. Future-proofing

Agents already browse and act for users; Google documents a Google-Agent user agent for this, and protocols such as UCP, ACP and WebMCP connect them to stores. Same logic as monetizing AI chatbots. You are preparing infrastructure for automated revenue.

Pair Action Schema with infrastructure controls

Once your products expose BuyAction, agents will hit those endpoints at machine speed. That changes your infrastructure load profile. Without rate limiting, WAF rules, and the right entries in robots.txt, an over-eager agent can drain your CPU budget on a single afternoon.

See our robots.txt 2026 guide for AI crawler budgets for the configuration patterns we ship for agent traffic. Pair it with nested JSON-LD for GraphRAG retrieval so the agent both sees the action and understands the entity context around it.

Measure how agents get through your checkout

Browser agents without a protocol work from screenshots, the HTML and the accessibility tree, so every extra step is a chance to fail. Run an agent through your best-sellers, time how long it takes to reach a filled cart, and fix the slowest step first.

Next steps

Six steps to get started:

1. Audit high-velocity products. Make sure the base Product schema is clean. Run Cubitrek's Schema unit-testing pattern so regressions break the build.
2. Define transactional endpoints. Point actions at pages that preselect the SKU; keep the purchase behind a POST request and an explicit confirmation.
3. Pilot BuyAction on best-sellers. Validate structured data before scaling to the catalog.
4. Configure robots.txt and WAF for agent traffic. Allow OAI-SearchBot and PerplexityBot and block training-only bots. User-triggered agents (ChatGPT-User, Perplexity-User, Google-Agent) may not follow robots.txt, so rate-limit at the edge. See the robots.txt 2026 playbook.
5. Publish a Brand Hub. Agents resolve product entities back to a canonical source. Without it, two products with similar names collide.
6. Plan for the buyer being a machine. Action Schema is the transport layer of the machine-customer era, and once agents transact, the counterparty needs verifiable authority: that is what the Agent Passport standard provides.

Let's discuss it over a call.