← Articles

Why AI Agents Can't Check Out: The Agentic Commerce Infrastructure Gap

Published July 29, 2026Updated July 29, 2026Analysis

Key takeaways

  • AI agents often cannot check out because checkout needs four layers that work together: structured intent, verifiable identity, usable payment credentials, and execution at the merchant.
  • Merchant checkout is defended. Bot detection, one-time passcodes, and CAPTCHAs exist to stop unknown automated traffic, and an unidentified agent looks like that traffic.
  • The identity gap is structural: a merchant sees only the agent that reached the page, not the human who asked for the purchase or the chain of agents between them.
  • Agentic checkout is not mainly a UX problem. A better approval screen does not give an agent identity, credentials, or the ability to complete an order.
  • Teams that treat checkout as a per-merchant feature tend to support one merchant. Teams that treat it as shared infrastructure can support many.

Most AI agents cannot complete a checkout on their own today. A model can find the right product and reason about the right price, but a purchase also needs structured intent, verifiable identity, usable payment credentials, and live execution at a merchant. This page explains why checkout is the hardest part of agentic commerce, in the questions that builders ask about it.

Can AI agents already handle checkout?

AI agents generally cannot handle checkout without dedicated infrastructure, although they handle the reasoning part of commerce well. The gap is not model quality. The general-purpose agent stack does not include identity, payment credentials, or merchant execution.

It helps to separate what an agent does well from what an agent cannot do without dedicated infrastructure:

  • What agents do well: Interpret a vague request, compare products across sources, apply user constraints such as budget and dietary restrictions, and assemble a recommendation.
  • What agents cannot do unaided: Authenticate as the user at a merchant, hold payment credentials safely, satisfy a merchant's bot and fraud controls, and carry a purchase through to a confirmed order.
  • Why the second list does not solve itself: Each item is a separate regulated or defended system. Card credentials bring PCI DSS scope. Merchant sign-in involves account security. Checkout involves fraud prevention. None of these are prompt engineering problems.
  • What this means in practice: A team that wants real purchases needs a solution for the transactional part, in the same way it uses a packaged solution for hosting or for the model.

The recommendation is the easy part. The purchase needs infrastructure.

Why is checkout a hostile environment for AI agents?

Checkout is a hostile environment for AI agents because merchants built it to keep unknown automated traffic out, and an agent without a verifiable identity looks like that traffic. This is an industry-wide condition, not one merchant being difficult.

A typical high-volume merchant puts several independent controls in front of a purchase:

  • Bot detection and traffic scoring: Services such as Cloudflare, Akamai, and DataDome evaluate incoming requests and challenge or block traffic that scores as automated. They are effective, and that is the problem for legitimate agents.
  • One-time passcodes: Sign-in and high-risk actions often require a code sent to a phone or email. An out-of-band code is easy for a human and a hard stop for an unaided agent.
  • CAPTCHAs and interaction challenges: These exist to require a human. An agent that meets one has no legitimate way forward on its own.
  • Account and session walls: Prices, saved addresses, loyalty pricing, and delivery windows often sit behind a signed-in session, so an agent that cannot authenticate cannot see the real order.
  • Multi-step, stateful forms: A checkout is a form that assumes a human. Cart state, fulfillment choice, address validation, and payment entry must stay consistent across several steps.

Generic agent tooling fails at this layer because it has no standing. It cannot prove who it is, and it cannot prove that a human authorized the purchase. Standards such as Web Bot Auth, built on HTTP Message Signatures (RFC 9421), and Visa's Trusted Agent Protocol give an agent a way to identify itself, so a merchant or CDN can check a signature instead of scoring an anonymous request.

The vendors above are examples of the bot detection layer that merchants deploy. Their products are not the obstacle. The obstacle is that a legitimate purchasing agent and an abusive scraper look the same until the agent has an identity.

What is the identity problem in agentic commerce?

The identity problem in agentic commerce is that a merchant can see only the agent that reached the page, not the human who asked for the purchase or the chain of agents that carried the request. The information a merchant needs for a risk decision is not visible when it must decide.

What the merchant needs to knowWhat the merchant actually sees
Is a real human behind this purchase?An inbound request with no human attached
Did that human authorize these exact items and this amount?A cart with no provenance
Which agent platform is responsible for this traffic?An unidentified client
Is this a legitimate purchase or an abuse pattern?A traffic score that cannot tell the two apart
Who bears liability if this goes wrong?Nothing in the request answers this

This is why a block is the rational default. Against an unidentified purchasing client, the safe choice for a merchant is to refuse it, and legitimate agents get caught with bad actors. A solution starts before checkout: the agent needs an identity worth verifying, and the merchant needs a cryptographic way to verify it.

Isn't this just a UX problem?

Agentic checkout is not just a UX problem, because a better approval screen does not give the agent an identity, credentials, or the ability to complete an order. Teams that start with the interface often find the real work only after they ship.

Four layers are missing, and they work only together:

  1. 1

    Intent: A user prompt must become a structured, line-item purchase record with merchant, items, amounts, and limits, approved before anything executes. Without it there is no record of what the human authorized.

  2. 2

    Identity: The agent must be a known, verifiable participant, not anonymous traffic. Without it the merchant blocks every other layer.

  3. 3

    Credentials: A real payment instrument, such as a network token or a tokenized card, must work at the merchant without the agent ever handling the card number. Without it there is nothing to pay with, and a poor design creates a compliance problem.

  4. 4

    Execution: A system must drive the purchase to a confirmed order at the merchant, under the approved terms. Without it the first three layers authorize a purchase that never happens.

Any one layer alone does nothing useful. Intent without execution records a purchase that never happens. Credentials without identity get blocked. Identity without credentials cannot pay. Agentic checkout is hard because all four layers must be present at the same time.

Four layers must arrive together. If one is missing, the agent stops at the merchant.

Why does this matter now?

The checkout gap matters now because agents already sit inside the chat and messaging interfaces people use every day, and users ask them to buy things. Distribution exists, and models can plan a purchase. Checkout is the bottleneck.

Per-merchant integration does not scale. Each additional merchant adds a sign-in flow, a set of bot controls, a checkout form, and compliance questions. An agent built one merchant at a time can stall after its first integration, even when users want more.

Which merchants matter most for agentic commerce?

The merchants that matter most for agentic commerce are the ones users already buy from often, in categories such as food delivery, everyday online shopping, rides, and travel. Agent demand tends to concentrate on habitual, high-frequency purchases.

That concentration affects strategy for anyone who builds in this space:

  • Is breadth the right first metric? Usually not. A long merchant list does not increase usage if the most-requested merchants are missing or unreliable.
  • Depth at the top of demand comes first: Infrastructure that works reliably for the highest-demand merchants covers a large share of what users ask their agents to buy.
  • The categories are predictable: Food delivery, everyday shopping, and rides are small, frequent decisions where manual checkout is tedious.
  • The long tail matters later: Breadth becomes valuable once the most-requested merchants work, because those are what make an agent worth opening again.

What does a complete agent checkout stack include?

A complete agent checkout stack includes the four layers (intent, identity, credentials, and execution) behind one interface, so an agent asks for a purchase under approved terms and receives a confirmed order.

LayerWhat it providesWhat the agent builder no longer owns
IntentA structured, line-item purchase record that the user approves before execution, with terms enforced throughoutAuthorization semantics and proof of what the user agreed to
IdentityA verifiable agent identity, for example through Web Bot Auth signatures and card network agent programs such as Visa's Trusted Agent ProtocolStanding with merchants, CDNs, and the verification ecosystem
CredentialsThe user's own card, tokenized by a PCI DSS Level 1 provider, or a network token, used without exposing the card number to the agentPCI DSS scope and card storage
ExecutionCheckout completed at the merchant, with a confirmed order returnedPer-merchant integration work and the controls each checkout applies

Two properties matter as much as the layers. First, the agent never sees the card number, so the builder adds payments without taking on a payments company's compliance scope. Second, the approval renders inside the builder's own interface, with no redirect to a third-party page.

The user sees one moment of consent. The user sees what will be bought and for how much, confirms with a biometric or passkey, and the purchase proceeds under those terms. The charge runs on the user's own card, so the user keeps the normal dispute rights that the card provides.

What changes when the checkout gap closes?

When the checkout gap closes, an agent changes from a recommendation tool into the place where a task gets done. An agent that can only recommend competes with every search box. An agent that can complete a purchase finishes the task for the user.

In practice, a food agent places the order instead of listing restaurants. A shopping agent buys the item instead of returning links. A travel agent books the trip instead of writing an itinerary. In each case the reasoning was already good enough, and the missing part was the last step: checkout.

Frequently asked questions

Why can't my AI agent just complete a checkout by itself?

An AI agent cannot complete a checkout by itself because checkout needs four things a general-purpose agent does not have: a structured record of what the user authorized, a verifiable identity that a merchant can trust, payment credentials it can use without handling card data, and a way to drive a purchase to confirmation at the merchant.

Are merchants deliberately blocking AI agents?

Mostly no. Merchants deploy bot detection, one-time passcodes, and CAPTCHAs to stop abuse, and an unidentified purchasing agent looks like the traffic those controls target. A block is the rational default. Agent identity standards such as Web Bot Auth give merchants a signature to verify instead of anonymous traffic.

Isn't agentic checkout mainly a user experience problem?

No. A better approval interface does not give an agent identity, credentials, or the ability to finish an order. The missing layers are intent, identity, credentials, and execution, and they work only together. The approval screen is one part of the intent layer.

How many merchants does an AI agent need to support?

An AI agent usually needs fewer merchants than teams assume. Agent demand tends to concentrate on a small number of high-frequency merchants in food delivery, everyday shopping, rides, and travel. Reliable support for those merchants covers much of real usage, and breadth matters after that.

Does the agent ever see the card number?

In a well-designed agent checkout system, the agent never sees the card number. The user's card is tokenized by a PCI DSS Level 1 provider or replaced by a network token, and the agent uses only the token, under the terms the user approved.

What stops an agent from buying something the user did not approve?

A structured purchase record stops an agent from buying something the user did not approve. The user prompt becomes a line-item record with merchant, items, and amounts, and the user approves it before execution. The system checks execution against those terms, so a purchase outside them is refused.

Related articles