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. The fix is Schema.org's Action Schema and the potentialAction property.

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. Agents like Siri, Alexa, and LLM-driven tools will not just read about your products. They will buy them on behalf of users. 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 actually 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.

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.

For e-commerce, two action types matter most:

• BuyAction. For retail products.
• ReserveAction. For bookings, appointments, or rentals.

A BuyAction gives the agent the exact URL endpoint. Often a deep link to a pre-loaded cart or an instant checkout flow.

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 add the item to a cart instantly.

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/cart/add?sku=CM-12345&instant_checkout=true",
      "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

Major AI players are racing toward Large Action Models (LAMs). Adding Action Schema now formats your store so future models plug in natively. 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 clients running Action Schema in production. Pair it with nested JSON-LD for GraphRAG retrieval so the agent both sees the action and understands the entity context around it.

Cubitrek case study: BuyAction on a Norwegian e-commerce client

A Norwegian outdoor-gear retailer added BuyAction to 2,400 product pages in Q4 2025 alongside a clean OpenAPI spec for their cart and a Brand Hub at the root. We tracked agent traffic via server logs, AI-referrer headers, and Cubitrek's answer-engine listener.

The decisive metric was agent-to-cart latency. Competitors without Action Schema force the agent to scrape the DOM, find a "Buy" button, simulate a click, and parse the cart confirmation. Each step adds 1 to 3 seconds. Our client's 1.4s response time meant the agent picked them over slower competitors when the user said "buy the cheapest one with two-day shipping."

Next steps

Five 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. Pick clean URL structures for adding specific SKUs to a cart. ?sku=XXX&instant=true is a common pattern.
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, ChatGPT-User, PerplexityBot. Block training-only bots. 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.

Let's discuss it over a call.