The web was built for humans. Pages, navigation, checkout flows — all designed for eyes and clicks. That architecture worked because the entity doing the browsing and buying was always a person.

That assumption is starting to break down. AI agents — systems that can browse, compare, request quotes, and execute purchases autonomously — are moving from research projects to deployed tools. Early versions are already being used by individuals to handle routine procurement: finding the best rate on insurance, ordering supplies on a weekly cadence, comparing service providers before scheduling calls.

The businesses those agents encounter fall into two categories: ones the agent can work with, and ones it cannot. For the ones it cannot work with, the agent does not report an error. It moves on. The business is invisible.

What an AI agent actually needs from a seller

A human buyer can tolerate ambiguity. They can call to ask about pricing, read a paragraph of marketing copy to infer whether a product fits their need, or navigate three layers of menu to find the contact form. An AI agent cannot do any of this reliably. Agents need structured, machine-readable signals at each stage of the commerce process.

The specific surfaces an agent looks for:

Surface What the agent needs What it does without it
Product catalog Machine-readable list: SKUs, names, prices, availability. JSON or structured API. Scrapes HTML (unreliable) or skips the seller
Quoting Deterministic quote endpoint: send parameters, get a price. No phone calls. Cannot quote. Treats the business as non-quoting.
Checkout handoff A declared path to complete a purchase — direct API, payment link, or stated process. Cannot complete the transaction or flags business as unsupported
Payment rail declaration Explicit statement of which payment methods are supported. Not implicit — declared. Assumes no agent-compatible rails; may not attempt checkout
Fulfillment proof Post-purchase confirmation: what was bought, when it ships, how to verify delivery. Cannot verify the transaction completed; may flag as unresolved
Agent discovery llms.txt, ai-plugin.json, or OpenAPI spec — a declared entry point for agents May not find the seller's commerce surfaces at all

A business that has all of these is agent-ready: an AI agent can discover it, understand its offerings, request a quote, and complete a purchase without human intervention on either side. A business missing any of these has a gap that, depending on the agent, either produces a degraded result or causes the agent to skip the business entirely.

Why this matters now, not in two years

The standard response to early agentic commerce is "it's too early — real agent-driven purchasing is years away." This argument has two problems.

First, agentic purchasing is not one monolithic event that arrives on a specific date. It is already happening at small scale and will expand gradually and unevenly. Businesses that are agent-ready when the volume is small will have established catalog presence, working integrations, and indexed status in agent-accessible registries before competitors who wait.

Second, the work required to become agent-ready — publishing a machine-readable catalog, adding a quote endpoint, declaring your payment rails — is not large. It is a few days of engineering work for most businesses with any existing API infrastructure. The cost of doing it early is low. The cost of doing it after your competitors are already indexed is higher, because you are not just building infrastructure; you are building from behind.

The businesses that ended up dominant in Google search did not win because they built SEO strategies in 2010. They won because they built good web infrastructure in 1999 and let a decade of compounding work in their favor. Agentic commerce indexing follows the same logic. The question is not "is it worth doing?" It is "how far behind do you want to start?"

The surfaces most businesses are missing

We have tested hundreds of online seller sites against the agentic commerce readiness standard. The distribution of gaps is consistent:

<5%
of commerce sites have a machine-readable catalog in a format an agent can parse without scraping
<2%
have a deterministic quote endpoint — a URL that returns a price given structured parameters
<1%
have explicit payment rail declarations that an agent can read without inferring from checkout UI

The gaps compound: a business missing the catalog is also likely missing the quote endpoint and the payment rail declaration, because all three require the same underlying orientation — treating agents as first-class users of your commerce infrastructure, not afterthoughts.

The one surface more businesses have than expected: llms.txt files. A small but growing number of sites have added these, often because AI-savvy operators saw them become a standard in 2025. But llms.txt alone does not make a site agent-ready for commerce — it is a discovery surface, not a transaction surface. A site with llms.txt and no quote endpoint is a site an agent can find but cannot buy from.

What certification actually tests

The emerging approach to signaling agent-readiness is certification: a standardized test suite that checks a seller's site against the full set of agentic commerce surfaces, scores each one, and produces a verifiable result that agents and agent-platform operators can trust.

A well-designed certification tests 10 or more surfaces including:

The last item matters more than it sounds. A subset of sites claim support for emerging payment rails — x402, SPT, agent payment tokens — that they do not actually implement. This produces false positives in agent discovery that burn agent time and erode trust in the seller. A certification that tests claimed capabilities against actual behavior catches these and excludes non-compliant sites from the certified registry.

The registry problem

Individual certification is useful. A shared registry of certified sellers is more useful, for the same reason Google's index is more useful than any individual site's sitemap.

An agent that needs to procure office supplies does not want to test every office supply vendor for agentic readiness before attempting a purchase. It wants a list of vendors that have already been tested and certified, so it can go directly to the transaction surfaces without a discovery loop. A certified registry provides this.

This is also why early registry presence matters. An agent-accessible registry with 500 certified sellers is easier for early agents to build against than one with 50,000. The sellers in the early registry get disproportionate agent traffic before the registry expands to the point where they become one of many.

The work required is smaller than it looks

For businesses with any existing product database or ecommerce infrastructure, the path to basic agentic commerce readiness is:

  1. Expose the product catalog as a JSON endpoint — same data that powers your storefront, served at a stable URL
  2. Add a quote endpoint that accepts structured parameters and returns a price
  3. Declare your checkout handoff path in a machine-readable commerce.json or similar
  4. Declare supported and unsupported payment rails explicitly
  5. Add fulfillment metadata to your post-purchase confirmation
  6. Publish llms.txt and ai-plugin.json to help agents find you

For a business with an existing API, steps 1-3 are usually one to three days of work. Steps 4-6 are configuration, not engineering. The full stack can be done in a week by a competent developer. It does not require new infrastructure. It requires orienting existing infrastructure toward agent consumers.

The 8bitconcepts consulting practice builds these surfaces as part of embedded AI engagements. For businesses already running on standard ecommerce stacks, the agentic commerce layer typically takes under a week to ship. The harder part is usually deciding what the quote logic should be, not the API itself.

Check where you stand

The fastest way to know whether your business has the agentic commerce gap is to test it. Agentprobe is an automated test suite that runs 13 probes across your commerce and agent-readiness surfaces, scores each one, and tells you exactly what is missing and what it means for agent discoverability.

Sites that pass all probes receive CERTIFIED status and are listed in the public registry — making them discoverable to agent platforms looking for vetted sellers. Sites with gaps get a specific remediation report: which surfaces are missing, what the correct implementation looks like, and in what order to address them.

The gap exists now. The agents doing early-stage commerce purchasing are live now. The registry is being built now. The question is whether your business is in it or not.

Agentprobe runs 13 automated probes against your site's agentic commerce readiness. CERTIFIED sites are listed in the public registry and discoverable to agent platforms.

Check your score at Agentprobe →