Why AI Agents Don't Complete Purchases (Yet) — and What Merchants Can Fix Today
AI shopping agents excel at product discovery and comparison — but they stall at checkout. Here are the five structural reasons why, and what merchants can fix today while protocols catch up.
AI shopping agents can now find products, compare prices, read reviews, and build shortlists with remarkable accuracy. What they cannot do — reliably and at scale — is complete a purchase. The gap between recommendation and transaction is the single biggest bottleneck in agentic commerce today, and understanding it is essential for any merchant planning their AI strategy.
This is not a technology limitation that will be solved by a software update next quarter. It is a structural challenge involving payment authorization, identity verification, policy ambiguity, and trust architecture. Merchants who understand these bottlenecks can fix the ones within their control right now — and position themselves ahead of the protocol-level solutions arriving in 2026 and 2027.
The Core Problem
AI agents can get a shopper 90% of the way to a purchase. The last 10% — payment, identity, and confirmation — requires trust delegation that most systems and consumers are not yet ready to grant.
The Five Reasons Agents Stall at Checkout
1. Payment Authorization Has No Agent Standard
When a human shopper checks out, they enter a credit card number, authenticate via 3D Secure, or tap Apple Pay. An AI agent cannot do any of these things without explicit credential delegation from the user — and no widely adopted standard exists for this delegation today.
Protocols like AP2 (Agent Payments Protocol) and Stripe's agentic commerce toolkit are building this infrastructure. AP2 defines how agents request payment consent with scope limits (amount caps, merchant restrictions, time windows). But adoption is early-stage, and most merchants have no integration path yet.
What this means for merchants: The checkout flow you build today should anticipate a future where an agent, not a human, initiates the payment. Support express payment methods (Shop Pay, Apple Pay, Google Pay) that already have device-level authentication. These are the most likely first candidates for agent-delegated payments.
2. Return Policies Are Written for Lawyers, Not Machines
Ask an AI agent whether a store accepts returns on opened electronics, and it will often respond with uncertainty. That is because most return policies are buried in legal pages, written in dense prose, and riddled with exceptions that are difficult to parse programmatically.
For an agent to confidently recommend a merchant, it needs to answer: Can this be returned? Under what conditions? Within what timeframe? What does the customer pay for return shipping? If those answers require navigating five pages and interpreting conditional clauses, the agent will either skip the merchant or add a disclaimer that erodes buyer confidence.
What merchants can fix today:
- Add a structured return summary to every PDP — not a link to a policy page, but a visible box with key terms.
- Use consistent language: "Free returns within 30 days" is machine-parseable. "See our return policy for details" is not.
- Consider adding return policy data to your Product schema as
hasMerchantReturnPolicystructured data.
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Premium Wireless Headphones",
"offers": {
"@type": "Offer",
"price": "199.99",
"priceCurrency": "USD",
"hasMerchantReturnPolicy": {
"@type": "MerchantReturnPolicy",
"returnPolicyCategory": "https://schema.org/MerchantReturnFiniteReturnWindow",
"merchantReturnDays": 30,
"returnMethod": "https://schema.org/ReturnByMail",
"returnFees": "https://schema.org/FreeReturn"
}
}
}3. Inventory Confidence Is Too Low
AI agents increasingly check whether a product is actually available before recommending it. If your inventory data is stale — updated once daily when stock changes hourly — agents learn that your availability signals are unreliable and deprioritize your listings.
This problem is especially acute for merchants with:
- Multiple warehouses with split inventory
- Dropshipping relationships with delayed sync
- Flash sales or limited-edition products
- High-velocity SKUs that sell out between feed updates
What merchants can fix today:
- Increase feed refresh frequency to at least every 4 hours, ideally real-time via API.
- Implement
availabilityschema that reflects actual stock status, not just "InStock" for everything. - Use Google Merchant Center's automatic item updates to catch price and availability mismatches.
- For high-value SKUs, consider real-time inventory APIs that agents can query directly.
4. Brand vs. Marketplace Trust Is Unresolved
When an AI agent recommends a product from a marketplace like Amazon, the trust model is clear: Amazon handles payment, returns, and fulfillment. When the agent recommends a product from a standalone DTC brand, the trust model is murkier. The agent must assess: Is this merchant legitimate? Will the payment be secure? Will the product actually arrive?
This creates a systematic bias toward large, well-known merchants and marketplaces — and against smaller DTC brands that may actually offer better products, prices, or service.
What merchants can fix today:
- Implement Organization schema with founding date, contact information, and social profiles.
- Ensure SSL certificates, privacy policies, and terms of service are current and accessible.
- Display trust badges, payment security icons, and third-party verification prominently.
- Build review volume — agents weight aggregate ratings heavily. Tools like Klaviyo can automate post-purchase review solicitation.
5. Checkout Flows Were Designed to Stop Bots
There is a fundamental irony in agentic commerce: the same anti-bot measures that protect checkout flows from malicious automation also block legitimate AI shopping agents. CAPTCHAs, rate limiting, fingerprinting, and forced account creation all serve important security purposes — but they make agent-assisted checkout nearly impossible.
This is not a problem merchants can fully solve unilaterally. It requires protocol-level solutions where merchants can distinguish between authorized shopping agents and malicious bots. UCP and ACP are building toward this by defining agent authentication and capability negotiation standards.
What merchants can fix today:
- Support guest checkout — forced account creation is the most common hard stop.
- Implement cart deep-linking so agents can construct pre-filled checkout URLs.
- Enable express payment methods that reduce the number of form fields.
- Consider agent-friendly checkout paths that use API-based cart creation rather than browser-based flows.
The Protocol Landscape: What Is Being Built
Several protocols are specifically addressing the agent checkout gap:
| Protocol | Focus | Status (Mid-2026) |
|---|---|---|
| UCP | End-to-end agent-merchant negotiation including checkout | Live in Google AI Mode, expanding |
| ACP | OpenAI + Stripe checkout flows | Live in ChatGPT Shopping |
| AP2 | Agent payment consent and authorization | Early adoption, Visa/Mastercard aligning |
| MCP | System-level agent integration | Broad developer adoption |
The key insight for merchants: you do not need to implement these protocols today. But you do need to build a storefront that is compatible with them when they mature. That means clean data, accessible APIs, clear policies, and frictionless checkout — the same improvements covered in our UCP Readiness Audit Checklist.
What Merchants Should Prioritize Right Now
While the protocol ecosystem matures, merchants have a clear hierarchy of fixes:
- Fix your structured data. This is the single highest-leverage change. Valid Product, Offer, and Review schema makes your products machine-readable today.
- Make policies explicit and visible. Move return, shipping, and warranty summaries onto PDPs. Use structured data for return policies.
- Enable guest checkout and express payments. Remove the friction that agents cannot navigate.
- Keep inventory data fresh. Stale availability signals erode agent trust and lead to recommendation exclusion.
- Build review volume. Products with strong, recent reviews get recommended more. Automate solicitation.
The Bottom Line
AI agents will complete purchases at scale. The infrastructure is being built right now across multiple competing and complementary protocols. The merchants who benefit first will not be the ones who wait for perfect agent checkout — they will be the ones who remove every obstacle between agent recommendation and human purchase confirmation.
The checkout gap is temporary. The competitive advantage of being agent-ready is not.
Frequently Asked Questions
Can AI agents actually buy things today?
In limited scenarios, yes. Amazon's "Buy for Me" feature and ChatGPT Shopping with Stripe-enabled merchants demonstrate early agent-assisted purchasing. But fully autonomous buying — where the agent handles payment without human confirmation — remains rare and restricted to specific platforms.
What is the biggest thing merchants can fix right now?
Structured data and policy visibility. These require no protocol integration, no API development, and no checkout redesign. They immediately improve how AI agents evaluate and recommend your products.
Will agents prefer marketplaces over DTC brands?
Currently, yes — because marketplaces offer consistent trust, payment, and fulfillment guarantees. DTC brands can close this gap by implementing strong schema markup, building review volume, and ensuring transparent policies.
When will AI agents routinely complete purchases?
Industry signals suggest 2027–2028 for mainstream agent-completed transactions, with early implementations in 2026 via platforms like Shopify (UCP) and ChatGPT (ACP). The timeline depends on payment protocol adoption and consumer trust delegation.