Stagehand vs Browser Use: Architecting Production AI Browser Automation & Web Scraping

# Stagehand vs Browser Use: Architecting Production AI Browser Automation & Web Scraping

Summary: The architectural comparison of Stagehand vs Browser Use defines modern AI browser automation. Stagehand pairs TypeScript with deterministic Playwright primitives and Zod schema extraction to minimize token consumption and latency. Conversely, Browser Use executes an autonomous Python-based multi-turn agent loop optimized for open-ended visual navigation. This engineering guide evaluates their execution engines, token pruning mechanics, anti-bot evasion profiles, and production trade-offs across enterprise web scraping pipelines.

---

The Paradigm Shift in Headless Browser Automation: From Deterministic Selectors to Semantic Primitives

For over two decades, enterprise web scraping and browser automation relied on deterministic browser control libraries—beginning with Selenium in 2004, followed by Puppeteer in 2017, and Microsoft Playwright in 2020. Engineering teams constructed rigid data pipelines using CSS selectors, XPath expressions, and explicit network request interception.

While performant, this deterministic approach suffers from chronic operational brittleness when applied to modern web applications. Modern frontend architectures present several failure modes for traditional selector-based automation:

• Dynamic Class Obfuscation: Modern build pipelines (CSS Modules, Styled Components, Tailwind CSS, and Vanilla Extract) generate randomized, hashed class names (.css-1r8b3g, .sc-bdVaJa) that mutate across production deployments.
• Complex Client-Side Hydration: Single-page applications (SPAs) built with Next.js, Remix, and React Server Components hydrate asynchronous state progressively, leading to non-deterministic element readiness and race conditions.
• Encapsulated Shadow DOMs: Web Components and micro-frontends isolate internal DOM subtrees within shadow roots, preventing top-level document traversal and standard DOM querying.
• Adversarial DOM Mutation: Anti-bot engines deliberately shuffle DOM node hierarchies, insert invisible decoy elements (aria-hidden="true", zero-height spans), and alter form control attributes upon user interaction to invalidate deterministic bots.

These structural realities have forced enterprise data teams to transition toward semantic browser automation. Rather than instructing the browser engine through brittle structural coordinates, modern systems instruct browser instances using natural language goals and strict semantic schemas.

Within this new paradigm, two dominant open-source architectural patterns have emerged: Stagehand (developed by Browserbase) and Browser Use. While both platforms integrate large language models (LLMs) with underlying browser drivers, they embody fundamentally opposing engineering philosophies: schema-driven deterministic execution versus autonomous vision-guided agent loops.

---

Side-by-Side Architecture Comparison: Stagehand vs. Browser Use

Choosing between Stagehand and Browser Use requires evaluating their core execution models, language runtimes, state representation strategies, and error-handling topologies.

+----------------------------------------------------------------------------------------------------+
|                                    ARCHITECTURAL COMPARISON                                        |
+------------------------------+----------------------------------+----------------------------------+
| Vector                       | Stagehand                        | Browser Use                      |
+------------------------------+----------------------------------+----------------------------------+
| Primary Language & Runtime   | TypeScript / Node.js (v18+)      | Python (v3.11+) / AsyncIO        |
| Core Paradigm                | Deterministic Hybrid Primitives  | Autonomous Cognitive Agent Loop  |
| Base Automation Driver       | Playwright (TypeScript API)      | Playwright (Python async API)    |
| Primary Control Primitives   | page.act(), extract(), observe() | Agent(task).run(max_steps)       |
| State Extraction Engine      | Accessibility Tree + DOM pruning | Viewport Screenshots + Bounding  |
|                              |                                  | Boxes + Indexed Element Tree     |
| Schema Validation            | Zod (Native TypeScript)          | Pydantic / JsonSchema            |
| Multi-Turn Decision Making   | User-orchestrated code control   | Autonomous LLM re-planning loop  |
| Inference Calls Per Page     | 1 per primitive execution        | N steps (compounding multi-turn) |
| Latency Profile              | Single-turn per primitive call   | Multi-turn compounding per step  |
| Production Blast Radius      | Predictable, unit-testable       | High non-deterministic variance  |
+------------------------------+----------------------------------+----------------------------------+

Stagehand: Procedural Primitives and Deterministic Guardrails

Stagehand operates as a lightweight, semantic extension layer atop the native TypeScript Playwright API. Its architectural philosophy treats AI not as an autonomous driver, but as a resilient semantic parser that resolves structural ambiguity on demand.

Stagehand exposes three core procedural primitives:

1. page.act(instruction): Translates natural language intent (such as "click the quarterly financial results tab") into an underlying Playwright interaction, automatically resolving the target element via an extracted semantic map.

2. page.extract(instruction, schema): Ingests the current page state, extracts data conforming to a defined Zod schema, and performs runtime type validation before returning structured data.

3. page.observe(instruction): Analyzes the current DOM state to return a deterministic list of actionable candidate selectors and descriptions, allowing developers to construct explicit branching logic.

In Stagehand, the host application maintains 100% control over the execution loop. If an extraction step fails, standard TypeScript try/catch blocks capture the exact exception, allowing deterministic retries, proxy switches, or graceful degradation.

Browser Use: Vision-Language Cognitive Loops

Browser Use represents an autonomous agent architecture constructed in Python. Instead of relying on programmatic step definitions, Browser Use initializes an autonomous agent loop (Agent.run()) driven by an iterative perception-reasoning-action cycle.

At each step in its cognitive loop, Browser Use executes the following pipeline:

1. DOM Perception: Injects a specialized client-side JavaScript payload into the active browser page to identify all interactable DOM elements (buttons, inputs, links, dropdowns).

2. Coordinate & Index Mapping: Calculates absolute bounding boxes for interactive nodes and assigns visible numeric tags ([1], [2], [3]) directly over the viewport.

3. Multimodal State Ingestion: Captures a high-resolution viewport screenshot and packages it alongside an indexed text representation of the interactive DOM tree.

4. Cognitive Planning: Transmits the multimodal state to a Vision-Language Model (VLM, such as Claude 3.5 Sonnet or GPT-4o). The model outputs a structured JSON response containing internal reflection, evaluation of the previous action, current sub-goal, and next tool execution (e.g., click_element(index=14), input_text(index=3, text="Enterprise Solutions"), navigate(url=...), or done()).

5. Execution & Feedback: The Python runtime parses the tool invocation, executes the command via Playwright, waits for network idle states, and iterates until the objective is satisfied or max_steps is reached.

---

DOM Token Pruning and Context Compression: Benchmarks and Mechanics

Raw DOM trees in modern client-rendered web applications frequently contain thousands of nested elements, inline styling directives, and complex component hierarchies. When serialized naively to standard HTML strings, these documents consume tens of thousands of tokens. Passing raw, unpruned HTML into LLM context windows degrades performance: it inflates inference costs, increases time-to-first-token latency during prompt ingestion, and risks attentional degradation across deep token contexts.

Stagehand and Browser Use solve this bottleneck using divergent context compression techniques.

Stagehand's Accessibility-First DOM Distillation

Stagehand bypasses the raw DOM by querying the browser engine's internal Accessibility Tree (AXTree) through the Chrome DevTools Protocol (Accessibility.getFullAXTree). The browser's accessibility engine already strips away layout containers, style rules, and presentation noise, leaving only semantic nodes endowed with accessible names, roles, and values.

Stagehand then applies a multi-stage distillation pipeline:

• Tag Stripping: Purges all <script>, <style>, <svg>, <noscript>, and HTML comment nodes.
• Invisible Node Elimination: Evaluates element layout geometry; elements with display: none, visibility: hidden, opacity: 0, or bounding boxes outside the viewport clipping rectangle are pruned.
• Attribute Whitelisting: Retains only semantic identifiers (href, aria-label, role, data-testid, placeholder, title), stripping inline styles, class hashes, and layout directives.
• Ephemeral ID Injection: Assigns a temporary identifier attribute (data-stagehand-id="x") to each candidate interactable node, providing a lightweight ground-truth selector for subsequent Playwright actions.

Browser Use's Interactive Tree Indexing and Visual Grounding

Browser Use takes a perception-driven approach. It injects a custom DOM-scraping script (get_interactive_elements.js) that walks the live DOM and calculates whether an element is interactable based on event listeners, role definitions, and computed CSS styling.

The script filters out structural containers and generates a flat, indexed representation:

[1] <a href="/pricing">Pricing</a>
[2] <input placeholder="Search enterprise solutions..." />
[3] <button type="submit">Request Demo</button>

When vision mode is enabled, Browser Use overlays these numeric indices directly onto the page canvas and captures a screenshot. The LLM processes both the textual index list and the visual image, achieving spatial grounding. While this allows the agent to interact with canvas elements and non-standard custom controls, multimodal tokens increase context size and inference latency.

Architectural Context Profiles and Compression Mechanics

When architecting high-throughput automation pipelines, engineering teams must evaluate how each framework serializes the DOM and handles state representations across different frontend topologies.

[!NOTE]

Falsifiability Check: To verify whether DOM pruning has discarded essential semantic data, validate the pruned output against the page's raw text content via Chrome DevTools Protocol (Runtime.evaluate returning document.body.innerText). If target data entities present in innerText are absent from the pruned model payload, your compression pipeline is over-pruning semantic nodes.

---

Production Code Implementation: TypeScript Stagehand Schema Extraction

The following runnable TypeScript module implements production-grade schema extraction using Stagehand. It integrates Zod runtime validation, model parameter controls, and structured error handling for high-throughput data extraction.

import { Stagehand } from "@browserbasehq/stagehand";
import { z } from "zod";
import * as dotenv from "dotenv";

dotenv.config();

// Define strict enterprise extraction schema
const EnterprisePricingSchema = z.object({
  tierName: z.string().describe("Name of the subscription tier"),
  monthlyPriceUSD: z.number().nullable().describe("Monthly cost in USD, or null if custom"),
  annualCommitment: z.boolean().describe("Whether annual commitment is required"),
  seatLimit: z.number().nullable().describe("Maximum seats allowed, null if unlimited"),
  features: z.array(z.string()).describe("List of core feature entitlements"),
  hasSsoIntegration: z.boolean().describe("Explicit support for SAML/SSO authentication")
});

const PricingExtractionResponse = z.object({
  companyName: z.string(),
  currency: z.string(),
  tiers: z.array(EnterprisePricingSchema),
  rawLegalDisclaimer: z.string().optional()
});

export type PricingData = z.infer<typeof PricingExtractionResponse>;

export async function extractEnterprisePricing(targetUrl: string): Promise<PricingData> {
  const stagehand = new Stagehand({
    env: process.env.BROWSERBASE_API_KEY ? "BROWSERBASE" : "LOCAL",
    apiKey: process.env.BROWSERBASE_API_KEY,
    projectId: process.env.BROWSERBASE_PROJECT_ID,
    modelName: "claude-3-5-sonnet-20241022",
    modelClientOptions: {
      apiKey: process.env.ANTHROPIC_API_KEY,
    },
    verbose: 1,
    debugDom: false
  });

  try {
    await stagehand.init();
    const page = stagehand.page;

    // Navigate to target web property
    await page.goto(targetUrl, { waitUntil: "networkidle", timeout: 30000 });

    // Dismiss interstitial dialogs or modal overlays if present
    const modalDismiss = await page.observe({
      instruction: "Find any modal dismiss, announcement close, or dialog acknowledgment buttons"
    });

    if (modalDismiss.length > 0) {
      await page.act({
        action: "Click the modal dismiss or close button to reveal main page content"
      });
    }

    // Toggle annual billing switch to verify pricing structures
    const billingToggle = await page.observe({
      instruction: "Find the billing cadence toggle for annual or monthly billing"
    });

    if (billingToggle.length > 0) {
      await page.act({
        action: "Switch to annual billing to reveal discounted enterprise rates"
      });
    }

    // Perform structured extraction against validated Zod schema
    const extractedData = await stagehand.extract({
      instruction: "Extract all subscription pricing tiers, feature matrices, and enterprise authentication terms",
      schema: PricingExtractionResponse,
      useVision: false // Pure accessibility DOM extraction minimizes token usage
    });

    return extractedData;
  } catch (error) {
    console.error(`[Extraction Failed] Error parsing URL ${targetUrl}:`, error);
    throw error;
  } finally {
    await stagehand.close();
  }
}

// Execution Entry Point
if (require.main === module) {
  (async () => {
    const url = "https://example.com/enterprise/pricing";
    const result = await extractEnterprisePricing(url);
    console.log("[Extraction Result]:", JSON.stringify(result, null, 2));
  })();
}

TypeScript Architecture Analysis

• Type Safety & Schema Integrity: Zod schemas provide static TypeScript types via z.infer and runtime validation. If an LLM hallucinates non-existent pricing properties or returns incorrect scalar types, Zod throws an actionable validation exception.
• Granular Determinism: By pairing observe() with conditional act() calls, the system executes UI interactions only when candidate elements are confirmed to exist, preventing speculative hallucinated clicks.
• Low Cost Per Extraction: By setting useVision: false, the operation runs exclusively against the pruned accessibility tree, processing complex pricing matrices in a compact token payload.

---

Production Code Implementation: Python Browser Use Autonomous Agent Loop

The following runnable Python implementation demonstrates an autonomous agent loop constructed with browser-use. It configures a custom Chromium context, applies stealth options, and processes an exploratory data collection objective.

import asyncio
import os
import json
from typing import Optional
from pydantic import BaseModel, Field
from dotenv import load_dotenv

from browser_use import Agent, Browser, BrowserConfig
from browser_use.browser.context import BrowserContextConfig
from langchain_anthropic import ChatAnthropic

load_dotenv()

class EnterpriseLeadProfile(BaseModel):
    organization_name: str = Field(description="Name of the enterprise entity")
    solution_category: str = Field(description="Primary category of the enterprise solution")
    key_executives: list[str] = Field(default_factory=list, description="Leadership contacts identified")
    headquarters: Optional[str] = Field(default=None, description="Primary geographic HQ")
    core_technologies: list[str] = Field(default_factory=list, description="Core technical stack or framework capabilities identified")

async def run_autonomous_discovery_agent(target_domain: str) -> Optional[str]:
    # Configure resilient browser runtime with stealth parameters
    browser_config = BrowserConfig(
        headless=True,
        disable_security=False,
        extra_chromium_args=[
            "--disable-blink-features=AutomationControlled",
            "--no-sandbox",
            "--disable-setuid-sandbox",
            "--disable-infobars",
            "--window-position=0,0",
            "--ignore-certificate-errors",
            "--ignore-certificate-errors-spki-list",
            '--user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"'
        ]
    )

    context_config = BrowserContextConfig(
        wait_for_network_idle_page_load_time=3.0,
        maximum_wait_page_load_time=25.0,
        browser_window_size={"width": 1920, "height": 1080},
        locale="en-US"
    )

    browser = Browser(config=browser_config)

    # Initialize foundation LLM driver with structured planning capacity
    llm = ChatAnthropic(
        model_name="claude-3-5-sonnet-20241022",
        temperature=0.0,
        api_key=os.environ.get("ANTHROPIC_API_KEY")
    )

    task_prompt = (
        f"Navigate to {target_domain}. Locate the company's enterprise overview or about page. "
        "Identify core technology offerings and leadership listings. Synthesize this data into a structured summary "
        "specifying organization name, solution category, key executives, headquarters, and core technologies."
    )

    agent = Agent(
        task=task_prompt,
        llm=llm,
        browser=browser,
        browser_context_config=context_config,
        use_vision=True,
        max_actions_per_step=2
    )

    try:
        # Execute autonomous perception-planning-action loop
        history = await agent.run(max_steps=12)
        
        final_result = history.final_result()
        print("\n[Autonomous Agent Task Complete]")
        print("Final Synthesis:\n", final_result)
        
        # Output action trajectory telemetry
        print(f"\n[Telemetry] Steps Executed: {len(history.steps)}")
        return final_result

    except Exception as exc:
        print(f"[Agent Execution Error]: {str(exc)}")
        raise
    finally:
        await browser.close()

if __name__ == "__main__":
    domain = "https://example.com/company"
    asyncio.run(run_autonomous_discovery_agent(domain))

Python Architecture Analysis

• Autonomous Exploration: The agent navigates unstructured navigation structures, locating menus, handling unknown URL patterns, and discovering multi-page paths without explicit hardcoded instructions.
• Multimodal Perception: With use_vision=True, the agent evaluates visual elements like non-standard badges, icon-only menus, and canvas controls that lack standard HTML text representations.
• Operational Overhead: Each step invokes the LLM with multimodal payloads. A multi-step autonomous trajectory rapidly accumulates tokens, as each step re-transmits the task prompt, cumulative interaction history, interactive DOM index, and high-resolution viewport screenshots. Implementing explicit step-limit guardrails (max_steps=12) is essential to prevent compounding costs and runaway execution loops.

---

Enterprise Anti-Bot Mitigation and Evasion Architecture

When deploying AI-driven browser automation at enterprise scale, raw model performance is secondary to browser survivability. Modern bot management systems—including Cloudflare Turnstile, DataDome, Akamai Bot Manager, and Kasada—operate multi-layered behavioral and cryptographic detection engines.

Standard Playwright instances frequently fail automated bot challenges upon connection or initial script execution due to several exposed browser telemetry vectors:

1. Automation Flag & CDP Artifacts: Pure Chrome DevTools Protocol connections natively expose window.navigator.webdriver = true, exhibit distinctive Runtime.enable message timing anomalies, and expose evaluation side-effects across execution stack traces. Modern bot defense scripts probe these runtime properties, permissions states, and headless client indicators immediately upon page load.

2. TLS / JA4 Fingerprint Mismatch: Headless Chromium binaries compiled on Linux emit distinctive TLS Client Hello signatures (cipher suites, elliptic curves, signature algorithms) that diverge from authentic desktop browsers. Bot defense systems compute JA3 and JA4 fingerprints during the cryptographic TLS handshake by inspecting the Client Hello message (cipher suites, TLS extensions, and elliptic curve parameters) before the application-layer HTTP request reaches the web server.

3. HTTP/2 Frame Sequence Entropy: Real web browsers send standardized HTTP/2 SETTINGS, WINDOW_UPDATE, and PRIORITY frames. Default automation libraries emit non-standard frame sequences that trigger immediate IP blacklisting.

4. Hardware Subsystem Emulation Deficits: Modern client-side bot detection scripts evaluate Canvas 2D render entropy, WebGL vendor strings (Google SwiftShader vs ANGLE Direct3D), AudioContext oscillator phase shifts, and WebRTC local ICE candidates.

To achieve production survivability across high-volume pipelines, engineering teams deploy a decoupled evasion architecture.

flowchart TD
    subgraph Ingestion["Ingestion & Workflow Orchestration"]
        Orchestrator["Task Orchestrator (Temporal / BullMQ / Celery)"]
        Queue["Priority Job Queue"]
        Orchestrator --> Queue
    end

    subgraph BrowserFleet["Anti-Detect Execution Fleet"]
        Queue --> Worker1["Browser Worker 01<br/>Patchright Runtime"]
        Queue --> Worker2["Browser Worker 02<br/>Patchright Runtime"]
        
        Worker1 --> CDP1["CDP Stealth Masking<br/>Navigator / WebGL / Canvas"]
        Worker2 --> CDP2["CDP Stealth Masking<br/>Navigator / WebGL / Canvas"]
    end

    subgraph NetworkProxy["Network & Proxy Layer"]
        CDP1 --> ProxyRouter["Smart Proxy Rotator<br/>Sticky Residential Sessions"]
        CDP2 --> ProxyRouter
        
        ProxyRouter --> Pool1["Residential ASN Pool US-East"]
        ProxyRouter --> Pool2["Residential ASN Pool EU-West"]
    end

    subgraph TargetSecurity["Target Edge Gateway Architecture"]
        Pool1 --> Edge["Edge Gateway (Cloudflare / DataDome / Akamai)"]
        Pool2 --> Edge
        
        Edge -->|Session Verification Required| Fallback["Session Refresh & Backoff Router<br/>IP Rotation & Re-Authentication"]
        Fallback --> ProxyRouter
        Edge -->|200 OK Authorized Stream| TargetWeb["Target Web Property"]
    end

Implementing Evasion Guardrails in Production

• Runtime Patching with Patchright: In enterprise environments, replace standard Playwright packages with patchright (available for both TypeScript and Python). Patchright patches the internal Chromium C++ source code to eliminate CDP runtime artifacts, normalize navigator.plugins, and prevent Runtime.enable detection.
• Sticky Residential IP Rotation: Distribute scraping workers across mobile and residential proxy networks with ASN diversification. When automating multi-step user workflows or Stagehand sessions, assign sticky IP sessions (10 to 30-minute lifetimes) to prevent session termination caused by mid-flow IP hopping.
• Browser Profile Persistence: Save and restore encrypted browser session state (userDataDir, cookies, localStorage, IndexedDB). In authorized data pipelines with legitimate access credentials, reusing authenticated session state avoids repeated login handshakes and preserves consistent session state across automated tasks.

For organizations scaling automated data extraction across thousands of heterogeneous enterprise applications, implementing specialized enterprise AI solutions ensures that proxy rotation, rate-limiting, and validation fallbacks operate under strict service-level agreements.

---

Production Decision Framework: Architectural Selection Matrix

Evaluating whether to standardize your enterprise extraction infrastructure on Stagehand, Browser Use, or a hybrid configuration depends on task predictability, language ecosystem, and latency requirements.

+----------------------------------------------------------------------------------------------------+
|                                    DECISION SELECTION MATRIX                                       |
+------------------------------------+--------------------------+------------------------------------+
| Engineering Metric / Requirement   | Recommended Architecture | Architectural Justification        |
+------------------------------------+--------------------------+------------------------------------+
| High-Volume Structured Scraping    | Stagehand                | Single-call schema extraction      |
| (Continuous Batch Extraction)      |                          | against pruned AXTree minimizes    |
|                                    |                          | token overhead compared to loops.  |
|                                    |                          |                                    |
| Unknown / Dynamic Multi-Page Paths | Browser Use              | Autonomous cognitive loop handles  |
| (Exploratory Market Research)      |                          | unmapped navigation structures.    |
|                                    |                          |                                    |
| Strict SLA & Low-Latency Demands   | Stagehand                | Single-turn execution minimizes    |
| (Fast Response Time Budgets)       |                          | end-to-end processing delays.      |
|                                    |                          |                                    |
| Python Data Science / ML Pipeline  | Browser Use              | Direct interoperability with       |
| (Pandas, Polars, PyTorch, Ray)     |                          | Python data ecosystems.            |
|                                    |                          |                                    |
| TypeScript / Serverless Backend    | Stagehand                | Native Node.js runtime, zero       |
| (Next.js, NestJS, AWS Lambda)      |                          | Python sub-process overhead.       |
|                                    |                          |                                    |
| Canvas / Non-Standard Visual UIs   | Browser Use              | Multimodal vision-grounding        |
| (Figma-like apps, Canvas UIs)      |                          | operates on visual screenshots.    |
+------------------------------------+--------------------------+------------------------------------+

The Hybrid Enterprise Pattern

The most robust enterprise automation pipelines combine both tools into a two-tier architecture:

1. Discovery Tier (Browser Use): An autonomous Browser Use agent explores target domains, identifies deep search interfaces, bypasses novel navigation modals, and maps out canonical URL endpoints.

2. Extraction Tier (Stagehand): High-throughput worker fleets receive canonical URLs from the discovery tier and execute deterministic, schema-validated extraction at high volume and low token cost.

---

Frequently Asked Questions

Can Stagehand and Browser Use be combined within the same pipeline?

Yes. Enterprise architectures frequently deploy a hybrid model. A Python-based Browser Use agent acts as an exploratory worker that navigates dynamic, unmapped web portals to discover deep data locations. Once the navigation sequence and target URLs are indexed, high-throughput Node.js Stagehand workers execute high-volume data extraction using deterministic Zod schemas.

How do you prevent non-deterministic infinite loops in Browser Use?

To prevent runaway LLM costs and infinite navigation cycles in Browser Use, configure strict operational guardrails: set max_steps (typically between 8 and 15), define explicit failure conditions within system instructions, implement duplicate state detection to abort if the agent repeats the exact action sequence twice, and establish timeout thresholds on BrowserContextConfig.

What is the primary cause of bot detection in headless AI automation?

The primary failure vector is CDP (Chrome DevTools Protocol) detection combined with TLS Client Hello fingerprinting. Headless browser automation libraries expose navigator.webdriver = true and exhibit distinct event-loop timing anomalies. Production systems must utilize stealth patches (such as Patchright) alongside residential proxy pools matching target geographic regions.

How do both frameworks handle deeply nested Shadow DOM elements?

Stagehand handles Shadow DOM elements effectively by default because it queries the Chrome Accessibility Tree (AXTree), which flattens shadow roots into a continuous semantic accessibility hierarchy. Browser Use relies on injected JavaScript that must be configured to recursively traverse element.shadowRoot containers; otherwise, interactable nodes within closed shadow trees may be missed.

---

Sources

• Browserbase Stagehand Documentation & Framework Repository
• Browser Use: Open-Source Web Automation Agent Repository
• Microsoft Playwright Architecture and Protocol Guide
• Chrome DevTools Protocol (CDP) Accessibility Domain Specifications
• W3C Accessible Rich Internet Applications (WAI-ARIA) 1.2 Specification