The Universal Commerce Protocol (UCP) is an open-source standard developed by Google in collaboration with major industry leaders (e.g., Shopify, Etsy, Target, Walmart) and endorsed by over 20 global partners (e.g., Adyen, Mastercard, Stripe). Its primary objective is to power the next generation of agentic commerce by establishing a common language and functional primitives for seamless commerce journeys between consumer surfaces, businesses, and payment providers.

UCP addresses the prevalent "N x N integration bottleneck" in traditional e-commerce infrastructure, where businesses must build bespoke integrations for every consumer surface. It solves this by standardizing the entire commerce journey—from discovery and consideration to purchase and order management—through a single, secure abstraction layer. This methodology involves:

1. Unified Integration: Collapsing complex N x N integrations into a singular integration point for various consumer surfaces (e.g., AI Mode in Google Search, Gemini app).
2. Shared Language: Standardizing discovery mechanisms, capability schemas, and transport bindings to ensure cross-platform interoperability and end-to-end support for the commerce lifecycle.
3. Extensible Architecture: Built with flexible capabilities and an extensions framework, allowing for scalability as new agentic experiences emerge and facilitating expansion into new verticals.
4. Security-First Approach: Employing tokenized payments and verifiable credentials to ensure secure communication between agents and business backends, with every authorization backed by cryptographic proof of user consent.

The core methodology of UCP revolves around defined "services" and "capabilities" exposed by businesses. Businesses publish these in a standard JSON manifest located at /.well-known/ucp. This allows agents to dynamically discover features, endpoints, and payment configurations without hard-coded integrations. Key technical components include:

• Services: High-level commerce functionalities (e.g., dev.ucp.shopping). Each service can specify a version, a spec URL, and transport-specific bindings (e.g., rest binding with schema and endpoint).
• Capabilities: Core commerce building blocks within services (e.g., dev.ucp.shopping.checkout, dev.ucp.shopping.discount, dev.ucp.shopping.fulfillment). Capabilities can define schemas and may extend other capabilities (e.g., discount extends checkout).
• Payment Architecture: UCP separates payment *instruments* (what consumers use to pay) from *payment handlers* (payment processors). The /.well-known/ucp manifest includes a payment.handlers array, detailing supported handlers with their id, name, version, spec, config_schema, instrument_schemas, and specific config objects (e.g., Google Pay's merchant_info, allowed_payment_methods). This modular design enables open interoperability and choice.
• Transports: UCP supports multiple communication transports, including dedicated APIs, Agent2Agent (A2A), and the Model Context Protocol (MCP), providing flexibility for how agents and businesses interact.

A practical workflow demonstrates this methodology:

5. Business Server Setup: A business (e.g., a flower shop) sets up a server (e.g., Python-based, from python-sdk and samples) and populates a product database (e.g., SQLite via import_csv.py).
6. Capability Discovery: An agent initiates a GET request to $http://<SERVER_URL>/.well-known/ucp$. The server responds with a JSON object detailing available ucp services and capabilities, as well as payment.handlers. This dynamic discovery allows the agent to understand what actions it can perform and with which payment methods.
7. Checkout Invocation: To create a checkout session, the agent sends a POST request to $http://<SERVER_URL>/checkout-sessions$. The request body includes line_items (product id, quantity), buyer details, currency, and payment.handlers (derived from the discovery step). Key HTTP headers like UCP-Agent, request-signature, idempotency-key, and request-id are used for context and transaction management. The server responds with a unique id for the checkout session, details of line_items, buyer, status (e.g., ready_for_complete), currency, and totals.
8. Applying Discounts: To modify an existing checkout, the agent sends a PUT request to $http://<SERVER_URL>/checkout-sessions/{CHECKOUT_ID}$. The request body includes the checkout_id and a discounts object containing codes (e.g., 10OFF). The server processes the discount and updates the checkout session's totals to reflect the reduced amount, providing details of the applied discounts (e.g., amount, title, allocations).

Google provides the first reference implementation of UCP, powering direct purchases within its conversational experiences (e.g., AI Mode in Search, Gemini) and leveraging existing Google Pay and Google Wallet integrations. UCP is designed to be neutral and vendor-agnostic, fostering an open-source, community-driven development model for the future of agentic commerce.