# Mirror Dimension for Agents: Evaluating Browser-Use Agents Without the Web

> Source: <https://blog.google/security/mirror-dimension-for-agents/>
> Published: 2026-11-19 19:11:35+00:00

**Recommendation:** Test browser-use agents in a hermetic sandbox that intercepts real URLs and serves synthetic sites, and reset state between trajectories so every eval run starts from an identical baseline.
More in the playbook "Designing agent systems": <https://wpnews.pro/playbooks/agent-architecture>

Chrome Security

# Mirror Dimension for Agents: Evaluating Browser-Use Agents Without the Web

Agents are already having a massive impact on how people use the web. That’s why we designed Chrome’s agentic browsing feature, auto browse, with [built-in protections](https://blog.google/security/architecting-security-for-agentic/) from the start. We’ve also been [using coding and security agents to make Chrome safer](https://blog.google/security/chrome-stronger-with-every-update/).

To validate and strengthen those protections, Chrome created a ‘mirror dimension’, a synthetic version of the web to test agents safely. This controlled testing ground lets engineers evaluate auto browse in realistic online environments, featuring thousands of simulated websites inspired by everyday user journeys, without creating real-world security risks. It serves as a critical tool to ensure new capabilities are safe, reliable, and resistant to threats. Below, we detail step-by-step how we built this environment and the obstacles we overcame.

## **The Challenge of Developing Browser-Use Agents**

Many of the tasks that we train our agents to handle require them to navigate to well-known websites and perform actions on those sites like clicking through subpages, scrolling to locate information or typing into input fields. Consider a user prompt like: “*Go to my youtube account and help me download the latest episode of the Made By Google podcast for my flight today*”. Here, the user does not provide a specific URL; instead, the model infers the destination and formulates a plan to navigate to www.youtube.com.

This introduces a fundamental eval challenge. Training and evaluating agents requires executing thousands of read and write actions across hundreds of websites on a continuous basis. But, pointing an agent at the public web during testing can be both ineffective, since the web is constantly changing, and irresponsible, since agents can cause harm when given unfettered access. Rigorous evaluations must be safe, reliable and repeatable: side effects from one trajectory must never persist into the next, ensuring every test run starts from a clean, identical baseline.

To solve this, we built a hermetic ‘mirror dimension’ for our agents. This environment combines an isolated sandbox populated with realistic synthetic websites and a local interception proxy that preserves the realism of browsing the live web. To create a **truly hermetic and high-fidelity** environment we needed to solve several unique engineering challenges around network routing and site generation.

High-level architecture of the hermetic 'mirror dimension' evaluation sandbox, routing all browser traffic through an interception proxy to local synthetic web environments.

## **The Art of Redirection: The Sandbox and the Proxy**

One of the key challenges with using synthetic sites is avoiding **eval awareness,** where the model suspects it is being tested and performs actions it might not otherwise. This means that for our 'mirror dimension', it was not enough to simply host all our synthetic sites under a single domain. With that approach, the URL for Youtube might look like:

https://fake-sandbox-sites.web.app/evals/www.youtube.com

This presents an interesting engineering challenge: how can we enable the agent to infer the URLs and navigate to websites for testing while covertly redirecting it to our sandbox? One easy solution would be to write our evals in such a way that the user prompt explicitly instructs the model to navigate to that exact sandbox URL. But in our testing, that easily breaks the realism of the eval and induces eval awareness.

**Same URL, Different Dimension**

Instead of forcing the agent to visit a suspicious sandbox address like the one above, we allow it to navigate to the real URL like [https://www.youtube.com](https://www.youtube.com), just as it would in the wild. Under the hood, the agent uses a headless Chrome browser in an isolated [gVisor sandbox](https://gvisor.dev/) to load the page. And rather than allowing the request to reach external DNS or the public internet, the sandbox captures the network connection and routes it to a local proxy that serves our generated site instead.

However, this presents a problem: this type of interception is exactly the kind of person-in-the-middle attack that Chrome is specifically engineered to block to protect users. Without a way to cryptographically prove the proxy's identity to the browser, every intercepted request would trigger fatal TLS errors.

**Maintaining the Illusion with Cert Minting**

To prevent Chrome from throwing the “Invalid Cert Authority” error shown above, we have to convince the browser that our local proxy is serving the actual destination website. Simply downgrading connections to unencrypted HTTP isn’t an option, since that would still trigger other “Not Secure” warnings in Chrome.

Instead, the proxy dynamically mints TLS leaf certificates on the fly that chain back to a custom Root Certificate Authority (CA) pre-installed in the sandboxed Chrome instance. On a real user’s device, an external network attacker cannot install a custom Root CA without already having privileged administrative access to the machine–but because we fully control the gVisor sandbox, we can safely configure this trust anchor at startup so Chrome validates the synthetic sites normally.

## **Spinning a Synthetic Web**

With the containment boundary and interception proxy in place, the next challenge is actually populating our mirror dimension. Our agents carry out multi-step, advanced workflows, so if a site feels static or half-baked the agent often does pick up on subtle cues that it's inside a test environment, leading to eval awareness. Therefore, we’ve had to find ways to scalably populate and maintain hundreds of interactive, stateful web pages. The sandbox has to support everything from local service marketplaces and e-commerce checkouts to social media feeds and recipe sites.

Instead of building and maintaining these sites manually, we developed an autonomous **multi-agent site development harness** to help us match the scale needed. A human in the loop simply defines the high-level user journeys we want our agent to test, and a specialized team of sub-agents designs, builds, inspects, and critiques the web site directly inside the sandbox.

High level architectural diagram of the site development harness, depicting how the harness iterates to develop a fully functioning website from a single prompt.

The site development harness divide the work across three specialized agent roles:

- **The research agent:** Generates site specifications based on the content in the user’s prompt. For example, if the user requests an e-commerce platform, it might enumerate site-specific requirements like: product catalog filtering, cart persistence, coupon code validation, and a multi-step checkout workflow. To help the other sub-agents create a high fidelity site, the research agent will build out additional requirements (when not specified by the user) such as establishing the high level architecture of the site, relevant CUJs and even mocks of basic UI assets using[Nano Banana](https://gemini.google/overview/image-generation/) .
- **The builder agent:** Translates the specifications into functional code, writing the HTML, CSS and JavaScript to create responsive layouts as well as the multi-page navigations required for more complex trajectories.
- **The critic agents:** Evaluates the generated application against production web benchmarks, verifying that accessibility tree semantics (ARIA roles and labels) work as expected, ensuring form validation catches edge cases, auditing console logs for JavaScript errors, and validating that element boundaries and various responsive screen-size layouts render correctly.

Most importantly, this is all made possible with **Chrome DevTools for Agents****,** which serves as the agents’ eyes and hands. Rather than analyzing the source code as text, the Chrome DevTools MCP server allows the sub-agents to exercise their multimodal capabilities. It gives them tools to visually inspect screenshots of the rendered page, execute actual clicks and keystrokes on page elements, navigate around the generated site and observe how the application behaves in real time while executing real user journeys.

Here is a demo video showing the agents interacting with each other and with the site. Follow the back-and-forth between the critic agents and the developer agent: problems are reported, fixes come back, and the critics check again. One key moment to watch for is a fix that introduces a brand new problem. That's where the additional loop of critics shows its value, and you can see how the system prioritizes fidelity over completion speed.

Demonstration video that shows the various agents interacting with each other to develop, critique and refine a site from just a single prompt.

## **Simulating a Hostile Web with Dynamic Red-Teaming**

Beyond evaluating how agents handle complex everyday tasks, owning every layer of our 'mirror dimension' brings us back to our core safety goal: rigorously stress-testing agent safeguards. One of the most critical threats those safeguards must stop is **indirect prompt injection**, where attackers embed hidden instructions inside untrusted web content in order to manipulate an agent into taking unauthorized actions.

The attack surface for indirect prompt injections on the web is uniquely expansive, and is not just limited to visible text on a webpage. Since browser agents perceive a rich, multimodal interface — spanning rendered visual layouts, underlying DOM elements, and structured tool interactions like [**WebMCP**](https://developer.chrome.com/docs/ai/webmcp) — a malicious payload can be tucked into any of those layers at any step along a multi-step workflow.

Testing an agent’s resilience against such a diversity of prompt injection vectors requires an evaluation environment that can synthesize malicious payloads and inject them in any of these surfaces, and at any point in time. Fully controlling our sandbox web server allows us to programmatically manipulate payloads across the full web context, whether that’s injecting prompt injections as images or text, adding malicious aria labels, or even altering WebMCP tool responses on the fly. This approach turned our hermetic sandbox into a dynamic testbed for multi-vector adversarial stress-testing across multi-turn trajectories.

**Stealthy Payload Injections**

Initially, our system for dynamically injecting malicious payloads relied on URL parameters that were visible to the agent. A fake example of such a URL would be:

*https://www.youtube.com/watch?v=dQw4w9WgXcQ&prompt_inject_payload=abcd1234*

We quickly learned that frontier models are far too perceptive for this. There were many instances where an agent became eval aware simply by noticing an abnormal query parameter that would not normally be associated with a given site.

Thus, to avoid tipping off agents about evals in the URL, we configured the sandbox to serve sites with injected adversarial payloads by passing the payload identifiers via HTTP headers. Our red-teaming orchestration harness populates custom HTTP request headers like X-Sandbox-Injection-Key in order to specify the payload to be injected. The sandbox web server intercepts and filters these headers, and then serves the mutated version of the page with the injected payload, leaving the page’s visible URL completely pristine. To the agent, the page appears to be a normal website, with an otherwise completely realistic URL path structure.

**Impact**

A security engineer can hand-craft and test a few dozen realistic attacks a day, but verifying and refining each idea quickly becomes the bottleneck. Our automated red-teaming pipeline uses the 'mirror dimension' to test and refine our best engineers' ideas across a wide variety of sites, steadily creating more than 1,000 tests candidates every day per security engineer. That's over 30x what one engineer could do by hand, or more than a month of manual testing, every day. That frees our experts to focus on discovering new attack techniques while the pipeline handles the repetitive work of refinement and evaluation.

## **Looking Ahead**

Agents with browser-use capabilities are helping users with longer tasks that involve complex, multi-step workflows. As they become more capable and more observant, we expect that hermetic sandboxes equipped with fully synthetic internets like the mirror dimension will be the baseline for agent safety and alignment research. This is because, fundamentally, building safe and aligned agents requires giving them a space where they can be monitored as they carry out longer workflows and make judgment calls on novel scenarios outside their training.

While this post focuses on browser-use agents that operate within a strictly bounded set of web primitives and tool calls, we believe the underlying mirror dimension sandbox architecture can be extended to evaluate more general-purpose coding agents with broader toolsets. As the agentic ecosystem grows, we remain focused on evaluating and hardening Chrome’s built-in defenses against hostile prompt injections, improving the realism of the sandbox to minimize eval awareness, and expanding our internal security testing infrastructure as agents gain richer capabilities.
