WebMCP Chrome Extensions: All 7 Compared (2026 Guide)

Seven different WebMCP extensions live in the Chrome Web Store right now, and most posts treat them as interchangeable. They are not. This guide breaks down what each one does, who built it, and the exact workflow for using them together.

Search for "webmcp extension" today and you'll get a wall of Chrome Web Store results with nearly identical names. Seven different WebMCP extensions are live in the Chrome Web Store right now, across three loose categories of purpose — and almost no published explainer tells you which one to actually install. This guide fixes that.

I've tested each WebMCP extension and read through every public repo behind them. Below: what each one does, who built it, and the exact order to install them depending on whether you're building a WebMCP-enabled site, debugging one, or just using the protocol from your AI agent of choice.

TL;DR — which extension do you need?

• Building or debugging a WebMCP-enabled site? Install the official Model Context Tool Inspector from Google's Chrome team.
• Need richer test workflows with Gemini/Claude/OpenAI built in? Install the community-built WebMCP Inspector (Shitij Agrawal — 5.0 stars).
• Want WebMCP to work on sites that haven't implemented it? Install WebMCP Hub for community-contributed configs.
• Want to use WebMCP tools from Claude Desktop / a non-browser agent? Install a browser-to-MCP-server bridge extension.
• Don't have Chrome Canary 146+? Install the polyfill via npm or use the Chrome Labs polyfill extension.

Why so many WebMCP extensions exist (and why nobody has explained this)

WebMCP is brand new. The native API only landed in Chrome 146 Canary in February 2026 and graduated to a Chrome 149 Origin Trial in early Q2. That meant three groups all needed tooling — and each shipped their own WebMCP extension — simultaneously:

1. Google's own team needed a debugger to validate the spec implementation as it shipped.
2. Independent developers needed inspectors that worked across the polyfill and native runtime.
3. Agent users (people who run Claude Desktop, ChatGPT Atlas, etc.) needed a way to expose their browser sessions to non-browser agents.

Different problems → different extensions. The good news: they don't conflict. You'll usually install 2–3 of them and that's fine.

The 7 WebMCP Chrome extensions, compared at a glance

1. Model Context Tool Inspector (the official-ish one)

Built by: François Beaufort, a Google Chrome Developer Advocate. The source lives at github.com/beaufortfrancois/model-context-tool-inspector. Note: Google's repository disclaimer says this is "not an officially supported Google product," but it's built and maintained by someone on the Chrome team and tracks the spec closely.

What it does: Inspects any open tab and shows you which WebMCP tools are registered on the page (via either the Declarative or Imperative API). Displays each tool's input schema, lets you execute tools manually by filling in a JSON form, and shows the response.

When to install: This is your default debugger if you're building a WebMCP-enabled site. It's the closest thing to a "ground truth" inspector — if a tool shows up here, it's correctly registered per spec.

Heads up on the naming: The Chrome Web Store listing is "WebMCP - Model Context Tool Inspector" (extension ID gbpdfapgefenggkahomfgkhfehlcenpd). Don't confuse it with the community-built "WebMCP Inspector" (next entry) — they're different extensions.

2. WebMCP Inspector (the community-built tester)

Built by: Shitij Agrawal. The best-rated community Inspector at the time of writing (5-star reviews, actively maintained — version 3.0.0 landed in February 2026). Listing ID edfjnadfiapmddgplgnphlflgafmcino.

What it does: Everything the official Inspector does, plus built-in chat integration with Gemini, OpenAI, Anthropic Claude, and Ollama. You can prompt the agent in natural language and watch it pick a tool, fill in arguments, and execute — all without leaving the page.

When to install: When you're past the "is my tool registered?" phase and into "will an agent actually use it correctly?" Manual JSON inputs in the official Inspector are great for unit-testing schemas; AI-driven testing in this one is how you catch real-world failures (vague descriptions, ambiguous parameter names, schemas that look fine but confuse the model).

Heads-up on permissions: Because of the AI integrations, this extension requests access to authentication information, personal communications, and website content. Review the permissions before installing on a profile with sensitive logged-in sessions.

3. WebMCP DevTools

Built by: Community contributor. Extension ID cgfogfkcfjdgpekdndcihajfjkaekjcl.

What it does: A lighter-weight inspector focused purely on visibility — registered tools, schemas, registration timing. No AI test harness, no execution UI by default.

When to install: Optional. If the two Inspectors above feel heavyweight and you just want a Chrome DevTools-style "what's registered right now?" panel, this is the minimalist option. Most teams will not need it alongside the others.

4. WebMCP Hub (the tool registry)

Built by: Joakim Selemyr. A newer extension in early-stage release (version 1.0.0). Listing ID ahblgfajboifhioeldnefolijmllkaaj.

What it does: This is a different category of extension. Instead of inspecting sites that have WebMCP, it adds WebMCP tools to sites that don't. The extension checks the current domain against a community-maintained "Hub" registry and, if there's a matching config, injects tool registrations into the page. Configs can describe form-completion tools, navigation tools, and information-retrieval tools.

When to install: If you're a power user who wants AI agents to interact with sites that haven't yet implemented WebMCP — and you don't mind that the tools are community-defined, not authored by the site owners. It's the fastest way to make the AI-agent web feel "real" today, before mass adoption.

One caveat: Trust model matters here. A community config could declare a misleading tool description that tricks the agent into the wrong action. Inspect configs before enabling them on financial or destructive sites.

5. WebMCP (Chrome Labs polyfill bridge)

Built by: Google Chrome Labs. Extension ID angbjhnglmgbaoknfnifedallkocldah. Same source family as GoogleChromeLabs/webmcp-tools.

What it does: Installs navigator.modelContext globally so sites that opt into the polyfill can be tested on Chrome Stable, Edge, Firefox, and other browsers without waiting for native implementation. Acts as a bridge — sites talk to navigator.modelContext, the extension translates those calls into a runtime the browser can execute.

When to install: If you don't run Chrome 146 Canary or aren't enrolled in the Chrome 149 Origin Trial, this extension is the fastest way to experience WebMCP without changing browsers. It also lets you test that your @mcp-b/global polyfill integration behaves correctly (see our polyfill tutorial).

6. WebMCP Extension (alternate polyfill bridge)

Built by: Community. Extension ID jigokfbbpcdckjmhbgapmikncfihboec.

What it does: Similar to the Chrome Labs polyfill — exposes navigator.modelContext on non-Canary browsers. Some workflow differences in how it surfaces tool registration to the user.

When to install: Probably don't. Unless you have a specific compatibility issue with the official Chrome Labs version, stick with the Chrome Labs polyfill. Avoid having two polyfill extensions enabled simultaneously — they will collide on navigator.modelContext.

7. Web MCP: Browser MCP Service (the agent-side bridge)

Built by: Community. Extension ID acdlpjcmkabbmhpibedepbfdankiagoc.

What it does: This is a completely different category from the others. It exposes your browser session as a local MCP server (typically on localhost:8080), which non-browser AI agents like Claude Desktop, ChatGPT Atlas, or any MCP-compatible client can connect to. The agent then gets to "see" the web through your logged-in browser — your cookies, your sessions, your extensions.

When to install: If you want your desktop AI agent (Claude Desktop, for example) to be able to perform tasks in your authenticated browser session. It's the answer to "how do I let Claude book my flight on my actual airline account?" without sandbox automation.

Privacy note: The extension keeps all communication on localhost — nothing leaves your machine. Password fields are masked by default. But you're still effectively giving a desktop agent the keys to your browser, so be deliberate about which agent you connect.

How to use them together: a 3-stage workflow

You don't pick one extension and stop. The realistic developer workflow uses 2–3 of them at different stages.

Stage 1 — Local development

• Official Model Context Tool Inspector open in a DevTools panel
• Native Chrome 146+ Canary OR Chrome Stable + Chrome Labs polyfill extension
• Your site running on localhost with WebMCP tools registered via registerTool()

Confirm every tool you intended to register actually shows up in the Inspector, with the correct input schema. If it's not in the Inspector, the agent can't see it.

Stage 2 — AI-driven validation

• Community WebMCP Inspector (the one with Gemini/Claude/OpenAI baked in)
• Same site, same tools registered

Prompt the integrated agent with realistic user requests ("Search for size 10 black running shoes under $150" or "Save a draft of this email"). Watch which tools the agent picks. If it picks the wrong one, your description is ambiguous — fix it and retest. This is where 80% of real-world WebMCP bugs hide.

Stage 3 — Cross-agent compatibility

• Web MCP: Browser MCP Service connecting your browser to Claude Desktop or another non-browser agent
• Run the same realistic user requests from inside that agent's chat UI

Confirms that your tool definitions are clear enough to be picked correctly by agents that don't share Gemini's training data. If a tool works in Inspector-Gemini but fails in Claude Desktop, the description is still too implicit.

Common mistakes I see developers make

• Installing the community Inspector and assuming it's the official one. They're both legit, but the official one tracks the spec more conservatively. When the spec shifts (like the March 2026 provideContext() removal — see our API reference), the official Inspector updates first.
• Enabling two polyfill extensions at once. The Chrome Labs polyfill and the community polyfill will both try to define navigator.modelContext. Pick one.
• Trusting WebMCP Hub configs on banking or e-commerce sites. Community configs are not vetted. Inspect before enabling on anything that handles money or credentials.
• Testing only against the polyfill. Native Chrome 146+ behaves slightly differently in edge cases (event timing, permission prompts). Always validate on native before shipping.
• Forgetting that the Inspector reveals the agent's view. If your tool description reads "Save draft" but the page context is unclear, the Inspector will show exactly what an agent sees — and it's often less than you think.

What's coming next

Three things to watch in the WebMCP extension space over the next 6 months:

1. Chrome DevTools integration. The current Inspector ships as a separate extension because Chrome DevTools doesn't yet have a built-in WebMCP panel. That changes when WebMCP graduates to stable — likely Q3 2026. At that point the Inspector extension becomes redundant for native testing.
2. Edge and Firefox-specific extensions. Microsoft Edge 147 shipped native WebMCP support in March 2026. Firefox is 8–12 weeks from stable per Mozilla's Bugzilla tracking. Expect at least one Edge-specific Inspector to appear; Firefox WebExtension equivalents will follow.
3. Hub registries proliferating. WebMCP Hub is the first community config registry but won't be the last. Expect commercial and niche registries (one for SaaS dashboards, one for travel, one for e-commerce) as adoption grows.

The bottom line on picking the right WebMCP extension

Right now, the minimum useful setup for serious WebMCP development is two extensions: the official Model Context Tool Inspector for spec-accurate debugging, and the community WebMCP Inspector for AI-driven validation. Add the Chrome Labs polyfill bridge if you're not on Canary. Add Web MCP: Browser MCP Service if you want desktop-agent integration. Skip the rest of the WebMCP extension catalogue unless you have a specific reason.

If you're building WebMCP from scratch, start with the complete implementation guide first, then come back here once you have tools registered. If you want a human in the loop for the implementation work itself, our services page covers the engagement options.

Frequently Asked Questions