A post about something called WebMCP hit the Hacker News front page yesterday, landing 22 points and 19 comments. The source turned out to be a personal blog by Sreenath Menon, an Indian full-stack developer—not anyone from W3C or Anthropic.
Bottom line: the concept is interesting, but it's far from usable. Here's the breakdown.
What Problem WebMCP Is Trying to Solve
When an AI Agent needs to interact with a website today, there are basically two approaches:
- Screenshot + vision model: Capture the screen, feed it to GPT-5 or Claude, identify buttons, and click. High latency, high cost, brittle on dynamic pages.
- DOM parsing: Read the HTML, find selectors, simulate clicks. Rigid—a single CSS change breaks everything.
WebMCP proposes a third path: let websites declare what they can do. It's similar to the tool-calling mechanism in MCP, but moved into the browser. The site exposes a structured set of methods, and the Agent calls them directly without guessing.
A hypothetical scenario (the original post doesn't include full code):
// WebMCP interface declared by the website developer
window.webmcp = {
tools: {
addToCart: {
description: "Add a product to the shopping cart",
parameters: {
sku: { type: "string", required: true },
quantity: { type: "number", default: 1 }
},
handler: async ({ sku, quantity }) => {
return await api.addItem(sku, quantity);
}
}
}
};
When an Agent arrives and asks "what tools do you have?", the site returns the addToCart schema. The Agent calls based on the schema—no HTML parsing required.
The idea isn't new. RSS, OpenAPI, and microformats all attempted something similar. But framing it for the browser in the context of AI Agents is a 2025 take, following the rise of MCP.
Source and Author Background
The original post lives at sreenathmenon.com. The author is a full-stack engineer based in India who has previously written about React performance.
This context matters: this isn't a standards-body effort or a major company proposal—it's a concept post by one person. It represents an idea, not industry direction.
HN Reception: Is 22 Points a Lot?
A front-page showing at 22 points and 19 comments lands in the "picked up but not viral" range. Viral typically means 100+ points and 200+ comments.
Here are the questions developers raised in the comments, cleaned up:
- How does this relate to existing MCP? Nobody could answer this clearly. The original author doesn't draw a distinction.
- Is there a demo? No. Just a snippet of pseudocode.
- Performance impact? Adding a
window.webmcpobject is negligible for first paint, but maintenance cost is a different story. - Accessibility (a11y) compatibility? Nobody asked, but I think it's the most critical question—sites with good a11y are already structured. Would WebMCP be redundant or complementary?
- What about Chrome's Prompt API? Someone mentioned it briefly; nobody followed up.
22 points means: the concept resonated with some people, but it hasn't built consensus.
WebMCP vs. Anthropic's MCP
This needs clarity because the names sound similar.
MCP (Model Context Protocol) is a protocol Anthropic introduced in late 2024. By 2025–2026, it's been widely adopted by Claude Desktop, Cursor, and Continue.dev. It addresses: how local AI applications call external tools—like letting Claude query GitHub, hit a database, or read local files.
A running MCP server looks like this (simplified):
from mcp.server import Server
import mcp.types as types
server = Server("weather")
@server.list_tools()
async def list_tools() -> list[types.Tool]:
return [
types.Tool(
name="get_forecast",
description="Get weather forecast for a location",
inputSchema={
"type": "object",
"properties": {
"latitude": {"type": "number"},
"longitude": {"type": "number"},
},
"required": ["latitude", "longitude"],
},
)
]
If WebMCP existed, it would be a web-layer extension of MCP—moving MCP tools from local processes into the browser, letting websites declare callable capabilities.
But as things stand:
- W3C has no proposal.
- IETF has no proposal.
- Anthropic has not acknowledged it.
- Chrome has not built it in.
It's a blog concept, not a standard.
Why I'm Skeptical
Counter-take incoming.
Why would sites re-architect for AI Agents? Two realities work against it:
- Agent traffic isn't large enough to justify architectural changes yet. For most sites, SEO traffic dwarfs Agent traffic. Rewriting structure for crawlers was a '90s thing. Nobody cared about crawlers anymore—until ChatGPT pulled traffic away from search engines.
- Current solutions are good enough. Screenshot + vision is slow but universal; DOM parsing is fragile but functional. Shopify and Cloudflare aren't going to overhaul their infrastructure for a blog concept.
Unless there's a strong ecosystem push—Chrome shipping it natively, Cloudflare enabling it by default, Shopify supporting it across stores—one blog post won't move the needle.
Similar attempts over the past 20 years:
- Microformats (2005)
- Schema.org (2011, Google-backed, succeeded)
- oEmbed (2008)
- ActivityPub/Mastodon (2018, niche)
Success has never been about protocol elegance—it's about distribution. WebMCP has no distribution channel right now.
Another concern: security. If a site declares a deleteAllData tool, what stops an Agent from calling it indiscriminately? In local MCP scenarios, the user has authorized each call. When browsing the web, who has authorized the Agent? The original post doesn't address this.
Editor's Take
WebMCP is worth knowing about, but not worth implementing right now.
It touches a real problem: the interface between AI Agents and websites is a mess—vision models are slow, DOM parsing is brittle, and a native channel is genuinely missing. But a missing channel doesn't guarantee one will exist.
Over the past 20 years, attempts to make websites "self-declare" have only succeeded once: Schema.org. It worked because Google Search was the distribution channel. Without distribution, everything else stayed at the blog-post stage.
The potential difference this time: AI Agents could become a new distribution channel. If OpenAI, Anthropic, or Google's Agents become major traffic gateways, sites will have incentive to declare interfaces for them—much like SEO optimization in the search era.
But that "if" is doing a lot of work. I'm not confident that by 2026, Agent traffic will be large enough to push Shopify to re-architect. The more likely outcome is that Agents themselves evolve better vision and planning capabilities, sidestepping the problem entirely.
My position: watch and wait for Chrome or Cloudflare to make a move. Adding window.webmcp to production code today is probably wasted effort.
References: