Most "AI browses the web for you" demos are really just an agent clicking around like a very fast, very literal intern — screenshot, guess a coordinate, click, screenshot again. It works, but the agent never actually understands the page. It's pattern-matching pixels.
WebMCP is a different idea: what if the page itself told the agent what it could do?
The basic idea
MCP (Model Context Protocol) is the standard that lets an agent like Claude call external tools — a database query, a file read, a Slack post — through a well-defined schema instead of scraping text. WebMCP takes that same concept and puts it in the browser: a web page can publish a set of tools directly from its own JavaScript, and any MCP-capable agent visiting that page can read and call them.
Concretely, that means instead of an agent clicking a "+" button sixteen times because it thinks that's how you set a value to 16, the page can just expose a set_value(16) tool. The agent calls the function. No guessing, no brittle selectors, no accidentally double-clicking because a screenshot was a frame stale.
It's still early, but it's real: a Chrome extension can pick up a page's WebMCP tools today and hand them to MCP-capable agents. The page stays the single source of truth — you're not maintaining a separate API for humans and a separate one for agents, it's the same controls, exposed twice.
Trying it on BeatMCP
BeatMCP is a sixteen-step drum machine built specifically as a WebMCP demo, and I was curious how something like this actually gets built — so I figured the best way to understand it was to go use it, instead of just reading about it.
The page publishes tools like:
set_steps— write a 16-step pattern to a trackgenerate_bassline/generate_melody— compose in the current keysuggest_chord_progressionhumanize_track— vary timing and velocity so it doesn't sound roboticset_tempo_and_keysave_sound/load_sound/list_sounds— a little pattern bank
The intent is that you'd literally say "write a bassline in the current key" or "humanize the hi-hats a little," and the agent calls generate_bassline or humanize_track directly — real music-theory logic running on the page, not an agent hallucinating which grid square is a minor third away from the root.
Where I actually landed
Here's the part that made the concept click for me: I built a full beat on BeatMCP — kick, snare, hi-hats, bassline, lead — and it played back exactly as intended. But I hadn't touched a single WebMCP tool to do it. I'd done it through plain browser automation: reading the page's accessibility tree, finding button coordinates, clicking sixteen step-buttons per track by hand. That's the exact thing WebMCP exists to replace, not a version of it.
The reason is simple: the client I was driving the browser with doesn't have WebMCP support built in, so it could only see "a button" — never set_steps. That capability lives elsewhere, in the clients built to look for it — a browser extension paired with something like Claude Desktop, or an agent runtime like Codex wired up its own way. Picking the right client isn't a footnote here; it's the whole difference between calling a tool and clicking a pixel.
Why this distinction matters
Clicking through a UI scales badly: it breaks when a layout shifts, it can't reason about state it can't see (like why a bassline is in a certain key), and it burns a lot of steps doing something a single function call could do in one. A page that exposes real tools gives the agent:
- Semantics —
generate_basslinesays what it does; a button labeled with aref_93id says nothing. - State access —
get_pattern_statereturns the actual tempo, key, and armed steps, instead of an agent inferring them from pixel colors. - Composability — an agent can chain
generate_bassline→humanize_track→save_soundas one coherent action.
That's the pitch of WebMCP in one sentence: agents stop pretending to be users with a mouse, and start being programs that call your program.
If you want to feel the difference yourself, open BeatMCP, wire up an MCP-capable agent to it, and ask for a bassline in D minor. It'll be a little fiddly right now — that's what "experimental" means — but the payoff is worth seeing once, if only to imagine everything else on the web working the same way eventually.