Back to Devoured - November 20, 2026
DEVOURED
Mirror Dimension for Agents: Evaluating Browser-Use Agents Without the Web

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

AI Google
Google’s 'Mirror Dimension' provides a synthetic, local web environment to safely stress-test browser-using AI agents against adversarial attacks.
What: Chrome developers built a hermetic sandbox that intercept browser traffic using a custom local proxy and dynamically injected TLS certificates, allowing agents to navigate 'sites' that behave like the real web without any internet connection.
Why it matters: Testing autonomous agents on the real web is dangerous and inconsistent; synthetic environments ensure tests are repeatable, safe, and free from external interference.
Deep dive
  • Uses gVisor for isolation and a local interception proxy to serve synthetic content.
  • Employs dynamic certificate 'minting' to prevent TLS errors in the browser sandbox.
  • Populates the synthetic web using a multi-agent harness: Research, Builder, and Critic agents.
  • Red-teaming pipeline uses HTTP headers (rather than visible URL parameters) to trigger adversarial payloads.
  • Capable of performing 1,000+ adversarial tests per security engineer, per day.
Decoder
  • Eval awareness: When an AI model detects it is in a testing environment and changes its behavior, potentially invalidating the security results.
  • Indirect prompt injection: An attack where an agent is fed malicious instructions hidden in external content (e.g., a website), leading the agent to take unauthorized actions.
  • Hermetic sandbox: A strictly isolated testing environment that has no external network access and can guarantee identical states for every run.
Original article

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

Chrome is introducing the ‘mirror dimension’; a synthetic version of the web to test agents safely in realistic online environments, without creating real-world security risks.

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 from the start. We’ve also been using coding and security agents to make Chrome safer.

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.

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.

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, we allow it to navigate to the real URL like 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 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, 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.

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.
  • 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 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.

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.

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.

Stealthy Payload Injections

Initially, our system for dynamically injecting malicious payloads relied on URL parameters that were visible to the agent. 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.

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.

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.

Explore all 56 articles in today's digest

Fresh dev news, AI-digested daily. Never miss a trend at devoured.fyi