Seven Methods Is Enough

The Chrome DevTools Protocol has hundreds of methods. We built seven.

People ask me whether that is a limitation. I think it is the most important design decision we made.

What those hundreds of methods are for

CDP was designed for a specific job: helping developers debug and inspect web pages. That job requires hundreds of methods because human developers need to observe everything. Network traffic. Heap snapshots. Animation frames. DOM mutation events. Accessibility trees. Layout geometry. Every detail that might explain why a page is behaving unexpectedly.

This is excellent design for the intended consumer. Chrome DevTools is a remarkable piece of software. Every one of those methods exists because a developer somewhere needed it to understand why something was broken.

AI agents have a completely different job. They are not debugging a page. They are doing something on it, or learning something from it.

That difference changes everything about what a protocol should look like.

What agents actually do

I sat down early in Plasmate's design and listed what an AI agent actually needs to interact with the web. The list was shorter than I expected.

Agents navigate to URLs. They read what is on a page. They click things. They type into fields. They scroll. They select options from dropdowns. They extract information.

That is seven things. We called them the Agent Web Protocol. Not because seven is a magic number, but because seven is what is actually required. Everything else in CDP exists to serve human observation, not agent action.

Intents, not instructions

There is a meaningful distinction between intents and instructions.

CDP speaks in instructions: set this attribute, evaluate this JavaScript expression, capture this network request. AWP speaks in intents: navigate here, click this, tell me what you see. The implementation detail, how the click actually happens, how the page snapshot gets structured, is Plasmate's responsibility. The reasoning about what to do next is the agent's.

This separation turns out to matter in practice. When you give an agent a method called Input.dispatchMouseEvent with twelve parameters, you are asking the agent to think about mouse coordinates. That is not what language models are good at.

When you give an agent a method called click that accepts an element reference from the structured page representation, you are asking the agent to think about what it wants to accomplish. That is exactly what language models are good at.

The honest tradeoff

I want to be direct about what seven methods cannot do, because I think it is worth being honest here.

Seven methods means you cannot use Plasmate to profile memory allocation, trace network requests, or capture WebGL frames. If you are building a developer tool or a testing framework, CDP serves those cases and AWP does not. That is a real gap, not a marketing limitation.

What seven methods also means is that every agent working with Plasmate operates at the same level of abstraction. They think about the web the way a person thinks about a task, not the way a debugger thinks about a runtime. That coherence shows up in the quality of reasoning.

There is also an escape hatch: an evaluate method for raw JavaScript execution when the seven methods genuinely cannot cover a case. It exists. We rarely see it used.

The bigger question

The protocol question is actually a small part of a bigger one: what does web infrastructure designed for agents look like, rather than web infrastructure adapted for agents?

Wrapping CDP for agent use is where most tools live today. It works, the same way a wrench works as a hammer when nothing else is available.

AWP is an attempt at infrastructure designed from the agent's perspective first. Seven methods, a semantic page representation instead of a DOM tree, stable element references, and token footprints that average 17 times smaller than raw HTML.

Plasmate is open source. The protocol spec and full implementation are at plasmate.app. If you have thoughts on AWP, I would genuinely like to hear them: @dbhurley.