Skip to main content

WebMCP Is Bringing AI Agents Into the Browser. Commerce Still Runs on the Server.

An ecommerce browser session connected through a secure boundary to backend commerce services for inventory, cart, payment and order validation.

An architectural guide to Shopify, Salesforce, Adobe, commercetools and PayPal—and to deciding which agent actions belong in the shopper’s tab and which belong in the commerce backend.

An AI assistant that shops through a browser has a familiar problem: it must infer what a button does, which field expects a postcode, and whether a cart change has actually been saved. WebMCP gives websites a more direct option: expose named tools with structured inputs and outputs instead of asking an agent to guess its way through the interface.

That is useful, but it does not move the system of record into the browser.

Shopify has shipped WebMCP tools for storefronts and checkout, while recommending server-side Checkout MCP whenever the agent can run independently of the buyer’s tab. Salesforce is taking a UCP and server-MCP route; Adobe’s Commerce MCP is still marked Coming Soon. The real architecture question is not whether an agent can click faster. It is which system is allowed to commit the price, reserve inventory, accept payment and create the order.

For commerce teams, WebMCP, MCP and UCP should not be treated as competing versions of the same feature. They solve related problems at different layers.

What WebMCP actually changes

Traditional browser agents often work by interpreting a page visually or inspecting its DOM, identifying controls, and simulating clicks and text entry. That can work, but it becomes fragile when a storefront has dynamic components, custom filters, multi-step checkout, variant selectors or asynchronous cart updates.

WebMCP gives a site a way to expose a defined tool surface to an agent working in the browser. A storefront can register JavaScript tools or annotate standard HTML forms so that an agent can discover the available actions, understand their input schema and call them directly. The current API surface uses document.modelContext, including methods such as getTools() and executeTool(). The WebMCP draft and Chrome implementation guide document the current API and its experimental status.

This is not a finished web standard. The Web Machine Learning Community Group published its current Draft Community Group Report on 13 November 2026; the document explicitly says it is not a W3C Standard and is not on the W3C Standards Track. Chrome opened an origin trial from Chrome 149, and its guidance says WebMCP is primarily designed for local browser workflows with a human in the loop—not as a headless server-agent interface (Chrome origin-trial announcement). Shopify also states in its WebMCP documentation that agent support is currently limited to Chromium-based browsers. Teams should treat it as an evolving browser capability and build a fallback for shoppers and agents that do not support it.

The practical benefit is narrower—and more useful—than the hype suggests. A site can describe its own operations rather than forcing an agent to reverse-engineer every visible control. A product page might expose a tool to select a valid size and check availability. A cart might expose an action to update quantity. A checkout page might let a browser agent read the current delivery choices or move to the next step.

The site still owns the implementation behind those tools. WebMCP does not create a new inventory service, payment system or permission model.

WebMCP, MCP and UCP are different layers

The names are similar, but the roles are not.

TechnologyWhat it providesWhere it normally runsCommerce example
WebMCPA browser API for a page to expose structured tools to an agentIn the active browser documentAn agent reads a live cart or updates a checkout field in the shopper’s open tab
Model Context Protocol (MCP)A protocol for an AI client to discover and call tools exposed by a serverA local or remote MCP serverAn external agent searches a product catalogue or creates a checkout through an authenticated service
Universal Commerce Protocol (UCP)Commerce-specific capability and lifecycle contracts for businesses, platforms and payment participantsAcross compatible commerce integrations and transportsA merchant publishes a capability profile and supports a standard checkout lifecycle

UCP is not simply another name for server-side MCP. It is designed to work across transports, including REST, MCP and A2A. It defines commerce-oriented capabilities and the data exchanged between a platform and a business. MCP can be one way to expose those capabilities to an agent. The UCP specification sets out this transport-agnostic model.

Shopify makes the relationship unusually clear: its Checkout MCP and Checkout WebMCP guide says both implement the same UCP checkout capability. One is called from the agent’s server through JSON-RPC; the other is called from the buyer’s browser through document.modelContext. The business capability is shared, but the execution context is different.

That distinction should guide the architecture review.

Why the browser session matters—and why it is not a security boundary

A browser-resident agent can work with the page the shopper is already using. The page may already have a logged-in session, a current basket, selected variants and checkout state. A WebMCP tool can use that state because the site has deliberately implemented the tool in the page context.

But WebMCP does not magically authenticate the agent as the shopper, and it does not grant the agent permission to perform every action available to the browser. The browser exposes only the tools the page registers. The merchant’s backend must still validate the shopper, resource ownership, pricing, promotions, inventory, payment and order transitions.

Shopify’s WebMCP documentation makes the distinction explicit: its tools do not accept authentication tokens as tool arguments; the shopper’s page, session and checkout state determine what each tool can do. Shopify also uses Web Bot Auth to identify browser agents on requests. That identifies the agent for bot-handling purposes; it does not replace buyer consent or the merchant’s authorization rules.

The security issue is broader than browser cookies. Product descriptions, reviews, Q&A, seller listings and external content can contain instructions that an agent should not treat as trusted commands. Chrome’s security guidance recommends labelling untrusted tool output, using read-only and consequential-action hints where appropriate, restricting cross-origin exposure and keeping user confirmation for consequential actions. Those hints help the agent; they do not replace server-side enforcement.

Shopify: WebMCP is live, but server-side Checkout MCP is the default recommendation

Shopify is the clearest production example of WebMCP in commerce today. Its developer documentation says WebMCP tools are available on Liquid storefronts and on Hydrogen 2026-10 storefronts that render ShopifyScripts or call initializeShopifyScripts. When a compatible browser agent visits the storefront, it can use tools for product discovery, cart management and navigation.

Checkout has its own tools. Checkout WebMCP lets a browser agent read and update the checkout open in the current tab, navigate checkout steps and place the order after the buyer confirms it. If the shopper encounters a payment challenge, such as 3-D Secure, the buyer completes that action in the same tab.

The important part is Shopify’s recommendation. Its guide says to use Checkout MCP when the agent can run on a server. In that model, the agent owns a checkout session it creates and manages independently of the buyer’s browser. Shopify recommends Checkout WebMCP only when the agent is already operating in the buyer’s browser.

This builds on the channel-control point in Tailoredd’s earlier Shopify Agentic Storefronts article, but narrows the question to the execution boundary. There are good engineering reasons for the split:

  • The browser tool is tied to the current document. executeTool() can return null if navigation happens before the result arrives. The tool list can change as the shopper moves through checkout, so the agent must listen for toolchange and refresh its registry (Shopify Checkout WebMCP implementation notes).
  • The browser completion call has no idempotency-key parameter. Shopify documents state checks such as complete_in_progress and completed, but Checkout WebMCP does not use id, meta or an idempotency key. The agent must inspect the current checkout state and follow the documented recovery flow rather than blindly resubmit after a timeout (Shopify Checkout WebMCP).
  • Buyer confirmation remains essential. Shopify requires the buyer to see the current order and total and authorize submission before complete_checkout is called. A Web Bot Auth signature or a ready_for_complete state is not buyer approval.

None of this makes Checkout WebMCP a poor design. It makes it appropriate for a specific situation: a browser agent helping a person who is already working in that checkout. When the agent needs a durable, independently managed checkout session, the server-side route is the better fit.

Salesforce B2C Commerce: UCP GA, Shopper MCP Pilot and developer MCP tooling

Salesforce’s current B2C Commerce documentation describes three distinct tracks. They should not be presented as one general-purpose agent feature.

UCP integration is generally available from B2C Commerce 26.9. Salesforce says the implementation allows compatible platforms to discover a merchant’s capabilities and conduct checkout while the merchant remains Merchant of Record. The current release is limited to en-US sites, and Google is the first live platform at GA. Salesforce publishes the merchant profile at a well-known UCP URL; checkout-session APIs require the relevant SLAS authentication. Salesforce OMS is optional, and a third-party OMS can be connected for order lifecycle events (Salesforce UCP integration guide).

The useful architectural point is that this is not WebMCP. It is a server-side commerce capability and lifecycle integration. Salesforce’s implementation guide describes a UCP Checkout Session as a headless view over a standard Commerce Cloud Basket. Standard Basket and Order hooks—including dw.order.calculateTax, dw.order.calculateShipping, dw.ocapi.shop.basket.validateBasket and dw.order.createOrderNo—run in this flow. SFRA/SiteGenesis controllers and hooks registered against other SCAPI resources do not automatically run. The Enable Salesforce Commerce API Hook Execution feature toggle must also be enabled. Teams therefore need to audit their existing checkout and move or bridge logic that currently lives in controllers or unrelated SCAPI hooks into the appropriate UCP hooks (Salesforce technical audit, implementation considerations).

This is a more useful readiness test than simply checking whether a site is on 26.9. Tax, shipping, promotion, payment and order processing remain backend responsibilities, but some existing custom checkout logic may need to be relocated before the UCP flow behaves like the current storefront checkout.

The B2C Commerce MCP Shopper Service is a Pilot. Salesforce documents a hosted MCP service for external assistants such as ChatGPT and Claude to search products, read product details, build a basket and return a checkout link. It requires a SLAS JWT with the sfcc.shopper-mcpagent scope. Salesforce explicitly distinguishes this service from its Agentforce Shopper Agent; the documentation says the two are separate offerings, and connecting the MCP service to Agentforce is not currently supported. Salesforce also limits the pilot to a defined set of shopper functions rather than exposing the full SCAPI suite, and notes that pilot performance is for demonstration purposes (Salesforce MCP Shopper Tools Quick Start).

The Agentic B2C Developer Toolkit is another separate use case. Its MCP and skills help developers and operators search documentation, inspect logs, debug cartridge code and work with permitted SCAPI Admin APIs. That is developer and operational tooling, not the same thing as a customer-facing shopper agent (Salesforce toolkit documentation).

For SFRA, PWA Kit or Storefront Next teams, a custom frontend could add WebMCP tools as a progressive enhancement when the browser supports them. That would be storefront implementation work. The platform-level Salesforce capabilities documented today are UCP and server-side MCP, with the availability boundaries above.

Adobe Commerce: Commerce MCP is documented, but still marked Coming Soon

Adobe’s Experience League Commerce MCP overview was updated on 13 November 2026 and is labelled Coming Soon. Adobe describes a customer-facing assistant experience that can support conversational product discovery, session context, cart management, checkout and post-purchase guidance.

That is a meaningful product direction, but the availability label matters. It should not be described as a generally available Adobe Commerce MCP service.

As with Salesforce, an Adobe storefront team could technically add browser-side WebMCP tools in its own frontend where the browser API is supported. That is not the same as Adobe shipping a native WebMCP integration. In this review, the public Adobe Commerce MCP capability remains Coming Soon.

commercetools and PayPal show two other sides of the market

commercetools made Managed MCP Servers generally available on 16 July 2026. Its Commerce MCP lets agents interact with project resources such as products, carts, orders and customer data. Merchants can select which tools are exposed and filter or redact fields, with managed and self-hosted options. This is a server-side MCP implementation, not a browser WebMCP integration.

PayPal is a more direct WebMCP example. In a 16 September 2026 developer post, PayPal described extending WebMCP support through its JavaScript SDK for merchants using its Store Sync platform. The flow lets compatible agents discover products, prepare a cart and initiate checkout, then hands the buyer to PayPal to sign in, select or confirm a funding source, review the transaction and approve payment. PayPal says the capability is optional and limited to Store Sync customers today. The headline of the post is broader than the currently documented availability, so it should not be read as a general rollout to every PayPal merchant.

The market is therefore not moving in one direction. Shopify and PayPal are showing browser-level WebMCP experiences; Salesforce is publishing UCP and server-side MCP capabilities; commercetools has a generally available server-side MCP service; Adobe’s customer-facing Commerce MCP is still marked Coming Soon.

Where WebMCP helps in a real commerce operation

The value of WebMCP is highest when the agent and shopper are working in the same browser experience. It is less compelling as a replacement for backend orchestration.

1. Product discovery, guided fit and configuration

A browser agent could use structured tools to compare product variants, select a compatible size, configure a bundle or filter a complex B2B catalogue. The storefront can reflect the action immediately, so the shopper sees the same page state as the agent.

The server must still confirm the product, price, promotion eligibility and sellable inventory. A browser result is a working view, not an inventory reservation or a binding price promise.

2. Cart and checkout co-browsing

When a shopper asks an assistant to add a second item, change a colour or review shipping options while both are in the same tab, WebMCP is a natural fit. The agent can work with the live UI and explain what it changed.

When the agent runs outside the browser, needs to preserve a checkout between sessions or orchestrate a longer purchase flow, server-side MCP and UCP are more appropriate. The buyer should still receive a clear review of items, delivery, payment and final total before order placement.

3. Reviews, Q&A and product evidence

An agent helping a shopper compare two products may need more than a star average. It may need verified review context, size feedback, fit comments or product Q&A. A browser tool can make a focused read operation available from the page, but review text remains untrusted user-generated content and should not be treated as an instruction to the agent.

This is also why server-rendered content and agent tools solve different problems. Tailoredd’s ReviewFlow architecture documents server-side review rendering for Salesforce Commerce Cloud, while its published MCP reference describes read-only access to structured review and catalogue context. That does not make ReviewFlow a WebMCP product; it illustrates that reliable content delivery and tool-based browser actuation are complementary layers. The separate question of getting review data into Merchant Center is covered in our Google Product Ratings troubleshooting article; that feed-distribution problem should not be confused with exposing review context to an agent on a live page.

4. Subscriptions, COD and payment decisions

A shopper might ask an in-browser agent to skip a subscription delivery, change a product or update a delivery preference. WebMCP can help stage the request in the portal. Billing schedules, payment-token references, dunning, churn-save eligibility and gateway operations still belong in the subscription service.

The same rule matters in India. An agent can help a buyer complete a COD form, but address validation, OTP verification, COD risk scoring and prepaid-conversion rules must be applied by the backend before an order is accepted. A browser tool must not be able to bypass those checks.

5. Marketplace and OMS orchestration

A shopper sees one cart. The backend may need to split it across sellers, check seller-specific inventory, reserve stock, calculate shipping, create order lines and send fulfilment instructions to multiple systems. Those decisions do not belong in browser JavaScript. Tailoredd has covered the related order-state and reconciliation problem in A Marketplace Order Isn’t One Order. Our companion Salesforce OMS decision-engine article examines the post-checkout side: recorded routing decisions, fulfilment and operational recovery. This article focuses on the browser-to-server handoff before and during checkout.

WebMCP can provide a clearer customer-facing interface for the actions the shopper is allowed to take. Seller routing, inventory reservations, order orchestration, settlement and returns remain owned by the commerce platform, OMS, ERP and marketplace services.

A practical rule for deciding what belongs in the browser

OperationWebMCP is useful when…Keep the authoritative decision in…
Product search and guided selectionThe agent is helping with the current storefront pageCatalogue, pricing and availability services
Cart editsThe agent and shopper are co-browsing the same active cartCommerce cart service
Checkout navigation and field updatesThe buyer is present in the current browser checkoutCheckout and payment services
Price, tax, promotion and inventory validationThe agent needs to explain or stage a choiceCommerce engine and inventory system
Payment capture, order placement, refund or cancellationA consequential transaction is being committedPayment service, commerce platform and OMS
Subscription changes and COD risk decisionsThe agent is helping the buyer submit a requestSubscription engine and server-side risk rules
Marketplace seller split and fulfilmentA single cart needs multi-party orchestrationMarketplace services, OMS and ERP

The browser can be an interaction surface. It should not become the ledger.

Six checks before exposing WebMCP tools

  1. Treat WebMCP as progressive enhancement. The storefront must still work when the API or a compatible agent is unavailable. Chrome describes WebMCP as an evolving capability, and Shopify currently limits agent support to Chromium-based browsers.
  2. Keep tools small and explicit. Name each action clearly, use structured inputs, and expose only the operations relevant to the current page state. Keep tool registration aligned with route and component lifecycle; refresh the registry when the tool set changes.
  3. Validate on the server. Do not rely on JavaScript callbacks, tool descriptions or read-only/consequential hints as authorization. Re-check the shopper, cart, price, stock, permissions and exact state in the backend.
  4. Make confirmation specific. Before a consequential action, show the exact item, amount, shipping choice and transaction being approved. A confirmation for one checkout state should not silently authorize a later state after the total or contents change.
  5. Design for retries and navigation. Handle timeouts, page transitions, stale tools and partially completed requests. Query the current transaction state before retrying a payment or order operation; make server-side idempotency and recovery behaviour explicit.
  6. Treat external content as untrusted. Reviews, Q&A, seller descriptions and third-party responses can contain prompt-injection text. Mark untrusted data, restrict tool exposure and keep audit records for consequential actions.

The Tailoredd view: browser tools should connect to governed commerce services

At Tailoredd, we see WebMCP as another way for an agent to operate a storefront—not as a replacement for the commerce services behind it. Our published Commerce MCP & Governed AI Architecture reference distinguishes current production read-only MCP connectivity from roadmap work on governed actions that require human approval. That distinction is important: an agent being able to inspect a product, review or subscription status does not mean it should be allowed to alter price, billing or order state.

For commerce teams, the practical sequence is straightforward. Make product and customer-facing information structured and dependable. Expose a narrow set of browser tools where the shopper benefits from live co-browsing. Keep authentication, pricing, tax, inventory, payments, risk and order execution behind deterministic services with explicit permissions, auditability and recovery.

The agent interface may change from a webpage to a conversation. The responsibilities of the commerce platform do not.

Evaluating how your commerce stack should expose agent capabilities? Start with Tailoredd’s Commerce MCP & Governed AI Architecture reference and use it to separate read-only access, staged actions and approved mutations in your own architecture review.


Frequently asked questions

What is WebMCP in ecommerce?

WebMCP is a browser API that lets a website expose structured tools to an AI agent operating in the browser. In ecommerce, those tools can support product discovery, cart updates and checkout interactions without relying only on visual clicking or DOM interpretation.

Is WebMCP the same as Model Context Protocol?

No. WebMCP exposes tools through a web page in the browser. Model Context Protocol connects an AI client to tools exposed by an MCP server. They can complement each other, but they have different execution contexts and lifecycle requirements.

Is WebMCP the same as Universal Commerce Protocol?

No. UCP defines commerce capabilities and data contracts such as checkout and order lifecycle. Those capabilities can be exposed through different transports, including REST, MCP and A2A. Shopify’s Checkout MCP and Checkout WebMCP both implement the same UCP checkout capability.

Does Shopify support WebMCP?

Yes. Shopify documents live WebMCP tools for Liquid storefronts and eligible Hydrogen 2026-10 storefronts, with browser-agent support currently limited to Chromium-based browsers. Shopify recommends server-side Checkout MCP when the agent can run on a server, and Checkout WebMCP when the agent is already in the buyer’s browser.

How does Salesforce B2C Commerce support agentic commerce?

Salesforce documents UCP integration as generally available from B2C Commerce 26.9, currently limited to en-US sites, with Google as the first live platform at GA. Its separate B2C Commerce MCP Shopper Service is a pilot for external assistants, and its Agentic B2C Developer Toolkit MCP serves developers and operators.

Is Adobe Commerce MCP available now?

Adobe’s Experience League Commerce MCP overview was last updated on 13 November 2026 and is marked Coming Soon. It should not be represented as generally available until Adobe updates its official availability information.

Should WebMCP place orders or capture payments?

It can participate in a browser-based checkout flow, but the merchant should keep order placement and payment authority in deterministic backend services, require the buyer to review and confirm the exact transaction, and design explicit retry and recovery behaviour.


This article reflects public documentation reviewed on 16 November 2026. WebMCP is an evolving Community Group draft and browser implementation; vendor features, browser support, pilot eligibility and release availability can change. Revalidate vendor release notes and regional restrictions before implementation.

tailoredd Data and AI Practice
Written by

tailoredd Data and AI Practice

Data Cloud, AI, and Automation Systems

The tailoredd Data and AI Practice writes about production AI workflows, data architecture, and governance patterns for commerce teams.

View Profile →