A shopping agent needs more than a product name. It must select the right variant, respect availability, understand delivery and present the final total before a purchase. Every ambiguity that frustrates a shopper can also interrupt an agent.
WebMCP gives a supporting browser a more direct way to ask the page for an action. The merchant’s practical job is to make the underlying catalog and buying journey dependable, then test the supported tools against that reality.
Audit one product journey
- Choose a representative product. Include variants, delivery constraints and a return policy. Start with a test environment and an approved payment test flow.
- Verify the facts. Check product IDs, variant labels, stock, prices, currency, availability and policy links. Structured access does not correct bad source data.
- Check platform support. Review the current Shopify or payment-provider documentation for your exact storefront and checkout. Do not paste a generic script into checkout and assume it has the provider’s permissions.
- Test discovery through cart. Ask for an eligible product, choose the right variant, inspect the cart and verify quantities and totals.
- Inspect the purchase review. Make delivery, payment method, total and the buyer’s confirmation unambiguous. Test human challenges and the return to the normal page.
- Verify completion independently. In an approved test order, confirm the order record, receipt and fulfillment state. Stop at review if your test does not authorize a purchase.
Separate browser-facing storefront tools from an authenticated store-management MCP server. A shopper’s catalog access should not inherit an administrator’s ability to edit products or issue refunds. Build only the surface the task needs.
Make the business experiment explicit
Your technical pilot can answer whether an agent finishes a checkout correctly, how long it takes and how often it needs help. A conversion experiment needs real eligible traffic, a defined comparison, instrumentation and enough observations. Reduced tokens are not additional revenue. Track completed paid orders and refunds separately from agent sessions, cart creation and checkout attempts.
MCP and WebMCP: what each one does
When people say “use an MCP,” they usually mean connect an AI assistant to an MCP server. Model Context Protocol gives an AI application a structured way to discover and call tools, read resources and use reusable prompts. The server is the program that exposes those capabilities; it may run locally or at a remote URL. It can wrap an API you already have.
WebMCP is a browser API proposal for tools exposed by the current webpage. The browser agent can ask for a named action with structured inputs instead of inferring every step from buttons, screenshots or page markup. It is useful when the open page and its session are part of the job. You can build a WebMCP tool without deploying a remote MCP server.
| Need | Start with | Example |
|---|---|---|
| Work across applications | MCP server | Look up approved project information from an assistant. |
| Act in an open webpage | WebMCP | Search the page’s catalog or select an available option. |
| Connect ordinary software services | Existing API | Apply your application’s business rules and permissions. |
| Delegate between independent agents | An agent-to-agent protocol | Coordinate separate agents; this is a different layer. |
Neither protocol grants extra account access. Tool names and annotations describe behavior; your application still has to enforce it. Keep pricing, eligibility, access control and validation in the same business logic used by the ordinary product.
What companies have actually shown
| Example | Verified implementation or evidence | What to take from it |
|---|---|---|
| Shopify | Storefront tools expose catalog and cart actions. Checkout support can hand control back for buyer confirmation or challenges. | Test your actual theme, checkout and payment path; platform support does not prove every customization works. |
| Stripe | Its September engineering study reported 42% fewer tokens, 38% fewer tool calls and 39% faster completion. | The study used 60 checkout runs across six models with a fictional retailer, split between WebMCP and baseline. It did not establish merchant sales lift. |
| Lovable | The October 13 changelog added browser tools alongside agent integrations, with an option to use WebMCP without an MCP server. | Review the generated tools and their scope rather than assuming every app action should be exposed. |
| Cloudflare + Commerce.com | A beta edge bridge can expose existing commerce tools. | Infrastructure can carry tool definitions; it cannot invent correct business rules for an arbitrary site. |
| Meta | Official developer examples demonstrate voice-driven web-app actions for glasses. | Examples and rollout documentation are not proof of universal device availability or measured production impact. |
A separate Shopify benchmark by Gil Greenberg reported average completion falling from 27.4 to 10.3 seconds and 58% lower cost in controlled checkout tasks. That is about 2.7 times as fast for those tasks. Treat it as motivation to run your own evaluation, not a forecast for your store. The source’s aggregate attempt counts are inconsistent, so we do not repeat a sample-size claim.
Use an existing MCP: four steps
- Choose a narrow job. Write a request with an observable result, such as “find the three approved documents about onboarding and return their source links.” Start with information you can independently verify.
- Find the official connection. Follow the provider’s own setup page. A remote integration generally supplies a URL and may use an account authorization flow. A local server supplies a launch command and runs on your computer. A directory entry alone is not proof that a package is the provider’s official software.
- Review what it can do. Check the connected account and workspace, available tools, requested permissions and whether the assistant requires confirmation for changes. Use the narrowest useful access. Keep credentials in the host’s supported secret settings, not in prompts or public configuration files.
- Ask, inspect and verify. Run one read-only request. Compare the tool result with the original application. Record missing data, errors and which account was searched before moving to edits or automation.
Use the connected tool to find information about [topic]. Return the source links and the exact result. Separate missing information from facts. Do not change records or send messages.
If tools do not appear, check that your assistant supports the server’s transport, the connection is enabled, authorization has finished and your account has the required access. For local servers, check executable paths and logs. A successful connection is only the first test; the requested task still has to work.
Create an MCP server: start with one useful tool
You are building an adapter around a real capability. Define the contract before choosing a framework: what is the tool called, what input does it accept, what does success return, who may use it, and what happens when it fails?
- Choose one read-only function. Our example searches two fictional workshops. It has no account credentials and cannot book, publish or charge anything.
- Describe inputs and outputs precisely. A topic is a nonempty string of up to 80 characters. Results contain stable workshop IDs and a
demo: truemarker. A valid search with no matches returns an empty array; invalid input returns an error. - Register the function with an official SDK. The Python example in the starter kit uses
FastMCPfrom the officialmcppackage’s v1 line. This is different from installing a separate package namedfastmcp. - Test discovery and execution. A tool that imports successfully may still fail when a client calls it. Exercise the actual protocol, including errors, before connecting an assistant.
- Connect a compatible host. Supply the absolute Python executable and server file paths. The host launches the local process and communicates over standard input/output, or stdio.
- Replace demo data deliberately. Integrate one real API, enforce user authorization, bound result sizes, set timeouts and return clear errors. For remote distribution, use Streamable HTTP and appropriate authentication; do not expose this unauthenticated local lab on the public internet.
Follow the full AI Teachers coding walkthrough for environment setup, the complete server, VS Code configuration and expected results. The starter kit on this page contains the same tested files.
Implement the browser path step by step
- Keep a working normal form or interface for the task.
- Feature-detect
document.modelContextin a supported test browser. - Register a named tool with a description, input schema and execution function.
- Have the tool call the same business function as the normal interface.
- Return a precise result and update visible state where appropriate.
- Test tool discovery, execution, errors, page lifecycle and the unsupported-browser fallback.
Use the complete JavaScript example and browser instructions to try this with fictional data. WebMCP is a progressive enhancement; a successful mock test alone does not verify the target browser’s native API.
A practical five-day pilot
| Day | Work | Evidence to keep |
|---|---|---|
| 1 · Choose | Pick one frequent task and a clear definition of done. | Baseline completion, errors and time for representative cases. |
| 2 · Specify | Write the tool contract and account boundaries. | Inputs, outputs, permission checks, error states and an owner. |
| 3 · Implement | Wrap existing business logic with one read-only tool. | A working tool plus a human fallback. |
| 4 · Break it | Test invalid input, no results, timeouts, expired sessions and access to another account’s records. | Expected versus observed results; unresolved failures. |
| 5 · Compare | Repeat the same tasks with the same model and starting conditions. | Verified success, latency, cost, retries and handoffs. |
Track cost per successful task, not only cost per attempt. Record median and slow-tail completion times, tool errors, human interventions and duplicate actions. Compare like-for-like tasks. A tiny learning pilot can expose obvious problems; it cannot prove a statistically reliable revenue lift.
For changes such as creating bookings, updating a CRM or issuing a refund, add a review step with the actual details. Enforce permissions on the server, defend against repeated requests, record the result ID, and provide recovery. Treat text returned from third-party content as data, not instructions that can override the user’s request. Keep secrets and unnecessary personal information out of results and logs.
Proceed when the task is useful, results are verifiable and failures are recoverable. Pause when permissions are unclear, source data is unreliable or there is no owner to maintain the connection. Neither MCP nor WebMCP automatically improves search rankings, creates demand or guarantees agent traffic.
Try it yourself
Download the Python server, protocol tests, browser demo, example host configuration and editable pilot worksheet. No email required.
Download the starter kit (.zip)Open the browser demoThe catalog is fictional. The kit demonstrates the connection mechanics; it is not a deployed booking integration.
Common questions
Do I need to create an MCP server to use an existing one?
No. Connect the provider’s server using its documented setup and a compatible assistant. Build your own only when you need a capability the existing tools do not provide.
Does WebMCP replace a normal website or API?
No. Keep the human interface and the backend’s business rules. WebMCP exposes selected page actions to compatible browser agents.
Will this automatically improve traffic or revenue?
No. Structured actions can make a supported task easier to perform. Discovery, customer demand and commercial results need their own evidence.
Continue with the guide for your role
- AI Product Manager — MCP and WebMCP for product teams: from promising demo to useful feature
- AI Teachers — MCP and WebMCP, step by step: connect a tool, build a server, try it in a browser
- UX Design Coach — Designing for WebMCP: make agent actions understandable, reviewable and recoverable
- Waymaker Agency — Build a useful MCP integration: a practical implementation plan for small teams
Sources and further reading
- MCP architecture
- Python SDK v1 maintenance documentation
- Python SDK v2 and migration
- Connect an MCP server in VS Code
- Chrome WebMCP overview
- Current imperative WebMCP API
- WebMCP draft specification
- Shopify storefront tools
- Shopify checkout support
- Shopify benchmark by Gil Greenberg
- Stripe checkout engineering study
- Lovable product changelog
- Cloudflare and Commerce.com
- Meta WebMCP examples
Original guide and teaching examples by Ashley Kays. Inspired by the questions raised in Department of Product’s WebMCP coverage; independently written and checked against the primary sources above. Sources reviewed November 15, 2026. Cover: AI-generated conceptual illustration. Diagrams: original explanatory graphics. Demo workshops are fictional.
