What is agentic commerce? A builder's guide to agent-ready storefronts

A buyer tells an AI assistant to find a running shoe under $120 and order it. The agent queries catalogs, compares prices and availability, picks one, and calls checkout. The buyer never opens a product page.

For that to work, the agent has to read a catalog written for browsers, prove it isn't a scraper, and complete a purchase with nobody watching the session. Most storefronts can't support any of the three.

This guide covers what agentic commerce means, the five properties that make a site transactable by machines, and which layers of the stack are stable enough to build against today.

Key takeaways:

• Agentic commerce is the use of AI agents that research, compare, and complete purchases on a buyer's behalf, with limited input at each step.

• Agents sent onto live sites to sign up, integrate, and pay fail against 99% of the web, by Ora's estimate.

• Agent-readiness is five architectural properties covering how a storefront exposes product data, accepts a checkout call, and verifies a non-human caller.

• AI-referred traffic converted 42% better than non-AI traffic in March 2026, reversing a 38% deficit a year earlier. It still made up under 1% of visits for most retailers.

• The protocol layer is the least settled part of the stack, and the storefront requirements underneath it carry over whichever specification wins.

Copy link to headingWhat is agentic commerce?

Agentic commerce is an approach to buying and selling in which AI agents act on behalf of individual or business buyers to research, compare, and complete purchases, with limited manual input at each step. The buyer sets the goal. The agent executes it.

Every major definition describes the same relationship. The agent acts as the buyer's proxy, running from discovery through to purchase without checking in at each step, and none of them says what the merchant has to expose for that to work. Delegation also arrives in degrees rather than all at once. McKinsey's automation curve sets out six of them, from rule-based reordering that involves no agent at all up to networks of agents negotiating with each other. It expands selectively rather than uniformly, shaped by trust and by how much a buyer stands to regret a bad purchase.

Copy link to headingHow agentic commerce differs from conversational and autonomous commerce

Conversational, agentic, and autonomous commerce get used interchangeably. They describe three different systems, and the one thing that separates them for an engineering team is which party makes the checkout call:

Conversational and autonomous commerce both leave the merchant's interface where it is. Agentic commerce doesn't. Something that isn't a person arrives at your checkout endpoint carrying a payment method and a set of instructions, and either your endpoint can handle that or it can't.

Copy link to headingWhy agentic commerce matters for storefront engineering teams

Agent traffic converts better than the traffic it replaces, and there still isn't much of it. Both are true right now, which is what makes the timing call a hard one:

• A real conversion premium: AI traffic converted 42% better than non-AI traffic in March 2026, a record high across more than 1 trillion U.S. retail site visits. A year earlier it converted 38% worse.

• A very small base: AI still accounted for less than 1% of total traffic as of May 2026. It reached a quarter of referral traffic for some retailers, but referral is a slice of the total.

• Research over purchases: Product pages make up roughly 87% of agent requests, while payment and checkout make up 2.2%. Most agent traffic today is research, not buying.

• Product pages as the weak spot: The average U.S. retail homepage scores 75% readable by machines and category pages 74%. Product pages score 66%, the lowest of any page type and the one an agent has to parse to recommend anything.

• A high live failure rate: Agents told to sign up, integrate, and pay on real sites fail against 99% of the web. That test covers signup and integration, not only checkout.

The premium makes sense, since the buyer compared options before ever clicking through. The browse-to-buy gap is a different problem. Agents stall at the product page because that's as far as most storefronts let them go, and that part is fixable.

Copy link to headingCore components of an agent-ready storefront

Agent-readiness isn't a feature you turn on. A storefront that serves machine callers does five things a browser-only storefront doesn't, and each one covers a different place an agent run breaks.

Copy link to headingStructured product data on every product page

An agent can't recommend a product it can't read, and scraping price and availability out of rendered HTML is unreliable. Every product page should carry a <script type="application/ld+json"> block of schema.org Product data, generated by the same code path that renders the page.

For Google product snippets, provide name and at least one of offers, review, or aggregateRating. Commerce pages should generally include an Offer with a numeric price, ISO 4217 priceCurrency, and a schema.org availability value.

Copy link to headingA machine-readable catalog feed

Page-by-page crawling doesn't scale to a full catalog, and it gives the agent a stale view of inventory between crawls. A feed gives it the whole catalog at once.

The product feed specification accepts UTF-8 tab-delimited .txt or .tsv files and comma-delimited .csv files, gzip compression supported, one product or variant per row. Every row needs id, title, description, link, image_link, availability, price, and brand, with price written as an amount followed by a three-letter currency code, plus a valid gtin or mpn unless you declare the product has no identifier. An existing Google-compatible feed can be submitted without renaming columns.

JSON, XML, RSS, and Atom sources sit outside that compatibility path, which surprises teams who assumed a JSON feed would be accepted. An llms.txt file at the domain root is a lighter separate convention, a curated Markdown index for language models, and it has no effect on rankings.

Copy link to headingA checkout path that holds no browser state

Most storefronts stop being usable at this step. A checkout that depends on cookies, a JavaScript session, or an external redirect is a checkout an agent cannot complete, and the agent moves on to a merchant whose checkout it can call.

A machine-completable checkout accepts requests without browser state, avoids redirects to third-party domains, and runs on the same data layer as the human storefront.

Two open specifications define this surface. The Agentic Commerce Protocol (ACP), from Stripe and OpenAI, covers agentic checkout, cart and feed, delegated payment, delegated authentication, and order webhooks. The Universal Commerce Protocol (UCP), launched by Google with Shopify, Etsy, Wayfair, Target, and Walmart, spans the full shopping lifecycle. Under both the merchant stays the system of record for orders, payments, taxes, and compliance, and neither removes the need for the endpoint itself.

Copy link to headingCryptographic identity for a non-human buyer

A User-Agent header verifies nothing. Spoofing it takes one line, and shared cloud infrastructure means IP reputation produces false positives on legitimate agent traffic. Block on those signals and you reject real buyers while admitting real scrapers.

Web Bot Auth solves the identity problem cryptographically. Agents sign their requests with Ed25519 keys under RFC 9421 and publish a JSON Web Key Set at /.well-known/http-message-signatures-directory for merchants to verify against. A signature either validates or it doesn't, so admitting one named agent while rejecting everything else on the same route becomes a policy decision rather than a guess.

The tradeoff is coverage. Signed requests only identify agents whose operators have adopted the standard, so verification has to fail into a deliberate decision about unsigned traffic rather than into an error.

Copy link to headingCompute and rate-limit behavior built for machine clients

Agent sessions are I/O-bound and multi-step. The agent calls a product endpoint, waits, calls a cart endpoint, waits, then calls checkout. A compute layer that cold-starts between those steps adds latency at every hop of a run that already involves several.

Machine clients also need an explicit rate-limit contract. An agent handed HTTP 429 with a clear signal backs off and retries. A timeout, a silent throttle, or a generic 500 leaves it unable to distinguish "slow down" from "broken," so it either hammers the endpoint or abandons the session.

Those five properties are the architecture. The operating practices that keep them working are a separate problem.

Copy link to headingBest practices for agentic commerce readiness

Structured data and a callable checkout get an agent through the flow once. Keeping that true as the catalog changes is a different job, and these four are much cheaper to build in now than to bolt on later.

Copy link to headingServe one source of truth to every surface

Your product page, your feed, and your checkout API will eventually disagree about price, availability, or the return window. Agents cross-check those sources, and when they conflict the agent can't tell which one is right. Its safe move is to drop you from the answer.

A separate "AI API" is the usual shortcut into that mess. It looks clean in the first sprint and breaks in the third, when a price change lands in the storefront but not in the agent surface. A different response shape for agents is fine. A different source of truth isn't.

Copy link to headingVerify agents instead of blocking all automation

Blanket bot blocking made sense when all automation was scraping. It doesn't now. Most agents hitting your product pages are working for a real person who asked a real question, so a blocked request is a lost sale rather than a prevented attack.

Cryptographic identity turns that into a per-agent call instead of a per-category one. You admit the shopping agents you want, rate-limit the ones you're unsure about, and reject unsigned automation on your transactional routes rather than across the whole site.

Copy link to headingFail loudly under load

An agent that gets throttled silently retries immediately, which makes the load worse and kills the run with nothing in the logs to explain it. A timeout tells the agent nothing either, so it has no reason to come back and try again later.

Inventory gaps, expired sessions, and declined tokens work the same way. A specific status code costs you one line and tells the agent whether to wait, retry, or go somewhere else.

Copy link to headingSegment agent traffic before optimizing for it

Agent requests show up in analytics as anonymous traffic with almost no click-throughs. They look like noise, so they get filtered out of the exact reports that would justify doing any of this work.

The fix is classifying every request at the boundary as human, agent, or bot, then reporting the three separately. Once you can see which product pages agents fetch and where their sessions stall, readiness stops being a bet and starts being a measurement.

Copy link to headingWhat's still unsettled in agentic commerce

The storefront requirements are stable. The layer above them isn't, and three questions are still open.

Copy link to headingWhere the checkout actually happens

For now, on the merchant's own site. The clearest evidence is what happened when the largest player tried to move it somewhere else.

OpenAI launched Instant Checkout on September 29, 2025, limited at first to single-item purchases from U.S. Etsy sellers, with Shopify merchants following. It pulled the feature back on March 4, 2026, and by late March had replaced it with a discovery-first experience that routes shoppers to merchant apps and sites. The gaps were operational. State sales tax remittance had no system behind it, inventory infrastructure was never built, and estimates of how many Shopify merchants ever went live run from about a dozen to around 30.

Shoppers trust retailer-owned agents roughly three times more than third-party agents to complete a purchase, and Salesforce, which sells into both sides of this market, put it the same way publicly. Its Agentforce Commerce GM Nitin Mangtani said AI platforms will heavily influence referral traffic to brand sites, but that "commerce itself will happen predominantly on owned and operated properties."

Copy link to headingWhich protocol to build against

There isn't one answer yet. ACP and UCP are both live, both open, and they expose different checkout surfaces, so a merchant that wants to be reachable from both ChatGPT and Google's AI Mode implements against two. Reading the fragmentation as a race with one winner gets the layer wrong. Adjacent protocols cover distinct jobs rather than competing, with the Model Context Protocol (MCP) handling tool access, the Agent-to-Agent protocol handling agent-to-agent communication, and the Agent Payments Protocol handling payment authorization with verifiable credentials.

The specs are also younger than the announcement volume suggests. Returns and exchanges workflows, tax configuration, and fraud modeling details all sit out of scope in the ACP checkout RFC, so the parts of commerce that generate the most operational work remain merchant problems by design.

Copy link to headingHow often agents finish the job

Less often than the launch announcements imply. On WebArena, a benchmark of 812 long-horizon tasks across self-hosted replicas of real web applications, the original GPT-4 agent completed 14.41% against a human baseline of 78.24%. Tracked leaders reached the low seventies by mid-2026, a large improvement that still sits short of the human number, and the scores move with the agent scaffold rather than the model alone.

None of those three questions changes what a storefront has to expose. That's the part worth building now.

Copy link to headingHow Vercel supports agent-ready storefronts

Agent-readiness touches the request boundary, the compute layer, and the rendering path, and wiring those together as separate integrations is where most of a project's time goes. Vercel covers all three with primitives that already exist in the framework, which leaves the commerce logic as the part a team writes.

Copy link to headingVerified bot identity at the request boundary with BotID

You need one route that lets a named shopping agent through and turns everything else away. A CAPTCHA won't do it, because the agent you want to admit can't solve one either. An allowlist of user agents and IP ranges falls behind as soon as an agent ships a new version.

BotID checks callers against Vercel's verified bot directory and returns the identity fields alongside the bot determination, and Vercel's bot verification supports Web Bot Auth, so cryptographically signed agents resolve through the same path.

Gating a route on a single named agent takes a few lines in the handler:

const { isBot, verifiedBotName, isVerifiedBot, verifiedBotCategory } = botResult;
const isOperator = isVerifiedBot && verifiedBotName === "chatgpt-operator";
if (isBot && !isOperator) {
  return Response.json({ error: "Access denied" }, { status: 403 });
}

The same layer held through the 2025 Black Friday weekend, when Vercel blocked 415,683,895 bots and verified 2,408,122,336 humans against 115.8 billion total requests.

Copy link to headingConcurrency for multi-step agent sessions with Fluid compute

A traditional serverless model allocates one instance per invocation, so an agent's cart-then-checkout sequence pays a cold start at every step while the instance sits idle waiting on a database or a payment provider.

Fluid compute lets multiple invocations share a single function instance instead. It has been the default for new projects since April 23, 2025, and it applies bytecode caching and function pre-warming on production deployments to reduce cold start effects on the routes agents hit first.

Copy link to headingAn explicit rate-limit contract with the Vercel Firewall

Rate limiting is the control teams add after the first traffic spike, usually as ad hoc logic inside a handler that doesn't share state across regions. It passes review and fails under real load.

The Rate Limiting SDK moves the rule into the Vercel WAF (web application firewall) and leaves the response shape in your code, so an endpoint can return a clear 429 rather than a timeout:

import { checkRateLimit } from '@vercel/firewall';

export async function POST(request: Request) {
  const { rateLimited } = await checkRateLimit('update-object', { request });
  if (rateLimited) {
    return new Response(JSON.stringify({ error: 'Rate limit exceeded' }), {
      status: 429,
      headers: { 'Content-Type': 'application/json' },
    });
  }
  // Otherwise, continue with other tasks
}

Adding a Retry-After header to that response is an HTTP convention rather than a platform requirement, and it gives well-behaved agents a concrete interval to wait before retrying.

Copy link to headingStructured data co-located with the product data fetch

Distance is what lets schema drift happen. When the JSON-LD (JavaScript Object Notation for Linked Data) lives in a separate template, a layout file, or a content management field, nothing forces it to update when the pricing logic changes.

The Next.js App Router renders JSON-LD inside the Server Component body, next to the fetch that supplies the page, so both read one object. The same co-location holds in Nuxt, SvelteKit, and Astro, which Vercel supports first-class alongside first-party Next.js:

export default async function Page({ params }) {
  const { id } = await params
  const product = await getProduct(id);
  const jsonLd = {
    '@context': '<https://schema.org>',
    '@type': 'Product',
    name: product.name,
    image: product.imageUrl,
    offers: {
      '@type': 'Offer',
      price: product.price.toFixed(2),
      priceCurrency: 'USD',
      availability: '<https://schema.org/InStock>',
    },
  };

  return (
    <>
      <script
        type="application/ld+json"
        dangerouslySetInnerHTML={{ __html: JSON.stringify(jsonLd) }}
      />
      <ProductDetails product={product} />
    </>
  );
}

Deleting the product means deleting its markup, because they're the same component.

Copy link to headingBuilding the buyer-side agent with the AI SDK and AI Gateway

Teams building their own shopping assistant hit a different version of the problem. A tool-calling loop that queries a catalog, checks inventory, and drafts a cart bills several model calls per turn, where a chat feature bills one, and the cost profile shifts that provider choice enough becomes an architectural decision.

The AI SDK runs the tool-calling loop with stopWhen control over the step count a run is allowed, and AI Gateway handles provider routing, model fallbacks, and team and project spend budgets behind one endpoint. Tool-call requests grew from 31.6% to 58.9% of all tokens on AI Gateway between October 2025 and April 2026, carrying roughly 2.6 times more tokens than the requests around them. For a worked example on a storefront, see ecommerce with the AI SDK.

Copy link to headingShip an agent-ready storefront on Vercel

Agentic commerce today is a conversion premium on a thin slice of traffic, riding on a protocol stack that is still finding its shape. The storefront requirements underneath that stack have already stabilized, and they are the part a merchant controls. An agent that can parse your catalog, authenticate against your routes, and call your checkout without a browser will transact whichever specification wins, and one that can't won't transact under any of them.

Vercel covers that work with five primitives:

• BotID: checkBotId() checks callers against Vercel's verified bot directory and returns isVerifiedBot, verifiedBotName, and verifiedBotCategory, so a route can admit named shopping agents and turn away everything unsigned.

• Fluid compute: Multiple invocations share one function instance, so an agent's cart call and checkout call don't each pay a cold start.

• Vercel WAF: The Rate Limiting SDK moves rate-limit rules into the firewall and leaves the response to your handler, so machine clients get an explicit 429 instead of a timeout.

• Next.js App Router: Server Components render schema.org JSON-LD in the same component as the product data fetch, so the markup can't drift away from live pricing and availability.

• AI SDK and AI Gateway: The AI SDK runs the tool-calling loop with stopWhen control and AI Gateway handles provider routing and fallbacks, so teams can build the agent side as well as receive agents.

Start a new Vercel project and ship on your first git push, or browse vercel.com/templates for a commerce starter you can extend with structured data and a machine-callable checkout.

Copy link to headingFrequently asked questions about agentic commerce

Copy link to headingWhat is the difference between agentic commerce and conversational commerce?

The difference is which party clicks buy. A conversational assistant hands a recommendation back to a human, so a browser-only storefront still works. An agentic buyer calls checkout itself, and anything gated behind a cookie, a session, or a redirect fails silently.

Copy link to headingHow does an AI agent differ from a chatbot?

A chatbot receives input, calls a model, and returns output. An agent runs a self-directed loop: it reasons about the task, chooses and calls tools, evaluates results, and decides the next step. In commerce, that means reacting to price changes and stock levels without a fixed script.

Copy link to headingIs agentic commerce the same as autonomous commerce?

No. Autonomous commerce uses AI to run merchant-side operations such as pricing, inventory, merchandising, and promotions. Agentic commerce is AI acting on the buyer's side, researching, comparing, and purchasing on the buyer's behalf against a merchant's storefront.

Copy link to headingWhat do merchants need to do to prepare a storefront for agentic commerce?

The product page comes first, since it scores lowest on machine-readability across the sector and it's the page agents retrieve most. Structured data there returns more than any protocol work will, and a signed-request policy that admits shopping agents rather than blocking automation wholesale is the next thing worth doing.