WebMCP and Dynamic Personalization for AI-Assisted Shoppers

The short version
WebMCP is a proposed browser standard that lets a web page hand a shopper's AI agent a short list of structured tools. One of those tools can carry what the shopper just said they want, such as an occasion or a budget, to a store's existing personalization engine, which then chooses from content the brand has already approved.
Browser and Shopify details were checked against the official documentation listed at the end in November 2026, and they may change.
Stated intent is better evidence than clicks
Picture a shopper who tells the assistant in their browser: "I need a gift for my brother. He travels every other week and he's sick of checking bags."
Most stores learn about a person like that slowly. They watch which pages open, which filters get clicked and how long someone lingers, and then a personalization engine guesses. After enough browsing it might decide this shopper likes carry-on luggage. The shopper already said so in one sentence.
The catch is that stated intent costs effort. Nobody wants to fill out a twelve-field quiz before they see a product. A browser agent can do that translating for them, if the site gives it a place to put the answer.
What WebMCP is, in plain language
WebMCP is a proposed web standard for exposing structured tools to AI agents from inside a web page. Without it, an agent has to read the page and imitate a person, clicking buttons and typing into boxes. With it, the page says what it can do and what input each action takes. Chrome's documentation describes two ways to publish tools: an Imperative API written in JavaScript, and a Declarative API that annotates ordinary HTML forms. The tools run on the page, visibly, while the shopper is looking at it.
It is early. Chrome describes WebMCP as under active discussion and subject to change, with an origin trial starting in Chrome 149. Shopify says agent support is currently limited to Chromium-based browsers. Plan a pilot for the share of your visitors on a supporting browser, and make sure everyone else gets the ordinary site.
WebMCP also differs from the server-side MCP connections many teams already use. A server-side connection lets software call a service over the network with no browser page involved, which is the kind we covered in Claude MCP for Marketers. WebMCP tools exist only while a page is open in a tab. Shopify draws the same line in its documentation: its WebMCP tools serve agents that shoppers bring to your store in their browser, while its MCP servers are for agents you build yourself.
WebMCP is not a personalization engine or a customer data platform, and it doesn't connect to any vendor's systems on its own. It's a doorway. What stands behind the doorway is the store's decision.
What Shopify already covers
Shopify's documentation says it provides WebMCP tools on every Liquid storefront, and Hydrogen storefronts load them by default when the browser supports WebMCP. A merchant can turn them off in Hydrogen with a webMcp setting. Shopify's August 5, 2026 changelog entry says there is nothing to install or configure.
The tool list covers catalog work (search_catalog, browse_store, get_product, show_variant), cart work (get_cart, update_cart) and a handoff to checkout (proceed_to_checkout). We don't rebuild any of that. Catalog, cart and checkout stay Shopify's job.
The gap is narrower. As documented, those tools search, browse and manage the cart. Nothing in the documentation describes them changing how the storefront presents itself to that shopper, and that layer belongs to whatever personalization the store runs.
The architecture
- Shopper makes a request
- Browser agent
- Scoped preference tool
- Approved personalization rules
- Visible storefront change
- Shopify catalog and cart tools
The store registers one narrow custom tool next to Shopify's. We call it set_shopping_context. It accepts a few values chosen from fixed lists: an occasion (gift, for me, replacement), a recipient type, a budget band, a needed-by date and a short list of interest categories the brand has defined. It does not accept names, email addresses, delivery addresses or a free-text life story.
The page script passes those values to the personalization engine as a signal for the current session. The engine matches them against experiences the brand's team has already written and approved, such as a gift guide for frequent travelers or a collection reordered by carry-on size. If nothing matches, nothing changes. Once the page has adjusted, the agent carries on with Shopify's tools to search and fill a cart.
The shopper sees all of it. A line near the top of the page reads "Showing gift ideas for frequent travelers under $100. Change or clear." That tells the shopper what their agent told the store, and lets them undo it.
Where Fleet personalization plugs in
The middle of that diagram is where Fleet's personalization app sits. It holds the approved experiences, decides which visitor gets which one and counts what happens afterward. WebMCP adds one new input to a system that already does those three jobs.
In Fleet, an experience is a set of coordinated changes to named elements on a page, such as a headline, a block of safe HTML or an image, plus the rules for who sees it. Rules can match on URL parameters, referrer, region, device, new or returning status, first-party categories and the path a visitor has taken in the current tab. An agent drafts the experience from the live page and the brand's approved wording. A person previews it on desktop and mobile, publishes it and can roll it back. The agent that drafts an experience has no way to publish it.
The shopper's agent contributes one new kind of category. When set_shopping_context accepts a call, the page hands the validated values to Fleet's script as session categories: occasion is gift, interest is travel, budget is under $100. The rule on the gift guide experience matches those categories the same way it would match a campaign parameter or a device type. The store's team writes that rule once, and every later call that fits it gets the same approved page.
Shopper's browser
- The shopper describes what they want
- Their agent calls
set_shopping_contextwith values from fixed lists
Store page
- Checks every value against the allowed lists
- Shows the shopper what was set, with an option to change or clear it
- Passes the values to Fleet as session categories
Fleet personalization
- Matches the categories against experience rules
- Applies the approved experience, or leaves the page alone
- Counts exposures and goals in aggregate
Each experience maps a small set of inputs to one approved page and one measured goal. The first two rows below come from the uses described earlier. The last row shows what happens when nothing matches.
| Shopper's agent sends | Rule in Fleet | Shopper sees | Goal Fleet measures |
|---|---|---|---|
| Occasion: gift. Interest: travel. Budget: under $100 | Categories gift and travel | The approved gift guide for frequent travelers, plus the real delivery cutoff | Click on a product in the guide |
| Comparison focus: fit, broad shoulders | Category fit comparison | The brand's fit guide and size notes ahead of reviews | Size notes stay in view for one second |
| Values that match no rule | None applies | The standard page | No experience exposure recorded |
Fleet can run an experience with a worthwhile goal as an A/B test. Each browser is assigned to the control or the variant once and keeps that assignment. Control browsers see the standard page, and Fleet receives daily totals for each arm with no visitor identity attached. The eligible sessions here are the ones where the shopper's agent called the tool.
On Shopify, when Fleet's first-party data connection is also installed and the shopper has consented, the comparison can go further: add to cart, checkout and purchase counts for each arm, with purchase and revenue figures taken from signed paid orders. Until the sample is large enough, Fleet reports that it is still collecting and names no winner.
Three uses
Gift discovery is the example above. The agent passes the occasion, the interest and a budget band, and the store leads with its approved travel gift collection and a delivery cutoff message drawn from its real shipping policy.
Comparison and fit is the second. A shopper asks which of two jackets runs warmer or fits broad shoulders. The agent passes the comparison focus, and the engine moves the brand's own fit guide and size notes ahead of reviews. The words on the page come from approved material. The agent never writes claims on the brand's behalf.
The third is personalization QA, and shoppers never see it. A separate tool registers only inside authenticated preview sessions for the brand's team and ours. It reports which experience is active on the page and which rule chose it, so a reviewer's agent can check each audience state without clicking through every variation.
Brand control, consent and boundaries
- Approved content only. The tool selects among existing experiences. It never writes copy, sets prices or invents offers.
- Narrow inputs. Fixed lists and short validated values. Anything that looks like personal data is rejected.
- Consent and data minimization. Treat the signal as session-only unless the shopper has consented under the site's existing consent settings. Shopify's documentation notes that its tools take no authentication tokens and that the shopper's page, session and checkout state decide what each tool can do. A custom tool should follow the same rule.
- Visible and reversible. Anything the agent sets is shown on the page and can be cleared by the shopper. Chrome's documentation also describes a confirmation dialog for sensitive actions such as purchases.
- Tool output is data. Shopify advises agents to treat merchant and third-party text in tool responses as data and never as instructions, because it can carry prompt injection. Our tool returns a structured confirmation and nothing free-form.
- Ordinary-browser fallback. Without WebMCP the site behaves as it does today, including any personalization built on consented browsing behavior.
- Publishing stays human. A shopper's agent never reaches raw customer profiles, internal credentials, audience builders or publishing controls. Those sit behind authenticated sessions, previews and human approval.
How to judge a pilot
Measure in layers, because each answers a different question.
- Tool health: how many calls completed, how many failed validation and what errors came back.
- Exposure: how often a call led to an approved experience being shown, and how often nothing matched.
- Shopper response: whether people cleared or changed the context, and whether they reached product pages.
- Conversion: a controlled comparison among eligible sessions, where some get the personalized experience and some get the standard page. Count orders once, from Shopify's order records, and don't add browser events on top of them.
Volumes will start small, since only some visitors arrive with a supporting agent. Report counts until there's enough traffic for a percentage to mean something, and don't promise a lift before you've measured one.
Where to start
If you're on Shopify, begin by seeing what your store already exposes. Chrome's documentation links a Model Context Tool Inspector extension and a DevTools panel for inspecting the tools a page exposes. Then pick the three or four inputs your brand could safely accept, and list the approved experiences each would map to. If you have none yet, that's the real starting point, and our posts on dynamic content personalization and AI-powered experience optimization cover how to build them.
If you'd like to think it through for your store, our AI Enablement work and Fleet, the agentic system we use to run personalization with human review, are where we'd begin. Talk with us, and we'll tell you plainly what's ready to use and what's still a proposal.


