# Introducing WebMCP: Agents in the Browser

RL Nabors, Arise | AI Engineer Europe 2026 | 23:08

Source: https://www.youtube.com/watch?v=LMbeDEQO6QM
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/introducing-webmcp-agents-in-the-browser
Published: 2026-05-23
Tags: design, mcp, tool-use

## TL;DR
- The browser can give agents direct access to website functions through WebMCP, without screenshot parsing or DOM traversal.
- MCP Apps let tool responses render as interactive HTML, CSS, and JavaScript inside an agent interface.
- Chat is a temporary agent interface because it makes users discover a system's capabilities through conversation instead of through the site's own visual design.

## Summary
RL Nabors uses her web comic archive to explain two ways to bring web experiences into agent software. MCP tools expose comic navigation and search as structured functions, while MCP resources could provide transcripts and other context directly, although client support remains limited. MCP Apps go further by returning a bundled HTML, CSS, and JavaScript interface inside an iframe. Her comic reader preserves images, navigation, comments, and transcript mode inside Claude. WebMCP approaches the problem from the browser side. Declarative attributes expose existing forms, while the imperative model registers JavaScript tools through navigator.modelContext. Browser agents can then call functions such as moving to the next comic page instead of interpreting screenshots or traversing the DOM. Nabors argues that the web's existing APIs, including Speech, Animation, Audio, Canvas, WASM, and CSS, are ready to power interactive agent experiences.

## Key ideas
### The browser is an infinite canvas for agent experiences
[01:56](https://www.youtube.com/watch?v=LMbeDEQO6QM&t=116s)
Nabors describes the browser as more than a document reader. It can render video, audio, animation, and whatever else a product needs through existing web APIs. She connects this view to her work on the Web Animations API and interactive demos such as Alice in Wonderland. Her goal is to put websites into agents or give agents a richer surface through the browser. The web comic archive is her practical test case: repair an old site, keep its original content, and make it usable by humans in browsers, humans in agents, and agents acting in browsers.

### A web service is easier for users to connect than a local MCP process
[06:05](https://www.youtube.com/watch?v=LMbeDEQO6QM&t=365s)
MCP transports determine how an MCP server communicates with an agent. With STDIO, which Nabors jokingly calls 'studio', the server runs as a local process spawned by the client. Users configure a command containing JSON and command-line inputs. With HTTP, the server runs as a web service at an HTTP endpoint and communicates through POST requests, which also fits serverless hosting such as Vercel or Cloudflare. The user experience becomes adding a URL in the agent's settings instead of installing and configuring a local process.

### Comic navigation works well as MCP tools, while transcripts need resources
[08:47](https://www.youtube.com/watch?v=LMbeDEQO6QM&t=527s)
Nabors exposes functions that match the archive's website: listing comics, storylines, and characters, searching comic transcripts, searching by character, and retrieving a transcript. Most return structured JSON, while the transcript returns Markdown. She wants agents to have the archive's full text available for analysis of themes and character arcs without making the model request hundreds of transcripts one by one. MCP resources would fit that use, but she says the specification is loosely defined, implementations are inconsistent, and she cannot find a client that makes resources accessible in its interface. She also argues that documentation belongs in resources rather than in tools that agents must call manually.

### Chat-only agent interfaces make users discover capabilities by guessing
[11:47](https://www.youtube.com/watch?v=LMbeDEQO6QM&t=707s)
Nabors calls the chatbox landing page a 'starfish' design because it leaves users to do the work. A person must already understand what the system can do and which request to type. She compares this with command-line software, which programmers may prefer but which eventually gave way to interfaces built around tapping and pointing. A chat interface can work for someone familiar with a system such as Linear, but it gives newcomers few visual cues. Her comic reader is an example of a richer surface: the user can see panels, move forward and backward, show commentary, and switch to transcript mode.

### MCP Apps bring a complete interactive surface into the agent
[13:26](https://www.youtube.com/watch?v=LMbeDEQO6QM&t=806s)
An MCP tool can return an app made from HTML, CSS, and JavaScript bundled into a single file. Nabors's get page tool returns a comic reader that looks like the website and uses the archive's resources. It accepts identifiers and a page number, then points to the app through a UI metadata attribute. The app runs in a sandboxed iframe. Required assets must be embedded, and external fonts or images need the right content security policy. The app has no local storage or network access, so it asks the server to perform operations through tool calls. Navigation controls can call tools, and Nabors recommends marking such tools for app visibility so the model does not expose their internal data as plain text.

### WebMCP lets browser agents call functions already present on a page
[17:38](https://www.youtube.com/watch?v=LMbeDEQO6QM&t=1058s)
Browser agents often rely on screenshots or DOM traversal to operate websites. Nabors says both approaches consume compute, either through visual models or by processing large amounts of HTML. WebMCP gives a page a direct way to expose its existing functions to an agent, making each HTML page a small MCP-like tool server. She cautions that WebMCP is inspired by MCP rather than being fully compliant with the MCP specification, and the specifications may diverge. The aim is direct browser tooling: an agent can call the same functions and links that the site's JavaScript already uses.

### WebMCP has declarative and imperative ways to expose tools
[18:58](https://www.youtube.com/watch?v=LMbeDEQO6QM&t=1138s)
The declarative model adds a tool name and description to an existing form. A site that already processes forms with JavaScript can expose that form to an agent with little extra work. The imperative model uses navigator.modelContext.registerTools with a name, description, input schema, and execution callback. Nabors uses this model for the comic archive because its main interactions are not forms. A registered next-page function can find the page's next link and let the browser agent navigate without clicking around. The API is still developing, and she demonstrates it with a debugging extension that lists the tools and provides a small chat interface.

### Existing browser APIs can power agent interfaces without extra inference
[21:47](https://www.youtube.com/watch?v=LMbeDEQO6QM&t=1307s)
Nabors ends with a talking version of the comic reader built with the browser's Web Speech API. The browser reads the comic content aloud without an inference service or additional dependency, although she says the result sounds poor and could be improved with a service such as ElevenLabs. She points to the same opportunity in Web Animation, Audio, Canvas, WebAssembly, and CSS. These capabilities already exist in the browser, so an agent interface can use them directly instead of rebuilding every interaction as a chat response.

## Notable quotes
- "It is an infinite canvas that can render anything, not just documents, but video, audio, whatever you need, there's an API for it." (02:16)
- "Chat is the lowest common denominator of the user experience." (11:47)
- "It makes every HTML page a mini MCP tools server." (18:17)
- "CSS and JavaScript aren't just the language of the web. They're the language of interactive experiences on agents." (21:40)

## Tools & references mentioned
- Mozilla
- Firefox DevTools
- W3C
- Microsoft Edge
- React
- react.dev
- reactnative.dev
- Arise
- The Agentic Web
- Anti-Social Social Agent
- MCP
- MCP Apps
- WebMCP
- Claude
- Vercel
- Cloudflare
- Web Animations API
- Web Speech API
- ElevenLabs
- MCP B extension

## Who should watch
- You maintain a website and want browser agents to use its forms, links, or JavaScript functions without relying on screenshots.
- You are building an MCP server or app and need to understand HTTP transport, sandboxed iframe limits, content security policy, and app tool calls.
- Your agent product is mostly a chatbox and you want to give users a visual, interactive surface instead of making them guess which prompts to write.

## Related talks

- [The agent-ready web: Simplify user actions with WebMCP](https://aietalks.com/talks/the-agent-ready-web-simplify-user-actions-with-webmcp) (Tara Agyemang, Google Chrome, 21:34)
- [MCP Apps: Extending the Frontier](https://aietalks.com/talks/mcp-apps-extending-the-frontier) (Ido Salomon, MCP steering committee & Liad Yosef, Aura, 18:38)
- [MCP Apps: Primitives, Discovery, and the Future of Software](https://aietalks.com/talks/mcp-apps-primitives-discovery-and-the-future-of-software) (Pietro Zullo, Manufact, Inc, 28:54)
- [MCP UI: Extending the frontier](https://aietalks.com/talks/mcp-ui-extending-the-frontier) (Liad Yosef & Ido Salomon, MCP Apps, 22:21)
- [AI Didn't Kill the Web, It Moved in!](https://aietalks.com/talks/ai-didnt-kill-the-web-it-moved-in) (Yohan Lasorsa, Microsoft & Olivier Leplus, AWS, 52:55)