WebMCP is Google's new protocol that lets AI agents interact with websites through structured tools instead of screen-scraping. It's in Chrome 146 now.
Scan any site. Generate agent-ready tool definitions. Test against Gemini, GPT-4, and Claude. From install to first audit in minutes.
No signup required. No API key. Just install and scan.
As of today, websites can tell AI agents exactly what they can do — and how to do it. Google's WebMCP protocol (Chrome 146, backed by Microsoft) lets any site expose structured tools that agents discover, understand, and invoke directly.
Instead of brittle screen-scraping, an agent calls your site's search_flights tool with typed parameters and gets structured results back. The site publishes a contract. The agent follows it.
This is the biggest shift in web architecture since REST APIs.
A proposed web standard for agent-website interaction. Ships in Chrome 146 behind a flag. Backed by Google and Microsoft.
Two APIs: Imperative (JavaScript registerTool() with JSON Schema) and Declarative (HTML form attributes: toolname, tooldescription).
Every website with forms becomes an agent-callable service endpoint. Tool descriptions become the new SEO.
// Agent guesses at form fields"code-keyword">await page.fill('#departure', 'London');"code-keyword">await page.fill('#arrival', 'New York');"code-keyword">await page.click('.search-btn');// Breaks when UI changes.// No structured output.// Website declares its capabilitiesnavigator.modelContext.registerTool({ name: "search_flights", description: "Search flights between airports", inputSchema: { "code-type">type: "">object", properties: { origin: { "code-type">type: "">string" }, destination: { "code-type">type: "">string" }, }, }, execute: "code-keyword">async ({origin, dest}) => { "code-keyword">return api.search(origin, dest); }});// Agent discovers, sends typed params,// gets structured response. Reliable.No signup. No API key. No credit card. Just npm install and go.
Full scoring across 5 dimensions — in under 5 seconds.
Note: This audit ran against Google's official WebMCP travel demo. Try it yourself — or point it at any URL. The CLI detects both imperative tools (registerTool()) and declarative tools (<form toolname="...">), analyzes schema quality against the spec's best practices, and checks for security vulnerabilities documented in the WebMCP Security & Privacy Considerations spec.
Writing registerTool() is easy. Knowing if agents will actually USE your tools correctly — across Gemini, GPT-4, and Claude — is the hard part.
From Existing Site to Agent-Ready in 60 Seconds
Your client's site already has forms — search, contact, booking, checkout. Each one COULD be a WebMCP tool. The Form Scanner detects them all, generates spec-compliant tool definitions, and exports production code for your framework.
~6–8 hours per site (reading each form, writing JSON Schema by hand, mapping input types, writing execute functions)
~30 minutes (scan, review generated definitions, customize, export)
Will Agents Actually Use Your Tools?
You wrote a beautiful tool definition with a perfect JSON Schema. But when a real user tells their AI agent "find me a cheap flight to NYC next week," does the agent select YOUR tool? Does it fill the parameters correctly? Prompt coverage testing answers these questions — across multiple AI models — before your tools hit production.
Essentially impossible at scale. 150 prompts × 3 models × 3 tools = 1,350 individual tests. Building the test infra alone would take weeks.
One command. 3 minutes. $2.40.
Point It at a URL. Get a Complete Implementation Plan.
The AI Co-Pilot is not a chatbot. It's an implementation engine. Give it a URL, and it crawls the site, identifies every form, generates complete WebMCP tool definitions, runs linting and security analysis, produces a prioritized roadmap, and generates production code for your target framework.
A full WebMCP assessment: identifying all forms and interactive elements, writing tool definitions, generating code, and producing an implementation guide.
One command. Review the output, customize, and ship.
Never Ship Broken Tools
Your team ships 5 times a day. Someone changes a tool description. Another dev renames a parameter. Without automated quality gates, you discover the breakage when agents stop using your tools — and you have no idea why.
"code-comment"># .github/workflows/webmcp.yml"code-property">name: Agent Readiness Check"code-property">on: [pull_request] "code-property">jobs: "code-property">agent-ready: "code-property">runs-on: ubuntu-latest "code-property">steps: - uses: actions/checkout@v4 - name: Agent Readiness Gate "code-property">run: | npx webmcp-cli ci \ --min-score 75 \ --fail-on-security-critical \ --model gemini-flash \ --budget-cap 5.00Manual regression testing of every tool definition on every PR. Realistically: nobody does it, tools break silently.
Automated gate on every PR. Blocks merge on score drops and security issues. ~30s per run.
Free, Instant, No API Key
Before you spend money on LLM-based testing, catch the obvious mistakes for free. The linter checks your tool definitions against every best practice in the WebMCP spec — in under 1 second, entirely offline.
Manually reading the WebMCP spec and cross-referencing every tool definition against every best practice. ~1 hour per tool.
One command. 0.3 seconds. Actionable fix suggestions included.
Google built the inspector. We built the optimizer.
Works on sites with and without WebMCP
| Feature | WebMCP | |
|---|---|---|
| List registered tools | ||
| Score tools against best practices | ||
| Lint schema against WebMCP spec | ||
| Manual tool execution | ||
| Quick prompt test | ||
| Multi-model agent testing | ||
| Works on sites WITHOUT WebMCP | ||
| Suggest tool annotations for plain forms | ||
| Export definitions to project |
Two common implementation paths. The CLI is free, the spec is open, and you can validate everything yourself.
From zero to agent-ready in a single session
Understanding where you stand vs. alternatives
Built on an open standard. Verify everything yourself.
Static analysis costs us nothing — so it costs you nothing. AI-powered features use LLM APIs and are metered.
Forever. No credit card.
For freelancers and indie devs
For teams shipping WebMCP at scale
Need Team ($249/mo) or Enterprise (custom)? See Team and Enterprise tiers
For when the CLI isn't enough. Bulk scan client portfolios. Integrate into your internal tools. Build custom workflows.
Individual site work, CI/CD, quick audits, development workflow
Bulk operations, custom integrations, agency portfolio management, automated reporting
SDK available on Solo plan ($29/mo) and above. Read the SDK reference
A typical client engagement workflow. Discovery through delivery.
WebMCP is a proposed web standard from Google (co-authored with Microsoft) that lets websites expose structured tools for AI agents. Instead of agents scraping your UI, they discover and invoke tools you've explicitly declared — with typed parameters, JSON Schema validation, and structured responses. It's available behind a flag in Chrome 146 as of February 9, 2026. Think of it as "APIs for AI agents, built into the browser."
Honest answer: It's early. Chrome 146, behind a flag, early preview. But three signals suggest this is real: (1) Microsoft is co-authoring — when competitors collaborate on a standard, the market is real, (2) it's already shipping in Chrome with working demos, not just a whitepaper, (3) the problem it solves (agents interacting with websites) is inevitable regardless of which specific protocol wins. WebMCP is built on the trend (agent-website interaction needs tooling), not just the protocol. If WebMCP evolves, our tooling evolves with it.
MCP is server-side — developers deploy tools on their own servers that AI agents connect to via JSON-RPC. WebMCP is client-side — tools live in the browser, declared via JavaScript or HTML attributes, and interact with the page DOM. MCP requires running a server. WebMCP works on any existing website by adding attributes to HTML forms or calling navigator.modelContext.registerTool(). They're complementary, not competing.
Writing registerTool() is easy. That's not what we sell. We sell: (a) prompt coverage testing across 3+ AI models (1,350 test combinations per tool set), (b) auto-generated tool definitions from existing forms (the Form Scanner detects forms, infers schemas, handles edge cases), (c) linting against every best practice in the WebMCP spec, (d) CI/CD quality gates that block deploys if agent readiness drops, (e) the AI Co-Pilot that produces a complete implementation in 5 minutes. You could build any ONE of these. You can't build all of them in an afternoon.
No. npm install -g @webmcp/cli works immediately. Basic scanning (audit, lint, scan) runs without an account. Signup required for: prompt coverage testing (uses LLM APIs), AI generation, AI Co-Pilot, and analytics. Free account gets you started with limited usage.
React, Next.js, Vue, Nuxt, Svelte, SvelteKit, WordPress (PHP), Shopify (Liquid), vanilla JavaScript/TypeScript. Each export includes: registerTool() definitions, provideContext() state management for SPAs, TypeScript interfaces, and feature detection guards (if ("modelContext" in navigator)). More frameworks coming — request yours on GitHub.
The CLI runs entirely locally for static analysis (lint, audit Quick Score, scan). AI features (prompt testing, generation, co-pilot) require our API because they proxy LLM calls at bulk pricing. Enterprise plan includes on-premise deployment options.
Source-available on GitHub. Core scanning and linting logic is open. AI/testing features use our API. We believe the linting rules and scanning heuristics should be a public good — the AI-powered features are how we sustain the business.
OpenAPI describes server-side REST APIs. WebMCP describes client-side browser tools. They operate at different layers. An OpenAPI spec tells an agent how to call your backend. A WebMCP tool tells the browser's built-in agent how to interact with your page — including filling forms, navigating UI state, and getting user confirmation for sensitive actions. You might have both: OpenAPI for your API, WebMCP for your website.
Other tools focus on WebMCP implementation (React hooks, framework bindings). We focus on what happens AFTER implementation: Does the agent actually pick your tool? Does it fill parameters correctly across Gemini, GPT-4, and Claude? How do you score vs. competitors? Where are the security vulnerabilities? Implementation is step 1. Testing, optimization, and monitoring are steps 2–100. That's where we live.
1 deep scan/day, 3 AI generations/month, unlimited Quick Scores, unlimited linting. No scan limit = you can lint and audit as much as you want for free, forever. The limits are only on features that cost us LLM compute.
The protocol launched two weeks ago. The tooling is ready. Teams shipping early will build durable implementation experience while the ecosystem is still taking shape.
$ webmcp-cli audit https://your-site.com
$ webmcp-cli --help
Not ready to install? Subscribe to WebMCP Weekly — protocol updates, tooling news, tutorials.