You Are Reading This Blog. But It Wasn't Written for You.

What WebMCP actually means

Open any AI agent running in a browser today, give it a task like "check my IIM admission chances for my CAT score," and watch what happens. The agent opens the Rehearsal predictor page. It takes a full screenshot, 1.5 megabytes of pixels. It sends that image to a vision model with the instruction "find the percentile input field." The vision model returns `x: 420, y: 310, width: 180, height: 42`. The agent clicks those coordinates. Waits. Types. Clicks submit. Waits again for the page to paint. Takes another screenshot. Sends it to the vision model. Hopes the results table parsed cleanly.

Fifteen seconds, on a good day. Sometimes thirty. The vision model occasionally clicks the wrong button and the agent has to backtrack.

That is 2026's state of the art, and it is unmistakably a hack. The page the agent is scraping was designed for human eyes. The agent is pretending to be a pair of human eyes. Every click has non-zero probability of failure.

WebMCP says: stop pretending. The website registers its callable features directly with the browser. A tool called `predictCATAdmissionChances` with a typed JSON schema (seven fields in, a ranked list out) becomes available the moment the page loads. The agent calls it as a function. The response comes back in roughly two hundred milliseconds. No screenshots. No vision model. No coordinate-clicking. It is the same thing every backend API has been doing for twenty-five years, except it also works against the user-session, cookies, and live DOM state of the tab the agent is currently in.

That is the whole technique. The page advertises its runtime interface. Agents call the interface.

It sounds obvious once you read it. That is a sign of a good standard, not a trivial one.

Why it matters in practice

Most web pages built after 2010 are rendered client-side. The HTML that arrives from the server is a husk; the actual content and interactivity are painted by JavaScript running in the tab. Search crawlers handle this badly. AI agents handle it worse. An agent that scrapes the DOM of a React app before JavaScript runs gets almost nothing. An agent that waits for render and then scrapes gets something unpredictable, because the layout changes subtly between sessions.

The shift is from interpreting the page to calling the page. The page volunteers its functions. The agent invokes them. The layout no longer matters.

Two short examples make this concrete. The GitHub PR-review workflow is a natural WebMCP surface: an agent could register tools like `summariseChangedFiles()` and `runTestForCommit()` and act on the user's current session without any pixel-clicking. The Stripe dashboard, where an agent might preview a payout or reconcile a subscription, could expose `listPayouts()` and `refundCharge()` as typed calls. Both of those interactions currently take twenty to forty seconds per step under the DOM-scraping regime. WebMCP collapses them into milliseconds, because they are already functions behind the UI; they just aren't advertised.

One warning. WebMCP is not a backend API. It runs in the tab, with the user's session, cookies, and permissions. If the user is logged in, the agent acts as the user. This is a feature when the user is watching; it is a foot-gun when the agent operates autonomously. The current spec pushes hard on human-in-the-loop consent prompts for sensitive actions. Respect that.

Now, the interesting bit.

The agent-invocable web is 80 years older than you think

February 2026, Chrome, Google, W3C. That is how WebMCP reached the developer world. It is not how the idea reached the world.

The earliest clear version is Vannevar Bush's essay "As We May Think", published in The Atlantic in July 1945, two months after the end of the Second World War. Bush, who had just directed the American wartime science effort, described a desk-sized machine he called the memex. A person could retrieve records on demand, link them together by association, and build what he called "trails" through knowledge. The machine did not scrape books. It called functions. An operator queried the machine, and the machine returned structured data.

The details were of their time: Bush imagined microfilm reels, electromechanical controls, and a "piece of furniture" in one's study. But the interface model, typed requests producing structured responses for an agent operating on the user's behalf, is the one WebMCP ships eighty-one years later.

The second lineage node is the Semantic Web. In May 2001, Tim Berners-Lee, James Hendler, and Ora Lassila published "The Semantic Web" in Scientific American. The opening example is eerily similar to the Rehearsal one. A user asks their software agent to schedule physical therapy for their mother. The agent queries structured data on the doctor's site, the insurance site, and the therapist's calendar, and returns a confirmed appointment. Published almost exactly twenty-five years before WebMCP, the essay sketches the same model: software agents invoking structured functions on behalf of the user, composing across sites.

The third lineage node is the attempt to make the Semantic Web deployable. In 2011, Google, Microsoft's Bing, and Yahoo jointly launched Schema.org, a shared vocabulary of structured metadata publishers could embed in their HTML. Ten years later, Schema.org markup is in something like forty percent of indexed pages. It made search richer. It did not make the web agent-invocable. Metadata that describes a page is not the same as a function a page offers.

What the three lineage nodes share: structured data, machine access, typed retrieval. What they share in failure: every one of them was opt-in. Publishers were asked to add the metadata; agents were asked to respect it. When adding structure is a polite request, most publishers do not bother, and most agents stop relying on it.

WebMCP's move is to stop requesting structure as metadata and require it as runtime code instead. A tool either registers via `navigator.modelContext` or it does not. If the site wants to offer an agent-invocable feature, it writes the JavaScript. If it does not, the agent falls back to vision-and-pixels. The structured interface is no longer a declarative footnote in the page header; it is an executable function in the runtime. That is what eighty years of predecessors got wrong, and what the W3C Web Machine Learning community group got right in February 2026.

Why the history is interesting

The point is not that Bush invented WebMCP, or that WebMCP owes the Semantic Web a royalty. The point is that good standards almost never arrive as novel theory. They arrive as re-expressions of old theory, packaged for a new audience by an industry that has just hit the wall the predecessor warned about.

Three practical implications follow.

First, if you want to predict which emerging standards will stick, look at which ones remove optionality. The Semantic Web lost because adding RDF was nobody's Monday-morning priority. HTTPS won because Chrome shamed HTTP pages into compliance. GraphQL is winning because Apollo made typed schemas cheaper to ship than untyped REST. WebMCP's registration step is cheap, about fifty lines of JavaScript per tool, which is why it has a chance where OWL ontologies never did.

Second, a useful test when you see a new machine-readable web standard: who wrote the reference implementation, and is it in every browser by default? Schema.org had Google, but Google already ran the search. WebMCP has Chrome and Edge. The registration API is behind a flag for now but will likely unflag within six months. That combination, a standard plus a runtime default, is what moved HTTPS from curiosity to default between 2014 and 2020. Expect the same arc here.

Third, and this is where it gets personal. I spent a Tuesday evening testing the Rehearsal CAT predictor via the Chrome 146 Canary WebMCP Test Agent. I asked, in plain English: "predict my IIM chances for a 96 percentile general category candidate with twenty-four months of work experience and a B.Tech background." Three hundred milliseconds later, the agent handed me seventy-seven ranked colleges, correctly filtered for my profile. No screenshots, no misclicks, no timeouts. The thing that struck me was not the speed. It was that the agent did not need a demo. It found the tool on the site, read the JSON schema, called the function, and relayed the result. That is the interaction Bush was drawing on the Atlantic's illustration board in 1945.

If you want the single compression of this essay, take this: the Semantic Web was a request to publishers to behave. WebMCP is an instruction to browsers to require the behaviour. Eighty years of hopeful standards became one enforceable one the moment the browser decided to ship the interface itself.

One last thing

Frameworks travel. Making a website agent-invocable is a ninety-minute job; making sure your content is worth invoking is the longer one. Rehearsal's Business 101 briefs sharpen that second muscle, fifteen minutes at a time.