The AI Infrastructure Behind Agentic Commerce: What E-commerce Businesses Need to Build Now

E-commerce is entering a new phase. Instead of customers visiting a store, searching through products, comparing pages, filling out checkout forms, and completing payments themselves, AI agents can increasingly handle those steps on their behalf.

This shift is known as agentic commerce. It changes more than the shopping interface. It changes the infrastructure required underneath e-commerce.

For an AI agent to discover a product, determine whether it is available, compare prices, create a cart, complete checkout, authorize a payment, and track an order, the merchant's systems need to become machine-readable, API-accessible, secure, and capable of handling interactions initiated by software rather than humans.

That is why the real question for e-commerce businesses in 2026 is no longer simply whether they should add an AI shopping assistant. The more important question is whether their AI infrastructure is ready for agentic commerce.

What Is Agentic Commerce?

Agentic commerce describes a model in which AI agents participate directly in the buying journey. Instead of acting only as a recommendation or search interface, an agent can understand a user's intent, discover suitable products, interact with merchant systems, initiate checkout, and in some cases complete a transaction within defined permissions.

Traditional e-commerce was designed around a human-controlled journey:

• ■Customer searches for a product
• ■Customer visits a product page
• ■Customer checks price and availability
• ■Customer adds the product to a cart
• ■Customer enters shipping and payment details
• ■Customer completes checkout

Agentic commerce changes the interface between the customer and the merchant. The customer can describe what they want in natural language, while an AI agent handles much of the discovery and transaction workflow.

This does not mean the existing e-commerce stack becomes obsolete. Instead, the existing stack needs a new machine-facing layer that allows AI agents to interact with product catalogs, inventory, pricing, checkout, payments, orders, and customer-service systems.

Why E-commerce Infrastructure Needs to Change

Most e-commerce infrastructure was built for humans. Product pages are optimized for visual browsing, checkout flows assume users will click through forms, fraud systems are designed around human purchasing patterns, and many enterprise systems expose information through interfaces that are difficult for autonomous software to query reliably.

Adyen identifies five major infrastructure constraints holding back agentic commerce: protocol fragmentation, product data that machines cannot reliably query, enterprise checkout systems designed around linear flows, fraud systems built around human-initiated transactions, and merchant onboarding that does not scale across platforms.

These problems point toward a broader infrastructure shift. E-commerce businesses need to make their commerce systems understandable and accessible to AI agents without sacrificing security, control, or the existing customer experience.

The Core Infrastructure Behind Agentic Commerce

A reliable agentic commerce architecture can be thought of as several connected layers:

1. ■Machine-readable product and catalog data
2. ■Real-time inventory and pricing
3. ■Commerce APIs and agent-facing protocols
4. ■Agentic checkout infrastructure
5. ■Payment authorization and processing
6. ■Agent identity and authentication
7. ■Fraud prevention and transaction risk management
8. ■Order management and fulfillment
9. ■Observability and auditability

The goal is not to build nine disconnected systems. The goal is to expose the capabilities that already exist inside the commerce stack through interfaces that agents can securely understand and use.

1. Make Product Data Machine-Readable

The first requirement for AI commerce is surprisingly basic: an AI agent needs to understand what a merchant actually sells.

A traditional product page may be perfectly understandable to a human while still being difficult for an agent to query consistently. An agent needs structured information about product names, variants, descriptions, specifications, prices, availability, images, shipping restrictions, promotions, return policies, and other attributes.

This makes the AI commerce data layer one of the most important investments an e-commerce business can make.

Product information should be structured, consistent, current, and accessible through APIs or standardized feeds. The more reliable the data, the easier it becomes for AI shopping assistants to discover and accurately represent products.

This is already becoming an important part of AI shopping infrastructure. OpenAI, for example, has expanded ACP to support product discovery and product feeds, while Shopify has integrated merchant product data into ChatGPT through Shopify Catalog.

2. Connect Agents to Real-Time Inventory and Pricing

Product discovery is only useful when the information is accurate.

An AI agent cannot reliably recommend a product if it is working with yesterday's inventory, an outdated price, or a promotion that has already expired.

Agent-ready commerce therefore requires access to real-time or near-real-time information such as:

• ■Current product price
• ■Variant availability
• ■Inventory levels
• ■Regional availability
• ■Delivery estimates
• ■Active promotions
• ■Shipping costs
• ■Return and fulfillment constraints

This is particularly important because AI agents can compare multiple merchants and products rapidly. If a merchant exposes inaccurate information, the agent may simply select another seller whose data is more reliable.

3. Build for UCP, ACP, MCP and A2A

One of the biggest developments in agentic commerce is the emergence of protocols that standardize how agents, businesses, tools, and payment systems communicate.

These protocols solve different problems and should not be treated as interchangeable technologies.

Universal Commerce Protocol (UCP)

Google's Universal Commerce Protocol (UCP) is an open standard designed to connect consumer-facing AI experiences with business backends for commerce capabilities such as product discovery and checkout.

UCP is designed to work with existing retail infrastructure and supports multiple communication methods, including APIs, Agent2Agent (A2A), and Model Context Protocol (MCP). It is also designed to work with Agent Payments Protocol (AP2) for secure agentic payments.

Agentic Commerce Protocol (ACP)

The Agentic Commerce Protocol (ACP), developed by OpenAI and Stripe, provides a standardized way for AI agents and businesses to execute programmatic commerce flows.

ACP is designed to allow merchants to participate in agentic checkout while retaining control over their existing backend, payments, fulfillment, and customer relationships.

Model Context Protocol (MCP)

MCP provides a standardized way for AI agents to connect with tools and data. In an e-commerce environment, that can mean giving an agent controlled access to product information, inventory systems, order management, customer-service tools, or other business capabilities.

Agent2Agent (A2A)

A2A focuses on communication between AI agents. This becomes important when commerce involves multiple specialized agents, such as a shopping agent communicating with a merchant agent, fulfillment agent, or payment-related service.

Agent Payments Protocol (AP2)

AP2 addresses the authorization side of agentic payments. Google's developer guidance describes AP2 as the layer that establishes who authorized a payment, what limits apply, and how that authorization can be audited. UCP can use AP2 as a payment-related extension.

These protocols are best understood as complementary pieces rather than competing replacements. MCP connects agents to tools and data, A2A connects agents to other agents, UCP standardizes commerce interactions, and AP2 adds payment authorization and guardrails.

4. Redesign Checkout for AI Agents

Traditional checkout assumes a human is sitting in front of a browser and interacting with a sequence of pages.

Agentic checkout changes that assumption.

An AI agent may need to initiate checkout through an API, provide cart information, retrieve shipping options, receive a payment authorization, and submit an order without navigating a conventional checkout page.

This means merchants need checkout systems that can expose core checkout capabilities programmatically.

A strong agentic checkout architecture should support:

• ■Cart creation and modification through APIs
• ■Product and variant validation
• ■Real-time price validation
• ■Shipping and tax calculation
• ■Promotion and discount validation
• ■Payment authorization
• ■Order creation
• ■Cancellation and refund workflows
• ■Order-status retrieval

ACP provides one example of this architecture: the AI agent can initiate checkout while the merchant continues to operate its existing data model, payment processing, fulfillment, and order-management systems.

5. Agentic Payments Need More Than a Payment Gateway

Payments are arguably the hardest part of agentic commerce because an AI agent is being given the ability to cause a financial transaction.

A normal payment system asks questions such as: Is this card valid? Is the transaction authorized? Does the transaction look fraudulent?

Agentic payments introduce additional questions:

• ■Which agent is making the transaction?
• ■Who authorized the agent?
• ■Which merchant can the agent transact with?
• ■What is the maximum amount it can spend?
• ■How long is the authorization valid?
• ■What happens if the agent attempts an unauthorized purchase?
• ■Can the transaction be traced back to the user's original intent?

This is why agent identity, authentication, permissions, spending limits, payment tokens, and transaction observability are becoming part of the commerce infrastructure itself.

6. AWS AgentCore Shows Where Agentic Payment Infrastructure Is Going

AWS's Amazon Bedrock AgentCore Payments illustrates how payment infrastructure is being adapted for autonomous agents.

AgentCore Payments provides payment connections, wallet management, payment sessions, configurable spending limits, payment processing, authentication, and observability. Payment sessions can be time-bounded and configured with maximum spending limits, preventing additional payment requests once the limit or session expiry is reached.

The system also separates payment credentials from the agent itself. AWS describes using AgentCore Identity to securely manage payment-provider credentials, while the payment service handles the payment workflow.

That architecture highlights an important principle for e-commerce businesses: never give an AI agent unrestricted access to payment credentials or purchasing power.

Agent permissions should be scoped, spending should be constrained, and transactions should be observable.

7. Fraud Prevention Has to Evolve for AI Agents

Traditional fraud systems often rely on signals associated with human behavior. Agentic commerce changes the nature of the transaction.

A legitimate AI agent may generate a transaction that looks very different from a normal customer interaction. At the same time, malicious bots can also automate transactions at scale.

This creates a difficult trust problem: merchants need to distinguish authorized agents acting on behalf of real customers from malicious automated activity.

That means future-ready fraud infrastructure needs to consider more than IP addresses, device fingerprints, and historical purchasing behavior. It also needs to understand agent identity, authorization context, payment permissions, transaction intent, merchant restrictions, and behavioral signals.

Stripe and OpenAI's work on ACP similarly emphasizes the need for new trust and fraud mechanisms because AI agents can initiate transactions on behalf of buyers.

8. Merchant of Record and Order Management Still Matter

Agentic commerce does not remove the merchant from the transaction.

Someone still needs to be responsible for accepting the order, charging the customer, calculating applicable taxes, fulfilling the purchase, handling returns, and supporting the customer.

In the ACP model, the merchant remains the Merchant of Record and continues to control fulfillment, returns, support, and the customer relationship.

This means an agent-ready commerce stack must connect cleanly into existing order-management and fulfillment infrastructure.

The AI agent may initiate the purchase, but the merchant's operational systems still need to execute everything that happens after the purchase.

9. Observability Becomes a Core Requirement

When humans perform every action, businesses can often reconstruct what happened from traditional checkout and application logs.

With autonomous agents, there can be many more machine-to-machine interactions between discovery and payment.

Businesses therefore need to know:

• ■Which agent initiated the interaction?
• ■Which products were retrieved?
• ■What price and inventory information was provided?
• ■Which checkout actions were performed?
• ■What authorization was granted?
• ■Which payment was attempted?
• ■Why was a transaction approved or rejected?
• ■What happened to the order afterward?

AWS's AgentCore Payments architecture explicitly includes logs, metrics, traces, payment-session information, spending data, and transaction-level observability.

For enterprise commerce, this kind of agentic commerce observability is not optional. It becomes part of the control layer that allows businesses to audit autonomous activity and investigate failures or unexpected behavior.

10. Shopify Shows Why AI Traffic Is Becoming a Commerce Infrastructure Issue

The shift toward AI-mediated shopping is already visible in commerce data.

Shopify reported that, according to its Q1 2026 commerce data, AI-referred orders grew nearly 13 times year over year, while referral sessions from AI chatbots grew more than 8 times year over year.

That changes the strategic question for merchants.

AI traffic should not be treated simply as another marketing channel. If AI agents increasingly influence which products consumers discover and purchase, merchants need infrastructure that allows those agents to accurately understand their products and transact with their systems.

Shopify has already been building toward this model through AI channels and Agentic Storefronts, including integrations involving Google, Gemini, Microsoft Copilot, and ChatGPT.

What E-commerce Businesses Should Build Now

Most businesses do not need to rebuild their entire commerce stack from scratch. The smarter approach is to make the existing stack progressively agent-ready.

1. Build a clean commerce data layer

Centralize product information, pricing, variants, availability, promotions, shipping rules, and policies so that different AI agents can access consistent information.

2. Expose commerce capabilities through APIs

Agents need machine-accessible interfaces for product discovery, inventory, carts, checkout, orders, returns, and customer support.

3. Prepare for emerging commerce protocols

Evaluate where UCP, ACP, MCP, A2A, and AP2 fit into the architecture instead of building isolated integrations for every AI platform.

4. Make checkout agent-compatible

Separate the underlying checkout capabilities from the human-facing interface so that authorized AI agents can interact with the same commerce backend.

5. Introduce agent identity and permissions

Every agent interaction should have a clear identity, authorization context, scope, and set of allowed actions.

6. Add spending controls

Agentic payments should operate within explicit limits based on amount, merchant, currency, task, time, or other business rules.

7. Upgrade fraud detection

Fraud systems need to distinguish legitimate automated commerce from malicious automation while incorporating the identity and authorization context of the agent.

8. Connect agentic transactions to existing operations

Orders generated through AI agents should flow into the same inventory, fulfillment, customer-support, refund, and returns systems that handle conventional e-commerce orders.

9. Build observability from day one

Log agent identity, actions, authorization, checkout events, payment events, errors, and order outcomes so autonomous commerce remains auditable.

The Agent-Ready E-commerce Architecture

A practical architecture can be viewed as a layered system:

AI Shopping Agents
        ↓
Agent Protocol Layer
UCP / ACP / A2A / MCP
        ↓
Agent Identity & Authorization
        ↓
Commerce API Layer
Product / Catalog / Inventory / Pricing
        ↓
Checkout & Payment Layer
Cart / Checkout / Payment / Fraud
        ↓
Core Commerce Systems
OMS / ERP / CRM / Tax / Fulfillment
        ↓
Observability & Governance
Logs / Metrics / Traces / Audit
  

The important point is that the AI agent should not bypass the merchant's core systems. Instead, the agent-facing layer should provide controlled access to them.

Agentic Commerce Is Not Just About AI Shopping

It is tempting to define agentic commerce as simply "shopping with ChatGPT" or adding an AI chatbot to an online store.

That definition is too narrow.

The deeper change is that software agents are becoming participants in commerce. They can discover products, communicate with businesses, evaluate options, initiate transactions, make payments within permissions, and interact with post-purchase systems.

That requires a fundamentally different infrastructure model: one where commerce systems are designed to communicate with both humans and machines.

The Businesses That Prepare Early Will Have an Infrastructure Advantage

The biggest mistake e-commerce businesses can make is waiting for one AI platform to become dominant before preparing for agentic commerce.

The more durable strategy is to strengthen the infrastructure underneath the storefront.

Clean product data, reliable APIs, real-time inventory, programmable checkout, secure payment authorization, agent identity, fraud prevention, order-management integration, and observability are useful regardless of which AI agent ultimately becomes the dominant shopping interface.

Google's UCP is attempting to create a standardized commerce layer across consumer surfaces, businesses, and payment providers, while ACP provides another open standard for programmatic commerce between AI agents and businesses. Meanwhile, infrastructure providers such as AWS are building payment controls specifically around autonomous agents.

The direction is clear: e-commerce is moving from a web designed primarily for human interaction toward a commerce infrastructure that can also be queried, negotiated with, and operated by software agents.

Final Takeaway

Agentic commerce will not be won by the businesses that simply add an AI shopping chatbot.

It will be won by businesses whose underlying commerce infrastructure is ready for machines.

That means making product catalogs machine-readable, exposing real-time commerce APIs, supporting emerging protocols such as UCP and ACP, connecting agent interactions to MCP and A2A where appropriate, securing payments with explicit authorization and spending limits, adapting fraud systems for AI-driven transactions, and building observability into every autonomous workflow.

The storefront may still look familiar to customers. Underneath it, however, the architecture of e-commerce is changing.

The next generation of commerce will not only be human-readable. It will be agent-readable, agent-accessible, and agent-operable.