Sub-grade spoke

Cart Accessibility — can an agent put an item in your cart without a browser?

Cart accessibility is whether an AI agent can add a product to a cart, complete checkout, and confirm an order without driving a sandboxed browser. The structured-action surface for e-commerce. Sites with programmatic add-to-cart endpoints, guest-checkout flows, and cart-token APIs route agent-initiated commerce smoothly; sites that lock the cart behind authenticated sessions and JavaScript-heavy checkout UI lose the agent at the moment of value capture.

By Chris Mühlnickel · 2026-05-16

What is Cart Accessibility?

Cart Accessibility is whether your cart and checkout flow expose programmatic add-to-cart endpoints, support guest checkout without forced account creation, and maintain cart state across stateless agent requests via a portable cart token.

By the numbers

Why it matters

Cart accessibility is the bottom-of-funnel Usability check — the one that captures the agent-driven economic upside or loses it. An agent that researched a product on your site, compared it favorably against competitors, and routed the user toward your cart is producing the highest-intent traffic available anywhere. If that agent can't complete the add-to-cart action because the endpoint expects a JavaScript-managed session, or hits a "create an account to continue" wall, or trips a CAPTCHA on the final submit, the entire upstream funnel collapses. Visibility and Clarity work compounds at this layer; a Usability failure on the cart cancels it.

The Baymard 26% finding is the binary cost of forced accounts. Per Baymard's 2025 checkout benchmark, 26% of cart abandonments stem from forced account creation — and that figure understates the agent-driven cost, because agents can't create accounts at all under most identity models. Sites that still gate checkout on account creation are paying that 26% on human shoppers and roughly 100% on agent-driven traffic. The 35% conversion lift Baymard attributes to checkout-flow design changes is the upper bound on the recoverable value. The work to capture it — guest checkout, smaller forms, persistent cart tokens, machine-parseable error responses — is the same work that makes the cart agent-friendly. One investment, two ROI vectors.

ACP adoption is the canary for what becomes a binary requirement. The 1M+ Shopify merchants who joined ChatGPT Instant Checkout via the Agentic Commerce Protocol within months of launch is the fastest agent-commerce-adoption signal we've seen. Stripe's Shared Payment Tokens, OpenAI's ACP routing, and the parallel Google/Shopify UCP work all point at the same near-term equilibrium: sites with ACP/UCP-compatible cart APIs participate in agent-mediated commerce; sites without get routed around. Today the gap is small; by 2027 it's the equivalent of "we don't accept credit cards" — a structural exclusion from the high-growth channel.

The cart is also where bot fingerprinting silently kills the funnel. Cloudflare bot-fight mode, Akamai bot manager, and AWS Shield all default to flagging non-human user agents at the cart and checkout layer — exactly where the legitimate agent population concentrates. Most site owners have never inspected the cart's behavior under a non-Chrome user agent and don't know whether their CDN is silently rejecting agent traffic. The cart accessibility check at the Usability layer surfaces this gap directly: if the same POST /cart/items works from a desktop browser but returns 403 under an OpenAI or Anthropic user agent, the funnel is leaking and the dashboard never shows it.

Where it's heading

Headless checkout becomes the dominant pattern within 24 months. The pattern is converging fast: Shopify Hydrogen, BigCommerce's Stencil-headless split, Stripe Checkout's API-first design, and the new wave of composable-commerce platforms all assume the cart is an API surface with the rendered UI as one of several consumers. Sites running monolithic checkout (cart state tied to a server-rendered template, no callable endpoints) lose the optionality to participate in agent commerce, embedded checkout, and any of the partner-channel flows that compound revenue.

Cart APIs gain protocol-level standardization. ACP, UCP, and AP2 (the Agent Payments Protocol) are converging on a small set of standardized cart operations: discover-products, add-to-cart, checkout-init, checkout-confirm, status-poll. By 2027 a site's cart either implements those operations natively or wraps them with a thin adapter — and the agent platforms route only to compatible sites. The cohort that ships compatible carts in 2026 captures the first-mover share of agent commerce in their vertical.

Identity signals replace bot defenses at the cart. The strategic shift: stop trying to block bots, start verifying agent identity. HTTP Message Signatures from the agent platform's certificate authority, signed user-intent tokens that prove the human approved the action, platform-level reputation scores. The cart layer is where this hardens first — because that's where the economic value concentrates — and the leading payment platforms (Stripe, Adyen, Visa Trusted Agent Protocol, Mastercard Agentic Tokens) are all building toward this in parallel.

Common mistakes

  • Forced account creation before checkout. The single biggest agent-killer in e-commerce. Costs 26% of human cart-completers per Baymard and roughly 100% of agent-initiated traffic.
  • Add-to-cart that requires JavaScript execution. A POST /cart/items endpoint is the right surface. A button that runs a 200-line JS handler before mutating client-side state is the wrong one — agents can't see the result.
  • No idempotency on cart endpoints. Agents retry under partial-failure. Without idempotency keys, retries double-add the same SKU or double-charge the same card — and the agent platform deprioritizes the site.
  • Bot fingerprinting at the cart layer. Cloudflare bot-fight mode, Akamai bot manager defaults to flagging agent UAs at the cart. Configure the bot policy for agent allowlist or accept the silent loss of agent-initiated commerce.
  • Cart tokens that don't survive across redirects. The agent calls add-to-cart, gets a token, calls checkout — and the token is invalid because session state was lost across the domain boundary. Use stateless, portable tokens designed for cross-request continuity.

Frequently asked

What does an 'agent-friendly cart' actually require?

Four things, in order of leverage: (1) a programmatic add-to-cart endpoint — POST /cart/items returning a cart state, not a 200 HTML redirect, (2) guest checkout that doesn't gate on account creation or email verification, (3) a cart token the agent can pass across stateless requests, (4) idempotency on the add-to-cart and checkout-confirm endpoints so retries don't double-add or double-charge. Each is a discrete check; the Spekto audit reports which of the four your cart passes today.

Is guest checkout really still a thing in 2026?

Yes, and it's the single biggest agent-friendliness lever in e-commerce. Per Baymard, 26% of cart abandonments are caused by forced account creation. Agents inherit that abandonment at 100% — they can't create a durable account, can't reuse a saved password, and can't reliably handle email verification in band. Sites that route agent-initiated traffic at meaningful volume all support guest checkout. The vertical exceptions (regulated industries, B2B with credit-line workflows) usually still expose a guest path for browsing and gate only the final commit step.

What's the difference between a cart token and a session cookie?

Session cookies are tied to a browser context — they carry implicit identity baggage (CSRF, same-origin policy, third-party cookie limits) that agents struggle with. A cart token is a portable string the agent passes in a header or URL parameter, with no domain or browser-context dependencies. Stripe Checkout's cs_* session IDs are the canonical pattern; Shopify's cart tokens work the same way. The right surface is either (token-based for agent flows, cookies for browser flows), not both required for the same checkout.

How does the Agentic Commerce Protocol (ACP) change cart requirements?

ACP — the OpenAI/Stripe spec launched in September 2025 — formalizes the agent-cart interaction: agents authenticate with a Shared Payment Token (SPT), call standardized add-to-cart and checkout endpoints, and receive structured confirmation. The 1M+ Shopify merchants who joined ChatGPT Instant Checkout in the first months after launch are the leading indicator: ACP-compatible cart APIs are becoming a binary requirement for participating in agent commerce. Google's UCP is converging on the same shape with different transport assumptions.

What about CAPTCHAs and bot defenses on the cart?

Most break legitimate agents. The structural answer isn't 'whitelist OpenAI's user agent' — it's to treat agent identity as a first-class signal: HTTP Message Signatures, signed agent tokens from the platform (ChatGPT's Signature header, Claude's equivalent), and platform-level reputation. The transitional answer for sites that can't ship that yet: keep the discovery flow CAPTCHA-free, gate only the final commit step behind a frictionless challenge (Cloudflare Turnstile invisible, not full-page reCAPTCHA), and accept that the gated step costs you the agent-driven population.

Do agents need to render the cart page, or just call the API?

API path first, cart page as fallback. The clean pattern: every cart state change (add, update quantity, remove, apply discount) is callable via an endpoint, and the cart page is the human-rendered view of the same state. Sites that ship both let API agents and computer-use agents (Operator, Claude Computer Use) both succeed — the API agent skips the rendering, the CUA uses the page when there's no API surface. The failure mode is cart pages that are the only surface, with cart state locked in a JS state manager invisible to anything other than a rendered browser.

Should I implement headless checkout if I already have a hosted checkout page?

Yes, if you sell across more than one surface. Headless checkout — the cart and checkout exposed as an API independent of the rendered UI — is what lets agents complete the purchase without driving your storefront. Shopify Hydrogen, Stripe Checkout API, BigCommerce's cart API are the canonical implementations. If you're a single-storefront merchant, the hosted page is fine; if you syndicate to marketplaces, embed in partner sites, or want to participate in ChatGPT Instant Checkout, headless is the path.