webmcp: the end of the surface web

chrome 146 contains an api that almost nobody has noticed yet. it will be the beginning of a fundamental change of the internet.

"show me my most expensive subscriptions."

no screen, no browser, no scrolling through a list. your ai agent opens snout.pink, calls list_subscriptions, gets structured json back and says: "your disability insurance costs 145 euros a month. want to cancel or compare?"

this is not a vision for 2030. it works today, in chrome 146 canary, behind a feature flag. i built it and tested it.

the technology is called WebMCP, and it is the beginning of the end of the internet as we know it.

what webmcp is: websites learn to speak

today, ai agents interact with websites the way a human does: they take screenshots, parse the dom, search for buttons and click their way through forms. this is roughly as efficient as running a restaurant where you can only serve customers by photographing the menu and deciphering each letter individually.

WebMCP flips this around. a website can now tell the browser what it can do: not as free text, but as a structured tool declaration with a name, description and parameter schema.

technically, it comes down to a single call:

navigator.modelContext.registerTool({
  name: 'search_hotels',
  description: 'search available hotels for a date range',
  inputSchema: {
    type: 'object',
    properties: {
      city:     { type: 'string' },
      checkin:  { type: 'string', format: 'date' },
      checkout: { type: 'string', format: 'date' },
      guests:   { type: 'number' }
    },
    required: ['city', 'checkin', 'checkout']
  },
  execute: async (input) => {
    const results = await searchHotels(input);
    return { content: [{ type: 'text', text: JSON.stringify(results) }] };
  }
});

the website registers a function, the agent calls it. a clean function call with typed input and structured output, instead of fragile screen-scraping and pixel-guessing.

the W3C draft [1] was published on february 10, 2026, jointly developed by google and microsoft. chrome 146 canary has had the api since february behind the "WebMCP for testing" flag, with the stable version expected for march 2026 [2].

real-world example: an afternoon project

i added WebMCP to snout.pink, my subscription tracker [3]. six tools: list subscriptions, add, update, delete, get a spending summary, export data. the entire service is an angular injectable with 456 lines, written in an afternoon.

the core looks like this (source):

@Injectable({ providedIn: 'root' })
export class WebMcpService {
  init(): void {
    if (!navigator.modelContext) return;

    navigator.modelContext.registerTool({
      name: 'list_subscriptions',
      description: 'list all subscriptions with price and billing cycle',
      annotations: { readOnlyHint: true },
      execute: async () => {
        const subs = this.subscriptionService.subscriptions();
        return { content: [{ type: 'text', text: this.format(subs) }] };
      }
    });

    // + add, update, delete, summary, export
    console.log('[WebMCP] 6 tools registered');
  }
}

in chrome canary with the flag enabled, the console shows: [WebMCP] 6 tools registered. the tools are there. an agent that connects via the chrome devtools protocol [4] can discover and invoke them immediately, without ever seeing the ui.

your morning in two years

imagine your ai agent wakes you up, not with an alarm, but with a summary.

overnight it queried your news sources, not by scraping spiegel.de, but via structured tool calls. it knows your favorite youtube channel published a new episode, has summarized the content and added it to your list for today. it says: "by the way, your colleague posted a thread on x that's relevant to your project. here's the key takeaway."

that hotel room for next week? booked last night. not through a website with cookie banners, "only 2 rooms left!" warnings and sponsored listings, but via search_hotels → check_availability → book_room: three function calls, structured, comparable, no dark patterns.

the pwa of your favorite news outlet exposes its articles as WebMCP tools: get_latest_articles, search_by_topic, get_article_summary. your agent calls them, filters by relevance, summarizes. you never see a homepage, never see an ad, never see a clickbait headline.

this sounds like science fiction. technically it's a W3C draft from three weeks ago and a feature flag in chrome.

WebMCP is the new seo

2005: if you weren't discoverable on google, you didn't exist. companies built entire departments to optimize their websites for search engine crawlers. those who ignored it lost traffic, slowly at first, then suddenly.

2028: if you don't expose WebMCP tools, you're invisible to ai agents.

the parallel is almost one to one. seo optimized websites for search engine crawlers, WebMCP optimizes websites for ai agents. but it goes further than seo, because it's not just about discoverability, it's about usability. a website without WebMCP tools is like a restaurant without a menu for an agent: you can walk in and look around, but you can't order efficiently.

think this one step further: you install a pwa on your phone. until now, that was an app with a surface that you operate. with WebMCP it's something fundamentally different. your agent automatically detects the interfaces the app exposes and integrates them into its repertoire. you're no longer installing an app, you're giving your ai a new capability.

your podcast player registers get_new_episodes, your task manager registers create_task, your calendar registers check_availability. the apps on your device become a network of functions that your agent orchestrates. the app icons on your home screen become what bookmarks in the browser already are today: relics of an era when humans were the primary interface.

just like with seo, directories will emerge. ai providers will maintain registries listing which domains offer which tools. the next step is .well-known/webmcp manifests: machine-readable declarations, accessible before the page is even opened. the infrastructure for discovery will come, because the incentives are aligned: every ai provider wants to give their agent access to as many tools as possible.

the surface dissolves

what happens when the primary interaction no longer goes through the website?

when your agent books your hotel room, nobody sees the sponsored listings on booking.com. when it compiles your news, nobody sees banner ads. when it manages your subscriptions, nobody needs the saas ui anymore. the ad-funded internet isn't losing its users: it's losing its surface. without a surface, there's nothing to place ads on.

social media is already in this crisis. feeds are flooded with ai-generated content, the sentiment is negative, and the honest answer to "what did you do on instagram for the last two hours?" is usually shame. if an agent curates the relevant content for you, filtered, no clickbait, no infinite scroll, no algorithm monetizing your attention: why would you still open a feed?

instead: "your friend posted something you might find interesting. here's the summary." or: "there's a new episode of hard fork, it's about WebMCP and the future of browser agents. i've added it to your list for tonight."

the interaction becomes personal, curated, intentional: the opposite of a feed.

who wins: google, not the open web

google co-authored the WebMCP spec. that's no coincidence and no altruism.

google has gemini. when ai becomes the new layer through which content flows, google has more control than ever before, not less. in the browser, they could sort search results. in the ai layer, they can filter, summarize, weight, modify and select content.

ai is the new browser, except you can not only display content but actively change it before the user sees it. that's more powerful than anything google has ever had.

advertising won't disappear, it will change form. instead of banners on surfaces: weighted recommendations in agent responses. instead of sponsored listings in search results: preferred tool calls through the agent. the mechanics change, the business model stays, it just becomes less visible and therefore more effective.

WebMCP is an open W3C draft, but the infrastructure that uses it, the agents, the browsers, the cloud, belongs to a handful of companies. the web becomes technically more open and economically more closed, simultaneously.

liquid software, part two

in my last article [5], i wrote about the production side: software becomes liquid, build beats buy, the saas equation tips.

WebMCP is the consumption side of the same development. there, the rigid layer between developer and software dissolves. here, the rigid layer between user and internet dissolves.

there, it was the saas ui that dictated workflows. here, it's the website ui that dictates interactions. booking.com decides the order in which you see hotels. instagram decides which posts you read. google decides which results appear at the top.

in both cases the intermediary layer disappears and gets replaced by ai.

it's the same fundamental movement: the rigid layer between human and function becomes liquid. the saas tool becomes the custom internal tool, the website becomes the tool call, the ui becomes optional.

what to do now

WebMCP readiness is the new responsive design. in 2015, if you didn't have a mobile-optimized site, you lost users. in 2027, if you don't have WebMCP tools, you'll lose agent traffic, which will grow faster than mobile traffic ever did.

content strategy must become machine-readable. don't optimize keywords for google crawlers, provide structured tools for ai agents. your content doesn't exist for ai if it's not accessible as a tool.

the advertising model has to change. ads in tool responses instead of on surfaces. google is working on it. if you're not google, you have a problem and should start thinking about alternatives now.

companies should experiment now. a WebMCP service for your website isn't a six-month project, it's an afternoon. snout.pink has six tools in 456 lines of typescript (full source). the learning curve is flat, the head start is real.

the technology is a W3C draft, a feature flag, an experiment. but the direction is clear, and it has never been this clear.

the internet isn't disappearing. but the way we use it, through browsers, feeds and surfaces: that's disappearing. faster than most people think.

translated from the german original by claude opus 4.6