2026-07-14 · 5 min read · Raw Drafts / AI Agents / Software Development
The Browser Is Becoming the Agent’s Body
Chrome DevTools for agents marks the shift from AI that writes software to AI that can observe, test, and correct what it made.
For the first wave of AI coding tools, the browser was mostly a blind spot.
An agent could read a repository, edit files, generate components, run tests, and explain what the code was supposed to do. The actual product lived somewhere else. It lived in the browser, where layouts shifted, buttons failed, requests timed out, accessibility broke, and users encountered the strange little gaps between intention and reality.
The agent could write the interface, but it could not really experience it.
That is beginning to change.
Chrome DevTools for agents gives AI systems direct access to a running browser. An agent can open a site, click through a user flow, inspect console errors, watch network requests, measure performance, test a mobile layout, and verify whether its own changes actually worked.
This sounds like a technical upgrade. It is also something more important.
The browser is becoming the agent’s body.
The model provides reasoning. The codebase provides memory. The browser provides perception and action. Through DevTools, an agent can see what it made, touch the interface, observe the result, and adjust its behavior.
That creates a new loop.
Act. Observe. Judge. Correct.
This loop matters more than raw code generation.
Generating code is relatively easy because code is symbolic. It can be produced one token at a time, checked for syntax, and compared against familiar patterns. Products are harder because they exist in a messy environment. A component can be technically correct and still feel broken. A page can load and still be unusable. A form can submit and still confuse everyone who touches it.
Software quality appears in the gap between what the code says and what the user experiences.
Until now, humans have been responsible for closing that gap. We open the browser, notice something is wrong, inspect the page, return to the code, make a change, and try again. This is the everyday rhythm of building software.
Agents are now entering that rhythm.
Once an agent can inspect a running product, it can do more than produce code. It can investigate. It can gather evidence. It can notice that a button is hidden on a small screen, trace the CSS rule responsible, make a change, reload the page, and confirm the fix.
The important shift is from generation to feedback.
An AI system that only generates is dependent on the quality of its initial prompt. An AI system with feedback can recover from incomplete instructions. It can compare intention with outcome. It can discover problems that nobody explicitly described.
That is the beginning of something closer to agency.
The same pattern is appearing across AI tools. Models are gaining access to terminals, browsers, files, design tools, databases, cameras, and robots. Each new tool gives them another way to connect abstract reasoning with the world.
The browser may become one of the most important environments in this transition because so much modern work already happens inside it.
Banking happens there. Communication happens there. Shopping, scheduling, publishing, research, design, analytics, and administration all happen there. A browser-capable agent is not limited to browsing websites. It gains access to the operating layer of modern knowledge work.
For coding agents, the immediate use cases are obvious. They can test a checkout flow, find a failed API request, audit accessibility, inspect layout shifts, or verify that a deployment works.
The longer-term implications are stranger.
A website could come with an agent that continuously tests its own core journeys. It could detect when a new release breaks a form, when performance drops, or when a navigation path becomes inaccessible. It could create a bug report, identify the likely cause, propose a patch, and verify the result.
The boundaries between development, testing, monitoring, analytics, and maintenance would start to dissolve.
Today, these activities are usually separated into different tools and roles. A developer writes the code. A tester checks the behavior. An analytics tool watches the users. A monitoring system catches errors. A designer reviews the interface. A product manager decides what matters.
An agent connected to the browser can move across several of these layers at once.
This does not mean product judgment disappears.
DevTools can reveal that a page is slow. It cannot automatically decide whether the page deserves to exist.
It can identify an inaccessible button. It cannot fully judge whether the surrounding workflow is meaningful.
It can confirm that a user reached the final step. It cannot know whether the user felt confident, manipulated, bored, or relieved.
The more capable agents become at execution, the more visible the limits of execution become.
The hard questions move upward.
What should the product do? Which problems are worth solving? What kind of behavior should it encourage? What should remain deliberately difficult? What should never be automated? When is a technically successful experience still a human failure?
These are questions of judgment, values, and direction.
This may be the real effect of better agents. They remove more of the mechanical distance between an idea and its implementation. That makes the quality of the idea easier to see.
When code generation becomes cheap, the scarce skill is deciding what deserves to be built. When agents can test their own work, the scarce skill is defining what success should look like. When software can repair itself, the scarce skill is knowing which version of the system is worth preserving.
Chrome DevTools for agents is one small sign of this shift.
It marks the moment an AI coding agent begins to cross the boundary between describing software and inhabiting it. The browser gives the agent somewhere to act, something to perceive, and consequences it can inspect.
AI could already write the interface.
Now it can open the browser, look at what happened, and try again.
AI authorship note
This essay began with Kris Haamer asking what Chrome DevTools for agents means, then asking how the idea connects to Raw Drafts. AI supported research, drafting, editing, and implementation. Kris selected the central frame that the browser is becoming the agent’s body and directed the article toward feedback loops, product judgment, and the shift from generating software to operating inside it.