For two decades, the question that shaped every ecommerce roadmap was simple: how do we make our storefront easier for people to use? In 2026, a second question has arrived alongside it, and for many merchants it is the more urgent one: how do we make our storefront easier for machines to buy from? The rise of agentic commerce AI shopping agents — autonomous buyers, ChatGPT-style shopping assistants, and B2B procurement agents that act on a buyer’s behalf — means your next customer may not be a person at all. It may be software, dispatched by a person or a business, instructed to find, compare, negotiate and purchase without ever rendering your carefully designed product page.
This is a different problem from building AI into your storefront. We have written before about agentic commerce for B2B product discovery and about AI-powered merchandising inside Elastic Path. This article takes the opposite vantage point. Here, your storefront is not the place where intelligence lives; it is the target that external intelligence consumes. The work is to make your catalogue, pricing, cart and checkout legible, trustworthy and safe for non-human consumers — without compromising the experience for the humans who still make up the bulk of your revenue.
Why agent-readable commerce matters in 2026 and beyond
The shift is being driven from several directions at once. Consumer AI assistants have moved from answering questions to taking actions, and shopping is one of the most commercially attractive actions they can take. On the B2B side, procurement teams are piloting agents that handle routine, repeatable purchasing — consumables, spare parts, software seats, MRO supplies — within policy-defined budgets. The common thread is that an intermediary now stands between your storefront and the buyer, and that intermediary reads structured data and calls APIs rather than scrolling pages.
For merchants, the strategic risk is invisibility. If an AI agent cannot reliably parse your catalogue, confirm a price, check stock and complete a purchase through a clean interface, it will simply transact with a competitor who has made that path frictionless. Search engine optimisation taught us that being unreadable to crawlers meant being absent from results; agent-readiness is the same lesson applied to the transaction itself. The merchants who win the agentic channel will be those whose commerce backend was already designed to be addressed programmatically — which is precisely why an AI-ready ecommerce API and a composable, API-first platform like Elastic Path is suddenly a competitive advantage rather than an architectural nicety.
It is worth being honest about the state of play. Many of the protocols and conventions in this space are emerging rather than settled. Several vendors and consortia have proposed agentic checkout standards and agent-payment schemes during 2025 and 2026, and they are evolving quickly. The sensible posture is not to bet the business on any single proposed standard, but to invest in the underlying capabilities — clean data, clean APIs, robust authentication and strong guardrails — that every plausible version of agentic commerce will require.
Structured product data that agents can actually parse
Before an agent can buy, it has to understand what you sell. Human shoppers tolerate ambiguity — they infer from photography, layout and prose. Machines do not. They need explicit, structured, machine-readable descriptions of your products, their variants, their attributes and their commercial terms.
The starting point is well-established and remains valuable: schema.org structured data. Marking up your product pages with Product, Offer, AggregateRating and related types gives any agent that visits the rendered page a reliable map of name, identifier, brand, price, currency, availability and condition. The Offer type in particular matters because it carries price, priceCurrency, availability and priceValidUntil, which together let an agent reason about whether a quoted price is current. Consistent use of stable product identifiers — GTIN, MPN, SKU — is essential, because an agent comparing options across merchants relies on those identifiers to know it is comparing like for like.
Beyond on-page markup, structured product feeds remain the workhorse of machine consumption. A well-formed feed — whether a traditional merchant feed format or a bespoke JSON catalogue exposed at a stable endpoint — gives agents a complete, parseable view of your range without scraping. The critical qualities are completeness (every purchasable variant, not just parent products), accuracy (attributes that match reality), and freshness (a feed that reflects today’s price and stock, not last week’s).
This is where Elastic Path’s Product Experience Manager (PXM) does real work. PXM is built around a flexible, attribute-rich product model with hierarchies, variations and templates that let you describe complex catalogues precisely. Because that model is API-first, the same structured product information that powers your human storefront can be projected into schema.org markup, into feeds, and into direct API responses for agents — from a single source of truth. The alternative, maintaining a separate “agent catalogue” that drifts out of sync with your real one, is exactly the kind of data-integrity trap that erodes trust with machine consumers.
Agent-readable APIs and emerging MCP-style interfaces
Structured data tells an agent what exists. An API lets it act. The most capable agents will not parse your HTML at all; they will call your commerce APIs directly to query the catalogue, assemble a cart and check out. Designing those APIs to be consumed by software you do not control is a discipline in its own right.
Elastic Path’s headless architecture is a strong foundation here, because the same Catalogue, Cart and Checkout APIs that serve your own frontend can serve an external agent. The Cart and Checkout APIs already model the operations an agent needs: create a cart, add and remove items, apply promotions, calculate totals with tax and shipping, and convert the cart to an order. Crucially, these are stable, documented, versioned interfaces rather than scraped page internals — which means an agent integration built against them will not break the next time your design team ships a new layout.
The emerging pattern worth watching is the use of Model Context Protocol (MCP)-style tool interfaces. MCP and similar approaches give an AI model a structured, self-describing set of tools it can invoke — for example, search_products, get_product, add_to_cart, get_cart_total and checkout — each with a typed schema describing its inputs and outputs. Rather than reverse-engineering your platform, the agent reads the tool definitions and calls them deliberately. Alongside MCP, several proposed agentic-checkout and agentic-commerce protocols aim to standardise how an agent discovers a merchant’s purchasing capability and completes a transaction. These are early and competing; treat them as directions of travel rather than destinations.
The pragmatic implementation pattern we favour is a thin agent-facing API layer or MCP server that sits in front of Elastic Path. Because Elastic Path is API-first, you can expose a curated, well-described set of agent tools that translate to underlying Catalogue, Cart and Checkout calls — without exposing your entire admin surface. This layer becomes the natural home for the things agents specifically need: clear capability descriptions, predictable error semantics, idempotency support, and the authentication and guardrail logic discussed below. It also gives you a single observability and control point for agent traffic, which matters enormously once that traffic grows.
Delegated purchasing and authentication for agents
The hardest and most consequential part of agentic commerce is authority. When an agent adds something to a cart, that is low stakes. When it spends money, the question of whose money, with what permission, up to what limit becomes critical — and it is fundamentally an authentication and authorisation problem.
The mental model to adopt is delegated authority. A human buyer, or a business, grants an agent a constrained mandate to act on their behalf. Translating that mandate into your systems means thinking carefully about OAuth-style scoped tokens. An agent should never hold a buyer’s full credentials. Instead, it should be issued a scoped access token that encodes exactly what it is permitted to do: which catalogues it can browse, whether it can transact at all, which payment instrument or account it may use, and — vitally — what spending limits apply. A token scoped to “browse and build carts but not check out” is very different from one scoped to “purchase up to £500 from approved categories against purchase order line X”.
In a B2B procurement context this maps naturally onto existing structures. A procurement agent acts within an account, against negotiated price lists, under an approval policy and a budget. Elastic Path’s account management and account-membership model — which already supports buyer organisations, account-specific catalogues and pricing — gives you somewhere sensible to anchor an agent’s delegated authority. The agent becomes, in effect, a constrained member of the buying organisation, with its own scoped token, its own spend ceiling and its own audit trail.
Several payment and identity schemes for agent-initiated purchases have been proposed across 2025 and 2026, including approaches that issue per-transaction or per-mandate payment credentials so that the agent never touches a reusable card number. The detail varies and the standards are unsettled, but the principle is durable: short-lived, narrowly-scoped, auditable credentials, with the buyer’s real payment instrument and identity held behind a delegation boundary. Designing your checkout integration so that payment authorisation is decoupled from a long-lived stored credential will serve you well regardless of which scheme prevails.
Pricing and availability accuracy for machine consumers
Humans forgive a stale price; they shrug, adjust and carry on. Agents do not. An agent that is told a product costs £40, builds that into a basket of options it is optimising, and then discovers at checkout that the price is £48 will at best retry and at worst abandon you and flag the discrepancy. At scale, inconsistent pricing and availability data is not a minor irritant — it is a reason for agents to deprioritise your storefront entirely.
This raises the bar on real-time accuracy. The price and stock an agent reads via your feed, your structured data and your API must be the price and stock it will actually transact at, at the moment it transacts. That argues for serving pricing and availability from authoritative, low-latency sources rather than cached snapshots, and for making freshness explicit — for example, communicating price validity windows so an agent knows how long a quote can be trusted. Where prices are account-specific, as they frequently are in B2B, the agent’s scoped token must resolve to the correct negotiated price list so that what it sees matches what its principal has agreed.
Elastic Path’s separation of catalogue, pricing and inventory concerns helps here, because price books and catalogue rules can be evaluated per request and per account rather than baked into static pages. The discipline to add is treating the agent as a first-class consumer of that real-time pricing logic, and resisting the temptation to serve it from a convenient but stale cache.
Guardrails, fraud and the observability of agent traffic
Opening a programmatic purchasing path to autonomous software is a security undertaking, and it deserves to be treated as one. The same qualities that make agents valuable — speed, persistence, tirelessness — make a misbehaving or malicious agent dangerous. The defences fall into a few categories.
Idempotency is the unglamorous foundation. Agents retry; networks fail; an agent that does not receive a clear response may resend a checkout request. Without idempotency keys on order-creating operations, that retry becomes a duplicate order. Every state-changing endpoint an agent can call should accept an idempotency key and guarantee that repeating the same request produces the same result rather than a second purchase.
Guardrails enforce the mandate. The scoped token defines what an agent may do; server-side guardrails ensure it cannot exceed that even if it tries or is manipulated. Spend limits, per-transaction ceilings, category restrictions, velocity limits and quantity caps should all be enforced at the API boundary, not assumed to be respected by a well-behaved client. Assume the client may be poorly behaved.
Fraud and abuse considerations shift in an agentic world. Conventional bot mitigation aims to block automated traffic; agentic commerce requires you to welcome legitimate automation while still excluding malicious automation. The distinction is no longer human-versus-bot but authorised-agent-versus-unauthorised-bot. That makes strong agent authentication, anomaly detection on agent behaviour, and rate limiting per agent identity essential. A single agent suddenly attempting to enumerate your entire catalogue, or firing checkout attempts at an abnormal rate, should be throttled and surfaced for review.
Finally, observability. You cannot govern what you cannot see. Agent-driven traffic should be identifiable and instrumented end to end: which agent, acting for which principal, queried what, built which cart, and completed which order. This audit trail is your basis for fraud investigation, for reconciling B2B spend against budgets, and for the simple commercial intelligence of understanding how much of your revenue now arrives through the agentic channel. The thin agent-facing layer described earlier is the ideal place to capture this, because all agent interactions pass through it.
Why Elastic Path’s API-first model fits the agentic shift
It would be easy to read this article as a long list of new burdens. In practice, most of the work rewards an architecture you may already have. Agentic commerce does not demand a new platform; it demands a platform that is genuinely API-first, with a rich structured product model, account-aware pricing, and clean, versioned commerce APIs. That is a fair description of Elastic Path.
Because Elastic Path is composable and headless by design, the agent channel becomes another consumer of the same backend that powers your web and mobile storefronts — not a parallel system to be built and maintained separately. PXM gives you the structured, single-source product data that feeds both human pages and machine catalogues. The Cart and Checkout APIs give agents a stable, documented transaction path. The account and pricing model gives delegated B2B purchasing somewhere to live. And the API-first foundation means the agent-facing layer, the MCP-style tool server and the guardrail logic can be added in front of a system that was always meant to be addressed by software. Merchants on monolithic, page-centric platforms face a far harder retrofit; composable merchants are mostly extending capabilities they already have.
How McKenna Consultants can help
Agentic commerce is moving from speculation to roadmap item, and the merchants who prepare now — while the standards are still forming — will be the ones agents prefer to buy from when the channel matures. As an Elastic Path consultancy in the UK with deep experience in composable, API-first commerce, McKenna Consultants helps merchants get agent-ready without disrupting the human experience that still drives most revenue.
We can audit your current catalogue data and structured markup for machine-readability, design and build an agent-facing API or MCP-style tool layer in front of your Elastic Path implementation, model delegated-purchasing authority and scoped authentication for B2B procurement agents, and put the idempotency, guardrails, fraud controls and observability in place to make agent traffic safe and accountable. Throughout, we frame the emerging protocols honestly — investing in the durable capabilities every version of agentic commerce will need, rather than chasing any single unsettled standard.
If your next customer might be an AI agent, it is worth making sure your storefront is ready to be bought from. Get in touch to discuss how to prepare your Elastic Path storefront for the agentic era.
