Unified Checkout for AI Agents: The Complete Guide

Winning visibility is half the work. If the shopper taps Buy inside ChatGPT and gets kicked to a desktop form on your website, you've lost 30-50% of the conversion lift agentic commerce is supposed to unlock. Unified checkout — where the transaction completes inside the agent surface — is the load-bearing close.

---

TL;DR

• Unified checkout is the pattern where an AI agent completes the purchase inside the shopper's conversation, not by kicking them to an external browser.
• The conversion delta is meaningful. Shopify's published data shows +49% CVR for in-conversation checkout vs. external redirect. Our cohort data runs 35-55% across categories.
• Six protocols matter: ACP (OpenAI/Stripe), UCP (Google/Shopify/consortium), AP2 (payments), MCP (tool-use foundation), A2A (agent-to-agent), TAP (trust/verification). No brand should manage all six directly.
• The brand stays merchant of record. This is non-negotiable. Vendors that want the MoR seat from you are taking the most valuable position at your table.
• The 90-day plan: weeks 1-2 audit + platform assessment. Weeks 3-8 protocol integration + payment stack. Weeks 9-12 measurement + optimization.

---

What unified checkout actually means

Unified checkout is the pattern where a shopper who's talking to an AI agent — ChatGPT, Gemini, Perplexity, Rufus, Copilot, Claude — completes the transaction inside the agent conversation, without being redirected to an external website or app.

The mechanic: agent shows a product card. Shopper taps Buy. Agent summons an in-conversation purchase sheet — variant selection, quantity, shipping address confirmation, payment method. Shopper confirms. Transaction completes. Order lands in your commerce backend as a normal order with an agent-source tag.

The alternative — call it "kicked-out checkout" — is what most brands still have today. The agent shows the product card. Shopper taps. Agent opens the shopper's default browser at your product page. Shopper is now on your website, presented with a cart form designed for humans on desktops. Conversion collapses by an order of magnitude.

The difference between these two flows is the entire ROI argument for agentic commerce today. If you can be discovered but can't close in-conversation, you're competing one-handed.

---

The conversion economics

Shopify's H1 2026 webinar series quoted +49% conversion rate for in-conversation checkout vs. external redirect, across the merchants they measured. Our internal cohort data (~30 brands across DTC categories) shows 35-55% depending on category:

• Household consumables — 55%+ lift (voice-friendly, replenishment behavior compounds).
• Considered purchases (electronics, home appliances) — 45-50% lift.
• Fashion / accessories — 30-40% lift (variant complexity slows the in-conversation flow).
• Beauty / personal care — 40-45% lift.

The lift is not marketing spin. It's mechanical: shoppers who commit inside a conversation face zero context switch, zero re-authentication, zero cart abandonment friction. Every fraction of a percent conversion improvement compounds into meaningful revenue when volumes scale.

Without unified checkout enabled, your best-case AI-driven revenue is ~50-60% of what it could be. That gap is the case for prioritizing this work.

---

The six protocols (in one paragraph each)

Unified checkout runs on protocols. Six matter. You need a strategy for each, but you shouldn't be integrating all six yourself.

ACP (Agentic Commerce Protocol) — Co-built by OpenAI and Stripe. Powers ChatGPT Instant Checkout and Copilot commerce. Single-item origin, multi-item since Q4 2025. Delegated payment via Stripe-issued agent tokens. Currently the most-integrated protocol. See ACP glossary entry.

UCP (Universal Commerce Protocol) — Google + Shopify + retail consortium. Endorsed at NRF 2026 by Walmart, Target, Wayfair, Etsy, and (Q1 2026) Amazon. Multi-item native, full-funnel from discovery to returns. Powers Gemini, AI Overviews, Google's Buy for Me. See UCP glossary entry.

AP2 (Agent Payments Protocol) — Cross-industry payments spec. Standardizes agent-payment authorization, tokenization, and settlement. Works inside ACP or UCP transactions. Handled by payment processors (Stripe, Adyen) + tokenization vendors (Basis Theory, Nekuda, Skyfire).

MCP (Model Context Protocol) — Anthropic-authored, now industry-standard. Defines how AI assistants discover and call external tools — merchant product catalogs, inventory systems, fulfillment APIs. Foundation layer beneath ACP/UCP for custom agent experiences.

A2A (Agent-to-Agent) — Machine-to-machine protocol layer. How a shopping agent hands off to a fulfillment agent, customer-service agent, or returns agent. Increasingly important as multi-agent flows mature.

TAP (Trusted Agent Protocol) — Verification layer. Confirms agent identity, session, and authorization scope. Prevents agent impersonation and unauthorized transactions.

The load-bearing insight: you don't need six integrations. You need one abstraction layer that translates all six. That's what Tru Commerce provides. For a Shopify brand, most of this is near-turn-key. For custom stacks, it's 2-3 weeks with the abstraction vs. 4-6 months without.

---

The merchant of record decision

Every unified checkout implementation forces a question: who is the merchant of record?

The default in most vendor pitches is "we are." The checkout vendor becomes the MoR — they hold the customer email, they issue the receipt, they handle the refund, they capture some of the margin. The brand becomes a fulfillment partner.

Our position: the brand stays MoR. Always. No exceptions in the product design. The agent is a channel — like an affiliate, like a marketplace, like Amazon Buy for Me — never a replacement for your storefront.

Practically this means:

• The customer's email is yours.
• The order data is yours to segment, remarket, retarget.
• The margin capture is yours.
• The refund experience is yours.
• The customer's next-purchase attribution is yours to earn.

If you're evaluating unified checkout vendors, this is the single most important contract line. Read it carefully. Vendors that want the MoR seat are taking the most strategically expensive position at your table — often without brands realizing until year two, when the "MoR is us" clause makes it hard to negotiate for data access.

See Agent Merchant of Record glossary entry for the full framework.

---

The 90-day plan

Weeks 1-2 — Audit + platform assessment

• Inventory current checkout flow. For each of the six agent surfaces you appear on, document what happens after a shopper taps Buy. Do they stay in-conversation? Get kicked to your website? Get kicked to a mobile browser?
• Platform assessment. What's your commerce backend (Shopify / BigCommerce / custom)? What's your payment processor (Stripe / Adyen / custom)? These determine the integration complexity.
• Measure the gap. Estimate current conversion rate for agent-driven traffic vs. traditional. If DACT is working, the delta is visible. If not, wire DACT first (see DACT methodology).

Deliverable: a one-page brief showing "you're closing X% of the theoretical possible; you can move to Y% in 90 days."

Weeks 3-6 — Protocol integration

• ACP live. For Shopify brands, this is largely turn-key (a config change plus a Stripe validation). For BigCommerce, near-turn-key. For custom stacks, 2-3 weeks of engineering — but only if you use an abstraction layer. Without an abstraction, plan 4-6 weeks.
• UCP live. Same pattern. Shopify + UCP is native; custom stacks need integration.
• Payment stack confirmation. Verify your payment processor supports agent-payment tokens. Most Stripe accounts already do. Non-Stripe processors may need config or feature request.

Deliverable: end-to-end test of an ACP-native purchase for one SKU + an UCP-native purchase for another SKU.

Weeks 7-8 — Fulfillment + returns

• Order routing. Agent-completed orders arrive with a source tag (source: chatgpt_acp or similar). Configure your fulfillment system to handle these correctly — same shipping SLA, same returns policy, same customer service flow.
• Returns flow. Returns inside agentic commerce work depending on the specific protocol. Amazon Buy for Me handles them via Amazon or the merchant per agreement. ACP/UCP typically leave returns to the merchant, initiated through the agent. Design the flow.
• Cart edge cases. Multi-item carts, quantity variants, subscription enrollment, gift-message inputs. Each needs an ACP/UCP path.

Weeks 9-12 — Measurement + optimization

• Track agent-source revenue. Your commerce backend should now report agent-driven orders separately. Cross-reference with the DACT panel for surface-level attribution.
• Optimize the purchase sheet. ChatGPT's ACP purchase sheet has a fixed form factor, but you control the shipping options, the returns clarity, the payment methods offered. Test these.
• Handle abandonment. Agent-driven cart abandonment is real. Wire the abandonment signal to a re-marketing flow — but respect the shopper: agentic commerce shoppers reject aggressive follow-up.

By end of quarter:

• Agent-driven CVR up 30-55% on optimized SKUs (verified via DACT).
• Ratio of "kicked-out" to "in-conversation" purchases moved from ~90:10 to <30:70.
• A monthly rhythm of purchase-sheet testing, order-flow monitoring, and protocol-update tracking.

---

What we see going wrong

Patterns we've watched brands stumble on:

• Vendor lock-in via MoR trojan horse. The checkout vendor's contract includes MoR as the default. Brands sign without reading. Two years later, they can't get the customer data they need for retargeting.
• Managing protocols in-house. ACP alone is manageable. Adding UCP, then AP2, then MCP, then A2A, then TAP compounds fast. Brands end up with 1-2 permanent engineers on protocol translation — none of which differentiates them. Use an abstraction layer.
• Skipping the returns design. Agent-completed purchases still need returns. Skipping the returns UX means the first return goes wrong, the shopper hates it, and Rufus/ChatGPT deprioritize you.
• Not enabling both ACP and UCP. ChatGPT owns roughly a third of agentic transactions today; Google surfaces (Gemini + AI Overviews + Buy for Me) own another third; Amazon owns the remainder. Enabling only ACP leaves Gemini's third on the table.
• Optimizing the purchase sheet like it's a website. Agentic checkout is not a landing page. Shoppers reject long forms, upsell pop-ups, and cross-sell insertions. Keep the flow clean.

---

Where this fits in the stack

Unified checkout sits at Layer 05 of the 7-Layer Map (checkout execution). It's downstream of Layer 06 (discovery / visibility — see AI Search Visibility guide) and upstream of the fulfillment work.

For most brands, the sequence is:

1. Visibility first — get in the answer.
2. Unified checkout second — convert the answer to a transaction.
3. Attribution and DACT third — measure and reallocate.

Trying to close the loop before you have discovery in place is putting the cart before the horse. Trying to have discovery without close-the-loop is putting the cart on top of the horse. Both stages need each other.

---

CTA

If your commerce backend is Shopify, unified checkout is faster to enable than most brands expect. If it's custom, the abstraction layer saves you 3-4 months and 1-2 permanent engineers.

Start with a free Citation Rank scan — the scan includes an integration-readiness assessment for your top SKUs across ACP and UCP. If you're ready to wire everything, book a demo. Growth tier is 2% per agent transaction (no platform fee, no MoR seat taken). Enterprise pricing kicks in at volume.

The +49% conversion lift is not marketing spin. It's mechanical. Every brand that installs unified checkout compounds it into meaningful revenue over 6-12 months.

— The Tru Commerce team (formerly Asva AI)

---

FAQs

Q: What's the minimum I need to enable unified checkout? A: For ChatGPT specifically: ACP integration + a payment processor that supports ACP delegated tokens. For Shopify brands, this is a settings change plus a Stripe validation. For BigCommerce, similar. For custom stacks, either direct ACP integration (~4-6 weeks) or via an abstraction layer (~2 weeks).

Q: Do I have to enable both ACP and UCP? A: If you want to close the loop on ChatGPT (~30% of agentic volume), Gemini (~25%), and Copilot (~5-10%), you need ACP + UCP. Enabling only one leaves half the agentic surfaces one-handed. Amazon-related surfaces (Rufus, Buy for Me) run on their own protocols; you don't manage those directly.

Q: Can I stay merchant of record if I use a checkout vendor? A: With the right vendor, yes. Tru Commerce is designed so the brand always stays MoR. But many vendors default to taking the MoR seat. Read the contract carefully. If MoR flows to the vendor, you lose customer relationship control.

Q: How does this interact with my existing Shopify checkout? A: Complementary. Traditional web-shoppers still complete on your Shopify checkout. Agentic shoppers complete via ACP/UCP inside the agent. Both flows land as orders in your Shopify backend, with source tags distinguishing them. Reporting, fulfillment, returns all work the same way.

Q: What about fraud in agentic checkout? A: Handled at the protocol layer (TAP + AP2 for agent identity and payment authorization) plus your existing fraud stack. Agentic transactions typically have lower fraud rates than open-web checkout because agent surfaces authenticate the shopper before the payment. Signifyd, Riskified, and HUMAN all support agent-source transactions natively.

Q: What if a customer wants to return an agent-purchased order? A: Depends on protocol. ACP orders: customer initiates via the agent (they say "I want to return this"); the agent forwards a return intent to your commerce backend; you process the return the way you normally would. UCP orders: similar flow. Amazon Buy for Me: partner agreement determines whether Amazon or the merchant processes.

Q: How long does implementation take? A: For Shopify + ACP + UCP: 2-3 weeks from decision to live. For BigCommerce: 3-4 weeks. For custom stacks with an abstraction layer: 2-4 weeks. For custom stacks doing direct integration: 4-6 weeks minimum, often 8-12 weeks with edge cases. Enterprise integrations with custom protocol work run 30-60 days.