Brow | Devpost

Brow webmcp zamaker
Architecture

Brow

Inspiration

Brow started because I wanted to experiment with WebMCP inside a real Chrome session.

While building it, I became convinced that WebMCP represents something much bigger than browser automation.

The Web is currently designed mainly for humans. Websites expose their capabilities through HTML, buttons, forms, menus, and visual interfaces. Agents do not fundamentally need that presentation layer. They need structured access to what an application can actually do.

A website already knows that it can send a message, create a document, search for a flight, add something to a cart, or execute a query. Agents should not always have to rediscover those capabilities by interpreting pixels or reverse-engineering the DOM.

I believe the future Web should expose two interfaces: one for humans through HTML and UI, and one for agents through structured tools.

I am confident that agents will represent an increasingly large share of Web interactions, potentially more than direct human interactions in the long term. That is why I hope WebMCP becomes part of the standard Web platform and eventually reaches broad W3C adoption.

Web applications across every domain should be able to expose native interfaces for agents.

How I built it

That initial experiment became Brow, an open-source agentic stack running directly inside Chrome.

Brow operates in the user's real browser session instead of launching a separate automation browser.

It combines WebMCP page tools, remote MCP servers, semantic browser automation, reusable Skills, memory, and workflow demonstrations.

For websites that support WebMCP, the agent can use structured capabilities directly. For the rest of the Web, Brow falls back to semantic browser automation.

I also wanted Brow to remain model-independent, with support for OpenAI-compatible models, Claude, local models, and future providers.

The agent runtime is built with LangGraph.js and runs alongside a Chrome side-panel interface.

What I learned

The biggest thing I learned is that browser automation and browser understanding are very different problems.

Clicking an element is easy. Understanding what it means, whether it is still valid, what changed after an action, and what the application is capable of doing is much harder.

I also learned that raw HTML is not a great interface for agents. Modern pages contain huge amounts of implementation detail that models do not need.

This is why Brow uses semantic browser snapshots and structured information rather than simply sending the full DOM to the model.

Another important realization was that interoperability matters more than any individual model. Models and agent frameworks will change, but an open interface between applications and agents could remain.

Challenges

One of the biggest challenges was dealing with constantly changing browser state. Modern applications update dynamically, elements become stale, forms change, and single-page applications can completely change state without a page reload.

Another challenge was combining multiple tool systems — browser actions, WebMCP tools, MCP servers, Skills, and memory — into one coherent environment for the agent.

Chrome extensions also have strong security and execution boundaries, which makes coordination between the side panel, background worker, content scripts, page context, and agent runtime more complex.

What's next

The Chrome extension is only the beginning.

I eventually want Brow to give the agent its own secure development environment: a sandbox, container, or VM where it can create files, write code, install packages, execute commands, start servers, build applications, test them in the browser, and iterate autonomously.

This is difficult to do cleanly within the limitations of a standard Chrome extension.

One longer-term direction is therefore to move Brow toward a Chromium-based browser where agent capabilities can become first-class features rather than being layered on top through an extension.

The goal would be to combine the browser, WebMCP, MCP, Skills, memory, and an isolated computing environment into one agent-native platform.

Brow started as an experiment to test WebMCP.

It became an experiment around a bigger question:

What should the Web look like when many of its users are agents acting on behalf of humans?

I believe agents should not always have to pretend to be humans to use the Web.

HTML gave humans a universal interface to the Web. WebMCP could help give agents one.