Technical Architecture and Implementation

Introduction

In Part 1, we covered the business case for Universal Commerce Protocol (UCP) and why CMOs should prepare for agentic commerce. Now let's examine how UCP actually works, what integration requires, and how it fits into your existing commerce infrastructure.

For technical leaders, product managers, and engineering teams responsible for platform modernization, understanding UCP's architecture is essential to evaluating integration effort and planning roadmaps.

How UCP Works: The Core Concepts

UCP is built on a capability-based architecture. Instead of prescribing rigid workflows, it lets retailers and AI agents negotiate what features they support and proceed with transactions based on mutual capabilities.

1. Discovery and Negotiation

Both the merchant (your eCommerce platform) and the AI agent (Gemini, ChatGPT, etc.) publish "profiles" declaring what they support.

Merchant profile example (exposed at /.well-known/ucp on your domain):

Agent profile example (what Gemini or another AI platform supports):

When a user initiates a purchase through an AI agent, the agent and your commerce backend exchange profiles, compute the intersection of capabilities, and proceed with what both support. If your platform offers loyalty rewards but the agent doesn't support that capability yet, checkout proceeds without it—no integration breaks.

2. Modular Capabilities and Extensions

UCP defines core capabilities and allows domain-specific extensions:

Core Shopping Service:

• Product catalog discovery
• Cart/checkout session management
• Line items, totals, and pricing
• Transaction status

Standard Capabilities:

• Checkout: Complete purchase flow with payment
• Fulfillment: Delivery options, scheduling, tracking
• Discounts: Promotional codes, percentage off, conditional offers
• Orders: Post-purchase order status, modifications, cancellations
• Catalog: Product search, filtering, attribute queries

Custom Extensions: Retailers can define proprietary capabilities (subscription billing frequency, gift messaging, custom engraving) by extending the base schema. Agents that don't support your custom extension will skip it; those that do can surface it in the conversational UI. This extensibility prevents the protocol from collapsing under complexity—a problem that plagued earlier e-commerce standards.

3. Payment Architecture: Separation of Instruments and Handlers

UCP separates what consumers use to pay (payment instruments) from how payments are processed (payment handlers).

Payment Instruments:

• Google Pay
• PayPal
• Shop Pay (Shopify)
• Apple Pay
• Credit cards stored in digital wallets

Payment Handlers:

• Stripe
• Adyen
• Shopify Payments
• PayPal Commerce Platform
• Authorize.net

A customer might use Google Pay as their instrument, but your backend processes it through Stripe. UCP negotiates both layers, ensuring the agent knows what the consumer can use and your platform knows what it can process.

This design integrates with Agent Payments Protocol (AP2), Google's payment-agnostic framework announced in 2025. AP2 provides cryptographic proof of user consent for every transaction—critical for security and fraud prevention in agent-driven commerce.

4. Transport Flexibility

UCP isn't locked to a single communication protocol. It supports multiple transports:

• REST APIs (JSON over HTTP)
• Model Context Protocol (MCP) – Anthropic's standard for AI agent-to-service communication
• Agent2Agent (A2A) – Google's protocol for cross-agent coordination
• JSON-RPC – For systems preferring RPC-style APIs

This means your eCommerce platform can expose UCP capabilities using the transport layer that fits your existing architecture. If you're already running RESTful APIs for headless commerce, you can map UCP endpoints to those APIs without rewriting your stack.

Integration Requirements: What Your Platform Needs

To support UCP, your commerce platform must expose the following:

Minimum Viable Integration (Native Checkout)

1. Product Catalog API

• Return structured product data: ID, title, price, images, attributes, inventory status
• Support filtering and search queries from AI agents
• Real-time or near-real-time inventory signals

2. Checkout Session API

• Create checkout sessions with line items
• Calculate totals (subtotal, tax, shipping, discounts)
• Apply promotional codes
• Return checkout status (ready, pending input, completed)

3. Payment Handler Integration

• Accept payment instruments (Google Pay, PayPal, etc.)
• Process transactions and return confirmation
• Handle authorization and capture workflows

4. Order Confirmation API

• Return order details after purchase
• Provide order tracking information
• Support post-purchase queries (order status, shipment tracking)

Optional Advanced Capabilities

• Fulfillment Options: Multiple delivery methods, scheduling, pickup locations
• Loyalty Programs: Account linking, points redemption, member pricing
• Subscriptions: Billing frequency, renewal terms, pause/cancel options
• Returns and Exchanges: Initiate returns, process refunds, manage exchanges
• Personalization: Account-based pricing, saved preferences, purchase history

Platform-Specific Implementation Paths

Shopify Merchants

Shopify has built native UCP support. Merchants can enable agentic storefronts through Shopify Admin with minimal configuration. Product feeds automatically sync, and checkout sessions are managed by Shopify's backend.

BigCommerce / Commerce

Commerce (parent company of BigCommerce and Feedonomics) announced UCP support at launch. Feedonomics' data enrichment layer optimizes product feeds for Google's schema, improving discovery and match rates in AI search.

Custom or Legacy Platforms

If you're running a custom-built commerce platform or legacy system (Magento 1.x, SAP Commerce, Adobe Commerce on-premises), you'll need to:

• Build REST APIs exposing UCP-required endpoints
• Implement the .well-known/ucp profile endpoint
• Integrate with payment providers supporting Agent Payments Protocol
• Handle real-time inventory and pricing updates

Embedded vs. Native Checkout: Two Integration Models

Google offers two checkout experiences:

1. Native Checkout (Default)

The AI agent handles the entire checkout flow within its interface (Gemini, AI Mode). Your backend provides APIs for product data, pricing, and order processing, but the UI is controlled by the agent.

Pros:

• Fastest time to integration
• Consistent user experience across AI platforms
• Lower abandonment (no redirects)

Cons:

• Limited brand control over checkout UI
• Can't customize the purchase flow for complex offerings

2. Embedded Checkout (Optional, Approved Merchants Only)

For brands with highly specific checkout requirements (custom gift messaging, complex subscription options, regulatory disclosures), Google allows an iframe-based embedded checkout within the AI interface. Your platform renders the checkout UI; the agent wraps it in context.

Pros:

• Full control over checkout branding and UX
• Support for complex purchase workflows

Cons:

• More development effort
• Requires approval from Google
• Potential friction from in-app webviews

Recommendation: Most brands should start with native checkout. Embedded checkout is for edge cases where the purchase flow is too complex for a standardized experience.

UCP vs. ACP: Will the Standards Converge?

OpenAI's Agentic Commerce Protocol (ACP), launched in September 2025, powers purchases inside ChatGPT. How does it differ from UCP?

Architecture Philosophy

• ACP is narrowly focused on checkout and transaction flows. It standardizes how agents complete purchases but doesn't cover catalog discovery or post-purchase support.
• UCP is broader, covering the full commerce journey: discovery, buying, fulfillment, returns, and customer service.

Developer Support

• ACP is backed by OpenAI and Stripe (infrastructure-first companies)
• UCP is backed by Google, Shopify, and major retailers (merchant-first companies)

Compatibility

Both protocols work with overlapping standards (A2A, AP2, MCP), so they're not mutually exclusive. A retailer can implement both—in fact, many will need to support both to reach consumers across ChatGPT and Google.

The industry is likely moving toward convergence. Having competing standards creates short-term fragmentation, but market pressure and shared underlying protocols (MCP, AP2) will drive alignment. Think of this like the early days of mobile payments: Apple Pay and Google Pay coexist because both use NFC and tokenization standards.

Security and Fraud Considerations

Agent-driven commerce introduces new fraud vectors:

User Consent

How do you prove the user authorized the purchase? UCP + AP2 requires cryptographic proof of consent for every transaction. The payment instrument (Google Pay, PayPal) includes a user confirmation step before the agent completes checkout.

Inventory Manipulation

AI agents query inventory in real-time. Malicious actors could send automated queries to scrape pricing or manipulate stock availability. Rate limiting and API authentication are critical.

Merchant Verification

How does an AI agent know it's connecting to a legitimate retailer? UCP requires TLS (HTTPS) and optionally supports OAuth for authenticated sessions.

Practical Implementation Timeline

Phase 1: Assessment (4-8 weeks)

• Audit existing commerce APIs
• Identify gaps between current capabilities and UCP requirements
• Evaluate platform partner UCP roadmaps (if on SaaS commerce)
• Define integration scope (native vs. embedded checkout)

Phase 2: Development (8-16 weeks)

• Build or extend APIs for product catalog, checkout, and orders
• Implement .well-known/ucp profile endpoint
• Integrate with payment providers supporting AP2
• Test against Google's UCP reference implementation

Phase 3: Pilot (4-8 weeks)

• Join Google's UCP waitlist (currently required)
• Launch with limited product catalog
• Monitor transaction success rates, abandonment, attribution
• Gather customer feedback on conversational commerce UX

Phase 4: Scale (Ongoing)

• Expand product catalog coverage
• Add advanced capabilities (loyalty, subscriptions, returns)
• Optimize product data for AI discoverability
• Integrate additional AI platforms (ChatGPT, Microsoft Copilot)

Note: For enterprises on modern composable commerce platforms, Phase 2 can be significantly shorter (4-8 weeks) because the required APIs often already exist.

What's Next

In Part 3, we'll cover the marketing implications: how SEO and Answer Engine Optimization (AEO) strategies must evolve for agentic commerce, how product discoverability changes when AI agents are the curators, and what CMOs need to rethink about demand generation and customer acquisition costs.

About Dotfusion

Dotfusion has 25+ years of experience modernizing enterprise commerce and content platforms. We've helped organizations migrate from monolithic architectures to headless, API-first systems that support emerging channels like agentic commerce.

Need help assessing your platform's readiness for UCP? Connect with our team.