WebMCP in the Wild: Who's Actually Implementing It (and How to Get Listed)

Reading a spec tells you what WebMCP can do. Seeing a working implementation tells you what it actually looks like to build one. This post rounds up the real, functioning examples available today, starting with the official reference demos and moving toward the early production adopters — and explains how to get your own site added if you've shipped something.

Why "who's actually doing this" is the right question to ask

Early-preview web platform features generate a lot of explainer content and comparatively few working examples. That gap matters if you're deciding whether to invest engineering time now: a spec with zero real implementations is a much riskier bet than one with reference demos you can inspect, run, and learn from directly. WebMCP currently sits in an interesting middle ground — it has credible, inspectable official demos, and a small but growing set of real sites experimenting with it in production.

The official reference demos

Chrome's own developer documentation publishes source-available demos covering both of WebMCP's APIs, and they're worth working through directly rather than just reading about:

A Declarative API demo (restaurant booking). Built around a small restaurant's reservation flow, this demo shows the annotated-form approach in its simplest form — a toolname and tooldescription attribute added to an existing HTML booking form, with no custom JavaScript required to make it agent-callable. If you're building your first Declarative tool, this is the clearest reference for what "minimal implementation" actually looks like in working code.

A travel booking demo (Imperative API, React). This demo covers the more complex end of WebMCP — a flight search-and-book flow with dependent steps (check availability, then confirm), built in React with registerTool(). It's the closest publicly available reference to the "multi-step workflow" pattern most real e-commerce and booking sites will need.

An interactive creation tool demo (Imperative API). A more open-ended example showing WebMCP applied to a tool with ongoing application state — useful if your use case is less "form submission" and more "an agent needs to read and modify something that already exists" (a document, a design, a configuration).

All three are referenced from Chrome's official WebMCP documentation, with source code available for inspection — the most reliable way to understand tool registration patterns before writing your own is to read code that's already known to work correctly against the current spec, rather than reconstructing it from written explanations alone.

The Model Context Tool Inspector

Separate from the demos themselves, Google publishes a companion Chrome extension for testing any WebMCP implementation — yours or someone else's. Install it, visit a site with registered tools (the demos above, or your own site once you've shipped something), and it will list every tool currently registered on that page, along with its full input schema. You can invoke any tool manually with a JSON editor, without needing an actual AI model in the loop — which makes it the fastest way to verify your own implementation is discoverable and correctly structured before testing against a real agent.

Early production adopters

Beyond the official demos, WebMCP is early enough that most production implementations are happening quietly, inside companies experimenting ahead of general availability rather than announcing it publicly. That's expected at this stage of any browser platform feature — mobile-responsive design and structured data both went through a similar quiet-adoption period before becoming standard practice. What follows is not an exhaustive account, and won't stay accurate for long precisely because adoption is accelerating; treat any specific company mentioned in WebMCP coverage elsewhere as a single data point, not a market signal, until adoption is broad enough to generalize from.

Why we're building a directory instead of a static list

A blog post listing "companies using WebMCP" goes stale within weeks in a space moving this fast — new implementations ship constantly, and a hand-maintained list can't keep up. That's the specific problem our directory is built to solve: instead of a fixed list frozen at publish time, it's a living index of sites that have submitted their own WebMCP and agent-readiness implementations, browsable by category (e-commerce, SaaS, developer tools, and more), so you can see real examples in your own vertical rather than a generic cross-industry sample.

Get your own implementation listed

If you've shipped a working WebMCP tool — whether it's a single Declarative form annotation or a full Imperative checkout flow — submit your site to the directory. Every submission is scanned for its Agent Readiness Score as part of the listing process, so what gets published isn't just a claim that you support WebMCP, it's a verified snapshot of what's actually implemented and discoverable on the page at the time of submission.

This matters for credibility on both sides: as a visitor browsing the directory, you're looking at implementations that have actually been checked, not just self-reported. As a site owner getting listed, your entry becomes a concrete, dated reference other builders in your category can point to — the same role the official Chrome demos play at the reference-implementation level, but for real production sites.

What to look for when studying someone else's implementation

• How narrowly scoped each tool is. Well-built implementations tend to favor several small, clearly named tools over one large, multi-purpose one.
• How descriptive the tool and parameter descriptions are. These are written for a language model to parse, not a human to skim — good implementations read almost like API documentation aimed at an LLM.
• Where confirmation steps sit. Sensitive actions (payment, account changes) should visibly pause for human confirmation rather than executing silently the moment an agent calls the tool.
• Whether the site still works completely without WebMCP. Every well-built implementation we've seen treats the tool layer as additive to a fully functional existing UI, not a replacement for it.

Check your own site against the same bar

Before submitting to the directory — or just to see where you stand independent of listing anywhere — run a free Agent Readiness scan to check your WebMCP tool registration, structured data, and semantic HTML against the same criteria used to evaluate every listed site.