Shoppers are already arriving through AI. Adobe Analytics reported that traffic to US retail sites from generative AI tools rose 693.4% during the 2025 holiday season, with those shoppers converting at a higher rate than non-AI traffic.
The Universal Commerce Protocol is the open standard that takes the next step, letting an agent complete the purchase rather than hand the shopper off. It is free to use, but a working implementation is not. It still requires product data, live commerce APIs, checkout logic, authentication, payment handling, webhooks, and runtime testing. Shopify has packaged much of that work into its platform. Most Magento, WooCommerce, Umbraco, and custom-store merchants haven’t been given the same shortcut.
Adopting an open standard removes licensing fees and reduces the need to build a different integration for every AI shopping surface. It doesn’t remove the engineering needed to make your store’s existing rules available to an agent. That gap is where the budget goes.
From AI referral to AI purchase
Agentic commerce is shopping in which an AI assistant can act for a shopper, rather than only suggest products or provide links. For example, someone might ask an assistant to find waterproof hiking shoes in size 10 for less than $180 and have them delivered before Friday. With permission, the agent could compare suitable variants, check live availability and shipping options, present a choice, add items to the cart, and complete the purchase after the shopper confirms the item, total, and payment method. The merchant still controls the price, tax, stock, delivery promise, return terms, and other conditions of sale. Without a shared protocol, each merchant and AI platform would need a separate way to exchange those facts and instructions, making every new shopping surface another integration project.
Google announced UCP on January 11, 2026, after co-developing it with Shopify and other commerce companies. UCP checkout initially launched with eligible merchants in the United States, but availability quickly expanded to Canada, Australia, and the United Kingdom on May 20, 2026, with rollout continuing through 2026. UCP exists to provide a common vocabulary for discovering supported functions, maintaining checkout state, linking identity, handling payment credentials, and returning order information. An agent can learn what a store supports and call the relevant operations, while the merchant continues to enforce its existing commerce rules. The protocol standardizes the conversation between systems; it doesn’t replace the systems where products, prices, inventory, payments, and orders are managed.
What UCP defines, and how fast that has grown
UCP’s practical value is interoperability. A merchant can expose one commerce interface instead of writing separate checkout integrations for each AI assistant, search experience, or agent platform.
The January 2026 release organized that interface around four core capabilities:
- Checkout: Create a checkout session, add or change line items, calculate totals, collect required details, and complete the purchase.
- Identity Linking: Connect the shopper’s agent identity to an account held by the merchant, commonly through OAuth 2.0 authorization.
- Order: Return order status and support post-purchase events through structured order data and webhooks.
- Payment Token Exchange: Pass payment credentials through supported payment handlers without exposing raw card details to the shopping agent.
The design is composable. A store publishes the capabilities it supports, then adds extensions such as Fulfillment, Discounts, and Buyer Consent for behavior it needs beyond the core. A merchant doesn’t have to implement every possible feature before publishing a useful profile.
UCP is also transport agnostic. The same commerce capabilities can be exposed over REST, Model Context Protocol (MCP), or agent-to-agent communication (A2A). It is designed to work with Agent Payments Protocol (AP2), rather than requiring merchants to replace their payment architecture with a UCP-specific payment system.
Why Shopify merchants have less implementation work
Shopify has been rolling out UCP support and native MCP servers by default, starting with eligible merchants. The platform owns the catalog model, inventory service, cart, checkout, identity, payment flow, and order lifecycle, so it can expose those systems through a shared implementation.
A Shopify merchant’s main responsibility is therefore the information placed into that implementation. Incomplete titles, vague descriptions, missing variants, inconsistent attributes, and unclear shipping information still give an agent poor material to evaluate.
Other platforms have a different starting point. Adobe has committed Adobe Commerce to UCP, with capabilities rolling out progressively through 2026. Merchants will need to check which capability is available in their specific Adobe Commerce version and hosting model instead of treating the roadmap as one all-or-nothing release.
Magento Open Source has no comparable native implementation. Community modules may reduce part of the work, but an early module shouldn’t be mistaken for a maintained production integration. The merchant still owns compatibility with custom checkout code, extensions, indexers, inventory sources, payment modules, and future protocol versions.
WooCommerce wasn’t a UCP launch partner. A WooCommerce store therefore needs a plugin or custom endpoints that translate WooCommerce products, stock, carts, accounts, taxes, orders, and payment behavior into UCP operations. Umbraco commerce installations and custom stores face the same underlying task, although the implementation will reflect their particular architecture.
That doesn’t automatically make moving to Shopify the right response. The gap is a protocol layer, not an architectural flaw, and that layer can be added to the existing store. Replatforming is usually slower and more expensive than adding an integration, and it may trade away the control and customization that led the merchant to Magento or a custom build in the first place.
What a non-native implementation has to contain
The first thing an agent looks for is a capability profile at /.well-known/ucp. It tells an agent which UCP version and services the merchant supports and where those services can be reached. Publishing that file is straightforward. Making every advertised capability work against the live store is the larger job.
- Expose current product facts. Agents need structured catalog data with stable identifiers, variants, availability, currency, customer-specific pricing where relevant, and enough product detail to compare an item with the shopper’s request.
- Build stateful checkout sessions. The agent must be able to create a cart, change quantities, apply valid promotions, select shipping, provide an address, and receive recalculated totals after each material change.
- Return authoritative tax and stock. Catalog exports aren’t sufficient at checkout. Inventory may change between discovery and purchase, while tax can depend on address, product class, business status, and exemption rules.
- Link identities safely. OAuth 2.0 flows need scopes, consent, token expiry, account matching, revocation, and a clear guest-checkout path. An agent shouldn’t receive broader account access than the transaction requires.
- Connect payments and orders. Payment-handler integration must align with the existing provider, fraud checks, 3D Secure requirements, captures, failures, and retries. Order webhooks then need authentication, idempotency, retry handling, and monitoring.
This is familiar work for 1902 Software’s custom web and integration developers. With more than 28 years in operation, we’ve built and extended Magento, WooCommerce, Umbraco, and custom ecommerce systems, including ERP and PIM integrations and payment and checkout flows. We also build AI agents and custom MCP servers, including the permission model that decides which data and actions an agent can reach.
Technically valid can still fail at runtime
A conformance check can confirm that an endpoint returns the expected schema. It can’t prove that a shopper can buy a real product during a busy trading period. Commerce failures usually appear where protocol messages meet platform behavior.
Consider a Magento store whose catalog index updates every few minutes. The agent may discover an available variant from a cached response, start checkout, and then encounter a different price or out-of-stock result when Magento reads the live inventory source. The UCP response can be valid at every step while the purchase still fails.
WooCommerce has its own failure modes. Object caches, transients, tax plugins, multilingual product records, and checkout extensions may disagree about the current cart. A custom store can fail because two services calculate rounding differently or because an order webhook is processed twice after a timeout.
Testing therefore needs complete agent journeys, not endpoint checks alone. Useful scenarios include:
- A price or stock change between discovery and payment
- Guest checkout and linked-account checkout
- Expired OAuth tokens and revoked consent
- Discount conflicts, shipping restrictions, and tax recalculation
- Payment challenges, declines, retries, and duplicate callbacks
- Webhook delay, replay, and out-of-order delivery
- Cart recovery after an agent or commerce service times out
1902 Software’s web and software testing can cover the store, agent-facing endpoints, backend APIs, integrations, and checkout flows as one system. The acceptance test isn’t “the server returned HTTP 200.” It is whether an agent can place the intended order once, at the correct total, with the correct payment and inventory effects.
Product data is the shared requirement
Product data quality is the one UCP requirement that applies equally to Shopify, Adobe Commerce, Magento Open Source, WooCommerce, Umbraco, and custom stores. Native protocol support can’t infer that “navy” and “midnight blue” are similar, identify an omitted material, or explain whether a replacement part fits a named model.
Agents need explicit facts because they make comparisons from the data available to them. That means stable variant relationships, consistent units, meaningful attributes, accurate availability, clear return and delivery information, and product copy that distinguishes one item from another.
WriteText.ai can help produce and revise product titles, descriptions, metadata, alt text, FAQs, and category content across large catalogs. It doesn’t replace authoritative price, stock, compatibility, or policy data. Those fields must still come from the systems that own them.
The same cleanup also serves Agentic Commerce Protocol (ACP). Following the discontinuation of Instant Checkout in March 2026, ACP is used mainly for discovery, while UCP covers a broader path into transaction handling. A clean catalog and dependable product identifiers support both rather than creating two separate data projects.
UCP is an ongoing integration
UCP uses date-based versioning, and the specification changed substantially four times in eight months. That makes maintenance part of the implementation decision. A merchant needs an owner for version review, regression testing, platform upgrades, deprecations, and changes introduced by payment, tax, or fulfillment extensions.
This is especially relevant to Magento, WooCommerce, Umbraco, and custom ecommerce systems. A core update, checkout extension, cache change, or payment-module release can break an agent journey without changing the UCP profile itself. Custom stores need the same discipline when internal services or schemas evolve.
Continuous Monthly Development fits this recurring work: reviewing specification changes, updating adapters, retesting conformance, and repairing regressions as the store changes. It turns protocol upkeep into an owned backlog rather than waiting for an agent transaction to expose a stale assumption.
Start with an audit, then scope the build
The sensible first step isn’t choosing a plugin. It is identifying whether the store can already provide authoritative catalog, inventory, pricing, tax, identity, payment, and order data through stable interfaces.
A technical audit of your ecommerce stack examines platform components, server configuration, caching, integrations, catalog behavior, checkout functions, and performance under load. It is fixed price, agreed before work begins. For UCP readiness, those findings become a capability matrix: available now, available with configuration, requires development, or blocked by a system limitation. That matrix is what tells you whether this is a configuration job or a build.
If it points to a larger implementation, Project Scoping defines the endpoints, capability phases, security model, payment responsibilities, test cases, exclusions, and rollout plan. That scope becomes a Fixed Price Project, so the cost is known before development begins. If you would rather shape the solution hands-on before committing to a production build, Co-Dev is an alternative route into the same place.
After launch, protocol and platform upkeep moves into Continuous Monthly Development. The sequence is practical rather than mandatory: audit what exists, scope what is uncertain, build what is justified, and maintain the integration as the store and the specification evolve.
A 30-minute meeting is enough to work out which of those steps your store actually needs. Book a meeting and let’s talk through the best way to move your project forward.
