Vercel unveils agent-browser, a lightweight way for AI agents to use a browser without MCP

Vercel has released agent-browser, a tool that gives AI agents access to a browser without bulky MCP layers. The idea is simple: show the model not the whole page DOM, but a short list of interactive elements it can work with right away.

Why MCP stalls

Playwright and Puppeteer are not going anywhere: they are strong tools for e2e tests, CI/CD and predictable parsing. Problems start the moment someone tries to hand browser control to an LLM through MCP.

To know where to click, the model needs to see the page. Usually that means sending either raw HTML or an accessibility tree into the context. On modern SPAs this quickly adds thousands of extra tokens at every step and eats the agent's memory before it ever reaches its goal.

According to data cited by the author of the analysis, a single click and a snapshot of a complex page can cost from 15 to 200 thousand tokens per step. That is not only expensive but unstable: the model spends its context reading the page tree, starts to get tangled in CSS selectors and misses the right buttons more often. For deterministic scenarios this approach is still tolerable, but for an autonomous agent that has to find its way around the web quickly, it is too heavy.

What Vercel did

Vercel's task was practical: if an agent writes an interface itself, it must be able to open a page, check a component and walk through basic actions in the browser. To get there, the team simplified agent-browser and dropped its earlier dependence on a Node daemon.

The current version is a lightweight CLI written in Rust that talks directly to the Chrome DevTools Protocol. As a result, the tool is easier to run locally, easier to put in containers, and does not drag extra Node infrastructure along.

• a single Rust binary
• direct communication with CDP, with no extra layers
• zero dependencies for Docker and local environments
• short references instead of the full DOM

The key idea is a snapshot of interactive elements. Instead of a giant tree, the agent receives a compact list such as button "Sign In" [ref=e1] or textbox "Email" [ref=e2], and then works with short commands: open the page, click @e1, fill in field @e2. This format takes hundreds of tokens rather than tens of thousands. For the LLM it noticeably lowers the load and also reduces the chance that an action breaks because of a brittle selector.

A new interface for agents

The difference shows clearly in a simple scenario: open a site and click the first article. In the classic MCP setup, the agent first receives a huge accessibility tree, then searches it for the right headline and tries to assemble an exact CSS selector. Any layout change, a cookie modal or an extra container makes such a click fragile.

In agent-browser the route is shorter: open, then snapshot, then click on a short ref. The model relies not on guesses about the DOM structure, but on a ready-made map of interactive elements.

"Don't use MCP for the browser — save your context windows and your API money."

Notably, Microsoft is already pushing a similar idea with @playwright/cli. There the agent also works through short commands, and the browser state is stored outside the model's context. This is an important shift for the whole category of agentic tooling: the market is moving away from streaming browser internals straight into the LLM and toward a scheme in which a local tool holds the state itself and hands the model only the minimum control layer it needs. The difference between the solutions now lies more in the ecosystem: Playwright remains heavier, while Vercel's Rust approach is more minimalist.

What this means

Browser automation for AI agents is starting to split into two classes. Classic Playwright and Puppeteer remain the foundation for complex testing and scraping, but for agentic coding and quick interface validation, demand for lightweight CLI wrappers is increasingly visible.

The main takeaway is simple: for an LLM it pays to provide not the whole browser, but a compact layer of commands and element references. It is cheaper, more stable and more practical in real work.