Getting a product into an AI-generated shopping result is becoming an ecommerce optimization problem. Getting an AI agent all the way through checkout is becoming an infrastructure problem — and the second challenge may be harder than the first.
Shopify says orders arriving at its merchants from AI-powered search have grown 15 times since January 2025. That is a striking signal that conversational discovery is already influencing real transactions, even if it starts from a relatively small base. But visibility does not guarantee that a machine acting for the shopper can successfully complete the purchase.
A new Search Engine Journal analysis by Greg Jarboe shifts the agentic-commerce conversation downstream. Structured data, product feeds and commerce protocols can help an AI system find and understand an item. The transaction can still fail when bot protection rejects the buyer, inventory systems disagree, sessions expire, retries duplicate an action or refund states fail to synchronize.
The emerging lesson for ecommerce teams is that AI visibility and agent readiness are different layers of the same funnel. A retailer can optimize the first and still lose the sale in the second.
Shopify says AI-search orders have grown 15 times
The strongest evidence that this matters comes from Shopify itself. In its current guidance on conversational AI for sales, the company says orders coming to Shopify stores from AI search have grown 15 times since January 2025.
The figure should be interpreted carefully. It describes growth in orders attributed to AI-search sources, not a 15-fold increase in Shopify's total commerce volume. A rapidly growing channel can post an enormous percentage increase while remaining much smaller than established acquisition channels.
Even with that qualification, 15x growth is enough to turn agentic commerce from a conceptual SEO discussion into an operational ecommerce question. If more discovery begins inside ChatGPT and other AI systems, merchants need to know what happens when software — rather than the shopper's own hands — tries to move the transaction forward.
Product visibility is only valuable if the infrastructure behind it can accept the buyer.
An agent does not shop like a human
Jarboe interviewed Konstantin Klyagin, founder of software-testing company QAwerk, about what changes when the actor moving through the commerce stack is an AI agent.
The difference is partly behavioral. A human shopper browses irregularly, pauses, changes tabs, abandons a cart and may return much later. An agent can issue structured requests rapidly, compare several products and execute actions in seconds.
Infrastructure designed around normal human pacing can interpret that behavior as suspicious. Rate limiting exists to slow automated request patterns. Bot-detection systems exist to identify software moving faster and more systematically than people. A legitimate commerce agent can therefore resemble exactly the type of automation the security stack was built to stop.
This creates a new engineering requirement: distinguish authorized machine customers from abusive automation without weakening protections against scraping, fraud and attacks.
Bot protection can become conversion friction
Retailers have good reasons to defend ecommerce infrastructure from bots. Automated systems can scrape prices, hoard inventory, test stolen payment credentials and overwhelm endpoints.
The problem is that a blanket rule such as “automation equals bad traffic” becomes less useful when legitimate buyers increasingly delegate actions to software.
Search Engine Journal has already documented the discovery side of this conflict. A July audit of 207 product URLs found 32 returning HTTP 403 errors to the auditing tools. The researchers warned that bot defenses can unintentionally make product data inaccessible to machine systems.
That audit does not prove every blocked test crawler would also block an authorized shopping agent. It does illustrate the architectural tension: the same controls that protect a catalog from unwanted automation can interfere with machine-mediated commerce if identity and permissions are not handled precisely.
Robots.txt is only one part of the access problem
Commerce teams often think about crawler access as an SEO configuration issue. In practice, an agent can be permitted by robots.txt and still be stopped further down the stack.
CDNs, web application firewalls, bot-management systems, API gateways and application-level rate limits can all make independent decisions about automated traffic. A site can therefore appear open at the crawler-policy layer while rejecting the actual requests required to browse or transact.
This means agent-readiness testing has to follow the entire request path. Checking whether a user-agent can fetch a product page is not enough if the same actor cannot create a cart, preserve state or call the checkout endpoint.
For agentic commerce, accessibility is increasingly an end-to-end property rather than a single crawl directive.
Product data has to agree everywhere
One of the most important risks is less visible than bot blocking: multiple systems can describe the same product differently.
Klyagin gave Search Engine Journal a real QA example involving a client funnel called Pridefit. Two components were maintaining separate copies of plan data, with small differences in pricing and attributes. His team removed the duplication and centralized the information so the funnel drew from one source.
The example was not presented as a verified AI-agent checkout incident. Klyagin explicitly told Jarboe he had not seen a confirmed production case where an agent itself caused one of his clients' checkout failures, and he declined to repackage a normal ecommerce bug as one.
What the example demonstrates is the type of inconsistency that becomes more consequential when software is the shopper. A human can notice an unexpected price, refresh the page or ask support. An agent needs the catalog, product endpoint and checkout system to resolve to a coherent machine-readable state.
Inventory disagreement can stop a perfectly discoverable product
Imagine an AI assistant finds a product that satisfies the user's requirements. The feed reports the correct size as available, the description contains the right attributes and the price falls within budget.
The agent selects it and proceeds to purchase. Checkout then queries a different inventory source and reports that the variant is unavailable.
For a human, this is annoying but understandable. The shopper might choose another color or wait for restocking. An autonomous agent operating under defined instructions may have no authorized path for resolving the contradiction.
The visibility work succeeded. The product was found and selected. The transaction failed because the systems disagreed about reality.
Machine-readable accuracy matters more than visual consistency
A storefront can look perfectly coherent in a browser while its underlying data is fragmented. Humans consume the rendered interface; agents may consume feeds, APIs, structured data and protocol responses.
That changes the QA question. Teams cannot simply inspect the page and confirm that the price, image and stock label look correct. They need to compare the machine-facing representations of the same product.
SKU, variant, currency, availability, shipping information, return conditions and price should resolve consistently across the systems participating in the transaction.
This is why product feeds are becoming infrastructure rather than merely a paid-shopping asset. AI systems need structured, dependable facts they can reconcile before acting for a user.
Session logic is another human assumption agents can break
Many commerce applications assume one reasonably continuous browser session. An agent may behave differently.
It can research a product, terminate or suspend activity and return later to complete the purchase. It may interact through a protocol or API rather than preserve the same browser context a human would.
If carts, tokens or transaction states depend too heavily on a continuous session, the system can lose the context required to finish the order. The product remains visible and available, but the checkout no longer recognizes the state the agent expects.
Agent-ready commerce therefore requires explicit testing of interrupted, resumed and cross-system transactions rather than only the familiar human happy path.
Retries make idempotency commercially important
Machines also retry. A request can time out even when the server completed the underlying action, leaving the caller uncertain about the result.
If the agent repeats a payment or order-creation request against an endpoint that is not properly idempotent, the retailer risks duplicate operations. If the system refuses the retry without communicating the original state clearly, the agent may instead conclude that the purchase failed.
This is not a new distributed-systems problem. APIs have needed safe retry behavior for years. Agentic commerce increases its commercial importance because more of the customer journey can be executed programmatically and at machine speed.
Reliability patterns that once belonged mainly to backend engineering are becoming conversion optimization.
Refunds are part of the agentic funnel too
A successful charge is not the end of commerce. Returns, cancellations and refunds also have to propagate correctly across systems.
Klyagin highlights the risk of a refund completing on the merchant side while the updated order state never reaches the agent that initiated it. The financial operation may be correct internally, yet the external actor still sees an unresolved transaction.
A human can call support when a refund status looks wrong. An agent needs a deterministic state it can read and report back to the user.
That means agentic-commerce QA has to test the complete order lifecycle, not just product discovery and payment authorization.
Three tests retailers can run now
The Search Engine Journal article recommends three practical checks that do not depend on predicting which commerce protocol will ultimately dominate.
First, load-test checkout APIs using patterns closer to machine behavior: rapid and parallel requests rather than only slow, sequential human sessions. The goal is to discover whether security controls, capacity limits or application assumptions fail under legitimate automation.
Second, audit product data from the machine's perspective. Compare feeds, APIs, structured data and checkout state rather than relying on what the rendered product page looks like.
Third, test refunds and returns end to end and verify that the resulting state synchronizes correctly on the first attempt. These tests target the foundation that any agentic-commerce protocol ultimately depends on.
Protocol support cannot repair a broken transaction stack
The industry is rapidly building standards intended to connect agents and merchants. Search Engine Journal points to Google's Universal Commerce Protocol, OpenAI's Agentic Commerce Protocol and Salesforce's Agentforce Commerce ecosystem.
These standards can make it easier for systems to exchange product and transaction information, but protocol compatibility does not automatically make the underlying commerce system reliable.
An API can implement the correct interface while returning stale inventory. A merchant can expose product data successfully while a WAF rejects the next automated request. Checkout can accept an order while the refund state fails to synchronize later.
Supporting another protocol is therefore not a substitute for testing the systems behind it.
OpenAI's changing checkout model makes merchant infrastructure more important
Agentic-commerce implementations are also evolving quickly. Search Engine Journal notes that OpenAI has moved away from its earlier native in-chat checkout model toward purchases completed through retailer applications integrated with ChatGPT.
That evolution makes the merchant's own transactional infrastructure more, not less, relevant. Even when discovery happens inside an AI interface, the retailer remains responsible for the systems that validate inventory, create the order, process payment and manage post-purchase state.
The interface presented to the user may change, but the operational dependencies underneath do not disappear.
For ecommerce teams, that is a useful guardrail against chasing only the newest visible integration. The durable investment is a commerce stack that can expose trustworthy state and execute transactions reliably regardless of which agent sends the request.
SEO now reaches into transaction architecture
Technical SEO traditionally asks whether machines can discover, crawl, render, index and understand a product. Agentic commerce adds another verb: act.
A product can pass every traditional visibility check and still fail this new layer. It can rank, appear in an AI recommendation and expose excellent structured data, yet remain effectively unbuyable by an agent because the transactional systems reject or confuse the machine.
This expands the collaboration required around ecommerce visibility. SEO teams understand discoverability and machine access. Merchandising teams own product data. Engineering owns APIs and session state. Security controls bot access. Payments and operations own the order lifecycle.
No single team can make the store agent-ready in isolation.
The new conversion funnel has a machine compatibility layer
For a human shopper, ecommerce teams have spent years optimizing page speed, navigation, product information, cart friction, forms and payment options.
An agent introduces a parallel set of friction points: whether it is recognized as authorized automation, whether it can retrieve consistent state, whether its requests survive rate controls, whether a transaction can resume, whether retries are safe and whether post-purchase changes remain synchronized.
Those issues may never be visible in a conventional CRO session recording because there is no human cursor struggling with the interface. The failure happens between systems.
Agentic conversion optimization will therefore require logs, API traces and automated test suites alongside the familiar analytics and UX tools.
Do not overstate what is already happening
The 15x Shopify figure makes the direction of travel difficult to dismiss, but the current evidence does not justify claiming that agent checkout failures are already widespread across ecommerce.
Klyagin's caution is important. He has not seen a verified client production failure that he can attribute specifically to an AI agent, and the engineering examples in the Search Engine Journal article are used to identify plausible and recurring infrastructure weaknesses.
That is exactly why retailers have an opportunity to test before the failure volume becomes obvious. Waiting for a large body of public incidents would mean waiting until agent-mediated transactions are common enough for broken infrastructure to be harming real customers at scale.
The rational response is preparation, not panic.
Discovery is only half of agentic commerce
Ecommerce marketers are understandably focused on being found. Product feeds, structured data, AI citations and protocol integrations determine whether a product can enter the agent's consideration set.
But a recommendation that cannot become an order is unfinished optimization.
The next stage of agentic commerce will force retailers to connect visibility metrics with transaction reliability. They will need to know not only how often an AI system finds a product but how often an authorized agent can successfully move from product selection through inventory validation, checkout, payment and post-purchase operations.
AI search can bring the customer to the product. The competitive advantage may belong to the merchant whose infrastructure knows what to do when the customer arriving at checkout is software.