# Browser Automation Tools for Web Agent Execution: Playwright, browser-use, and Python webbrowser

> Explore Playwright, browser-use, and Python webbrowser for efficient web agent execution. Discover the best tools for your AI agent projects.

- Repository: [Bojie Li/ai-agent-book](https://github.com/bojieli/ai-agent-book)
- Tags: deep-dive
- Published: 2026-07-31

---

**The bojieli/ai-agent-book repository implements web agent execution using Playwright for low-level Chromium automation, the browser-use library for LLM-friendly high-level interactions, and Python's standard webbrowser module for quick URL demonstrations.**

The bojieli/ai-agent-book repository demonstrates practical implementations of AI agents capable of navigating and interacting with web interfaces. Understanding what browser automation tools are used for web agent execution reveals a layered architecture designed for both robust automation and rapid prototyping. The codebase strategically combines low-level browser drivers with high-level abstraction libraries to enable agents to navigate pages, extract content, and interact with dynamic web elements.

## Playwright as the Low-Level Chromium Driver

The foundation of browser automation relies on **Playwright**, configured to launch Chromium instances with extended permissions for audio input capabilities.

In [`chapter9/phone-agent/run_acceptance.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter9/phone-agent/run_acceptance.py) (line 283), the implementation calls `playwright.chromium.launch` with `headless=False` for debugging visibility and `--no-default-browser-check` arguments. The code creates a browser context with `permissions=["microphone"]` to support agents requiring audio stream access for speech-to-text processing.

This low-level control enables full page interaction, network monitoring, and media handling essential for complex web agent tasks.

## browser-use for High-Level Agent Abstraction

Building atop Playwright, the repository integrates the **browser-use** library to provide an LLM-friendly API that abstracts complex browser actions into structured function calls.

The file [`chapter8/gaia-experience/AWorld/examples/gaia/mcp_collections/tools/browser.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter8/gaia-experience/AWorld/examples/gaia/mcp_collections/tools/browser.py) (line 4) imports the `Agent` class from the `browser_use` package and implements the MCP (Multi-Client Protocol) service. This service exposes functions including `browser_navigate`, `browser_click`, and `browser_fill`, which return JSON-serializable results suitable for LLM reasoning workflows.

The `browser-use` wrapper handles session management through `BrowserProfile` configurations, managing download directories and user data persistence while the underlying `ChatOpenAI` model drives the agent's decision-making process.

## Python webbrowser for Demonstration Workflows

For lightweight demonstrations that do not require full automation, the repository utilizes **Python's standard `webbrowser` module**.

In [`chapter9/phone-agent/direct_call.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter9/phone-agent/direct_call.py) (line 9), the code invokes `webbrowser.open` within a delayed thread using `threading.Timer(0.8, ...)`. This approach opens the user's default browser after a brief pause, allowing terminal output to remain readable while demonstrating ReAct-style agent calls without the overhead of managing browser contexts.

## Integration Architecture

The three tools operate in distinct layers within the agent execution pipeline:

- **Playwright** provides the raw browser driver capabilities with hardware permission controls
- **browser-use** implements the MCP service that translates high-level agent intentions into Playwright commands
- **webbrowser** serves as a convenience utility for human-in-the-loop demonstrations

This architecture enables agents to navigate arbitrary URLs, extract page content, interact with forms, and capture microphone audio through a unified interface that routes tool calls to the appropriate automation backend.

## Implementation Examples

The following code snippets illustrate how each browser automation tool is implemented in the repository:

```python

# Example 1 – Launch a Chromium browser with Playwright (used in acceptance tests)

from playwright.sync_api import sync_playwright

def launch_browser():
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,               # show UI for debugging

            args=["--no-default-browser-check"],
        )
        context = browser.new_context(permissions=["microphone"])
        page = context.new_page()
        page.goto("https://example.com")
        # … interact with the page …

        browser.close()

```

```python

# Example 2 – High‑level browser‑use call (used by the LLM‑driven agent)

from browser_use import Agent, BrowserProfile
from browser_use.llm import ChatOpenAI

def make_browser_agent(task: str):
    profile = BrowserProfile()                     # sets download dir, profile data, etc.

    llm = ChatOpenAI(model="gpt-4o-mini")          # LLM that drives the agent

    agent = Agent(
        task=task,
        llm=llm,
        browser_profile=profile,
        save_conversation_path="trace.log",
    )
    result = agent.run()                           # performs navigation, clicks, etc.

    return result

```

```python

# Example 3 – Quick URL launch with Python’s webbrowser (demo script)

import webbrowser
import threading

def open_demo(url: str):
    # Open the URL after a short delay so the terminal output is readable

    threading.Timer(0.8, lambda: webbrowser.open(url)).start()

```

## Summary

- **Playwright** serves as the low-level Chromium driver in [`chapter9/phone-agent/run_acceptance.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter9/phone-agent/run_acceptance.py), providing microphone permissions and full browser context control.
- **browser-use** offers a high-level abstraction layer in [`chapter8/gaia-experience/AWorld/examples/gaia/mcp_collections/tools/browser.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter8/gaia-experience/AWorld/examples/gaia/mcp_collections/tools/browser.py), exposing LLM-friendly functions like `browser_navigate` and `browser_click` through the MCP service.
- **Python webbrowser** enables rapid prototyping in [`chapter9/phone-agent/direct_call.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter9/phone-agent/direct_call.py) without requiring complex automation setup.
- The layered architecture separates browser driver logic from agent reasoning, allowing flexible execution from full automation to simple URL opening.

## Frequently Asked Questions

### What is the primary browser engine used for web agent execution in the repository?

The primary engine is **Chromium** launched through **Playwright**. According to the source code in [`chapter9/phone-agent/run_acceptance.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter9/phone-agent/run_acceptance.py) at line 283, the implementation specifically uses `playwright.chromium.launch` to create browser instances with custom permissions including microphone access for audio-enabled agents.

### How does the browser-use library differ from direct Playwright usage?

The **browser-use** library provides a higher-level abstraction that wraps Playwright functionality into LLM-friendly APIs. As implemented in [`chapter8/gaia-experience/AWorld/examples/gaia/mcp_collections/tools/browser.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter8/gaia-experience/AWorld/examples/gaia/mcp_collections/tools/browser.py), it exposes structured functions like `browser_navigate` and `browser_fill` that return JSON-serializable results, whereas raw Playwright requires manual handling of page contexts and element selectors.

### Why does the repository include Python's webbrowser module alongside Playwright?

Python's **webbrowser** module serves lightweight demonstration purposes where full browser automation is unnecessary. In [`chapter9/phone-agent/direct_call.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter9/phone-agent/direct_call.py) at line 9, `webbrowser.open` launches the default browser for quick URL demonstrations without the overhead of managing Chromium contexts, making it ideal for ReAct-style teaching examples and simple agent interactions.

### Where are browser permissions configured for audio capture?

Microphone permissions are configured in the Playwright browser context within [`chapter9/phone-agent/run_acceptance.py`](https://github.com/bojieli/ai-agent-book/blob/main/chapter9/phone-agent/run_acceptance.py). The code explicitly sets `permissions=["microphone"]` when creating the browser context, enabling agents to capture audio streams for downstream speech-to-text processing during phone-agent acceptance tests.