Building Browser-Using AI Agents in Python

A new tutorial teaches developers how to build AI agents that browse and interact with real websites using Playwright, browser-use, and LangGraph, addressing the gap where most tasks lack APIs. The global AI agents market is projected to reach $50.31 billion by 2030, with browser-capable agents driving growth as 27.7% of enterprises already use agentic browsers in production.

In this article, you will learn how to build AI agents that can browse and interact with real websites using Playwright, browser-use, and LangGraph. Topics we will cover include: - Why Playwright is the right foundation for browser automation in 2026, and how it differs from Selenium. - How to scrape dynamic, JavaScript-rendered pages and complete multi-step forms reliably. - How to wire browser actions into LangGraph and browser-use agents, handle anti-bot detection, manage waiting and session persistence, and deploy the result in Docker. Introduction Most AI agent tutorials start with an API. They show you how to call OpenWeather, hit the Stripe endpoint, pull data from GitHub. That is a fine starting point until you try to build something real and realize that the task you actually need done does not have an API. Think about what humans do with browsers every day: filing government forms, reading competitor pricing, extracting research from sites that guard their data behind JavaScript rendering, logging into portals that have never heard of OAuth. There are roughly 1.1 billion websites on the internet. A vanishingly small fraction of them have public APIs. The rest only speak browser. An agent that is limited to API calls handles maybe 5% of the tasks a human worker does daily. Give that agent a browser, and the coverage approaches everything. That is the gap this article closes. The global AI agents market https://www.ringly.io/blog/ai-agent-statistics-2026 stands at \$10.91 billion in 2026 and is projected to reach \$50.31 billion by 2030, with browser-capable agents at the center of that growth. 27.7% of enterprises https://velofill.com/articles/agentic-ai-browsers-2026-market-landscape/ are already running agentic browsers in production, up from virtually none two years prior. The tooling has matured fast, and the patterns are settled enough to teach properly. By the end of this article, you will have a working browser agent that navigates real websites, fills forms, extracts structured data, and connects to an LLM that decides what to do next, all in Python. Why Playwright, Not Selenium If you built browser automation five years ago, you built it with Selenium. Selenium is still widely deployed, still works, and is not going anywhere. But for any new project in 2026, Playwright is the default. The reasons are practical, not theoretical. Selenium communicates with the browser by sending individual HTTP requests to a WebDriver. Every action, click, type, scroll, is a separate request. Playwright uses a persistent WebSocket connection for the entire session. Commands flow through that channel with no per-action round-trip cost. Independent benchmarks consistently show Playwright running 30-50% faster than Selenium at the test-suite level and averaging ~290ms per action versus Selenium’s ~536ms. For a browser agent that might execute hundreds of actions, that gap compounds. Playwright also bundles its own browser binaries. When you install it, you get pre-configured versions of Chromium, Firefox, and WebKit that are guaranteed to work with your Playwright version. No driver version mismatches, no broken CI pipelines because someone updated Chrome. It has built-in auto-waiting before it clicks an element; it verifies the element is visible, enabled, and not animating. You do not have to write time.sleep 2 and hope for the best. For AI agents specifically, Playwright fires real mouse and keyboard events that mirror how humans interact with browsers. Sites designed to detect automation look for synthetic DOM clicks. Playwright’s interaction model is harder to distinguish from genuine human input. There is also the browser-use library, which sits one level higher. Browser-use is a Python library that gives an LLM a working browser. Under the hood, it uses Playwright to drive the browser, but the LLM reads the page state and decides what to click, type, and extract, no CSS selectors required. You give it a task in plain English, and it figures out the rest. We will cover both raw Playwright and browser-use in this article, because they serve different needs: Playwright when you want precise, predictable control; browser-use when you want the agent to handle navigation decisions autonomously. Setting Up the Environment You need Python 3.10 or higher, an OpenAI API key, and about five minutes. Step 1: Create a virtual environment python -m venv browser agent env macOS / Linux source browser agent env/bin/activate Windows browser agent env\Scripts\activate 1234567 python -m venv browser agent env macOS / Linuxsource browser agent env/bin/activate Windowsbrowser agent env\Scripts\activate Step 2: Install dependencies pip install playwright \ browser-use \ langchain \ langchain-openai \ langgraph \ langchain-community \ python-dotenv 1234567 pip install playwright \ browser-use \ langchain \ langchain-openai \ langgraph \ langchain-community \ python-dotenv Step 3: Install the browser binaries This is the step most people miss. Playwright needs to download Chromium, Firefox, and WebKit separately from the Python package. Run this once after installing: playwright install chromium 1 playwright install chromium If you want all three browser engines: playwright install . Chromium alone is sufficient for most agent work and is smaller to download. Step 4: Store your API key Create a .env file in your project directory: OPENAI API KEY=your openai api key here 1 OPENAI API KEY=your openai api key here Add .env to your .gitignore immediately. Do not commit API keys. Step 5: Verify everything works Here is a first script that navigates to a URL, reads the heading, and saves a screenshot. Use example.com http://example.com , a publicly available test domain maintained by IANA that will not block you. How to run: Save as first run.py and run python first run.py first run.py Navigate to a URL, take a screenshot, and extract the page title. Prerequisites: pip install playwright && playwright install chromium How to run: python first run.py import asyncio from playwright.async api import async playwright async def main : async with async playwright as p: Launch Chromium in headless mode no visible browser window . Set headless=False if you want to watch it run during development. browser = await p.chromium.launch headless=True A browser context is like a fresh browser profile. It isolates cookies, storage, and cache from other contexts. context = await browser.new context viewport={"width": 1280, "height": 720}, user agent= "Mozilla/5.0 Windows NT 10.0; Win64; x64 " "AppleWebKit/537.36 KHTML, like Gecko " "Chrome/120.0.0.0 Safari/537.36" page = await context.new page Navigate to the URL and wait until the network is idle. "networkidle" means no open network connections for 500ms. For faster pages, "domcontentloaded" is sufficient. await page.goto "https://example.com", wait until="networkidle" Extract the page title title = await page.title print f"Page title: {title}" Extract the text content of the h1 heading h1 = await page.text content "h1" print f"H1 heading: {h1}" Take a full-page screenshot and save it to disk await page.screenshot path="screenshot.png", full page=True print "Screenshot saved to screenshot.png" await browser.close asyncio.run main 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647 first run.py Navigate to a URL, take a screenshot, and extract the page title. Prerequisites: pip install playwright && playwright install chromium How to run: python first run.py import asynciofrom playwright.async api import async playwright async def main : async with async playwright as p: Launch Chromium in headless mode no visible browser window . Set headless=False if you want to watch it run during development. browser = await p.chromium.launch headless=True A browser context is like a fresh browser profile. It isolates cookies, storage, and cache from other contexts. context = await browser.new context viewport={"width": 1280, "height": 720}, user agent= "Mozilla/5.0 Windows NT 10.0; Win64; x64 " "AppleWebKit/537.36 KHTML, like Gecko " "Chrome/120.0.0.0 Safari/537.36" page = await context.new page Navigate to the URL and wait until the network is idle. "networkidle" means no open network connections for 500ms. For faster pages, "domcontentloaded" is sufficient. await page.goto "https://example.com", wait until="networkidle" Extract the page title title = await page.title print f"Page title: {title}" Extract the text content of the h1 heading h1 = await page.text content "h1" print f"H1 heading: {h1}" Take a full-page screenshot and save it to disk await page.screenshot path="screenshot.png", full page=True print "Screenshot saved to screenshot.png" await browser.close asyncio.run main What this does: async playwright is the entry point for the entire Playwright session. The browser context is equivalent to opening a fresh incognito window; cookies, local storage, and cache are isolated from everything else. wait until=”networkidle” tells Playwright to wait until the page has finished all its network activity before your code continues, which is the safest wait strategy for dynamic pages. If this runs and saves a screenshot, your environment is working correctly. Web Navigation and Scraping The reason you need Playwright instead of requests + BeautifulSoup is JavaScript rendering. Modern websites deliver a skeleton of HTML and then build the actual content dynamically after the page loads: React, Vue, Angular, Next.js. A plain HTTP request fetches the skeleton. Playwright runs a real browser, so it sees exactly what a human sees after all JavaScript has executed. The target below is books.toscrape.com http://books.toscrape.com/ , a legal scraping sandbox built for practice. It paginates results, uses dynamic class names for ratings, and closely mirrors the structure of real e-commerce product pages. How to run: Save as scrape books.py and run python scrape books.py scrape books.py Scrape book titles, prices, and ratings from books.toscrape.com This is a legal scraping sandbox site built for practice. Prerequisites: pip install playwright && playwright install chromium How to run: python scrape books.py import asyncio import json from playwright.async api import async playwright async def scrape books max pages: int = 3 - list dict : """ Scrape book listings from books.toscrape.com across multiple pages. Returns a list of dicts with title, price, rating, and page number. """ results = async with async playwright as p: browser = await p.chromium.launch headless=True context = await browser.new context viewport={"width": 1280, "height": 720} page = await context.new page for page num in range 1, max pages + 1 : url = f"https://books.toscrape.com/catalogue/page-{page num}.html" print f"Scraping page {page num}: {url}" await page.goto url, wait until="domcontentloaded" Wait for the product cards to be visible before extracting. This is critical on JavaScript-heavy pages where content loads after the HTML. timeout=10000 means wait up to 10 seconds before raising an error. await page.wait for selector "article.product pod", timeout=10000 Get all book cards on the current page books = await page.query selector all "article.product pod" for book in books: Extract title from the <a tag's title attribute title el = await book.query selector "h3 a" title = await title el.get attribute "title" if title el else "N/A" Extract price text price el = await book.query selector ".price color" price = await price el.inner text if price el else "N/A" Extract star rating from the CSS class name. e.g. <p class="star-rating Three" → "Three" rating el = await book.query selector "p.star-rating" rating class = await rating el.get attribute "class" if rating el else "" rating = rating class.replace "star-rating", "" .strip results.append { "title": title, "price": price, "rating": rating, "page": page num } print f" Extracted {len books } books from page {page num}" await browser.close return results async def main : books = await scrape books max pages=2 print f"\nTotal books scraped: {len books }" print json.dumps books :3 , indent=2 asyncio.run main 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172 scrape books.py Scrape book titles, prices, and ratings from books.toscrape.com This is a legal scraping sandbox site built for practice. Prerequisites: pip install playwright && playwright install chromium How to run: python scrape books.py import asyncioimport jsonfrom playwright.async api import async playwright async def scrape books max pages: int = 3 - list dict : """ Scrape book listings from books.toscrape.com across multiple pages. Returns a list of dicts with title, price, rating, and page number. """ results = async with async playwright as p: browser = await p.chromium.launch headless=True context = await browser.new context viewport={"width": 1280, "height": 720} page = await context.new page for page num in range 1, max pages + 1 : url = f"https://books.toscrape.com/catalogue/page-{page num}.html" print f"Scraping page {page num}: {url}" await page.goto url, wait until="domcontentloaded" Wait for the product cards to be visible before extracting. This is critical on JavaScript-heavy pages where content loads after the HTML. timeout=10000 means wait up to 10 seconds before raising an error. await page.wait for selector "article.product pod", timeout=10000 Get all book cards on the current page books = await page.query selector all "article.product pod" for book in books: Extract title from the <a tag's title attribute title el = await book.query selector "h3 a" title = await title el.get attribute "title" if title el else "N/A" Extract price text price el = await book.query selector ".price color" price = await price el.inner text if price el else "N/A" Extract star rating from the CSS class name. e.g. <p class="star-rating Three" → "Three" rating el = await book.query selector "p.star-rating" rating class = await rating el.get attribute "class" if rating el else "" rating = rating class.replace "star-rating", "" .strip results.append { "title": title, "price": price, "rating": rating, "page": page num } print f" Extracted {len books } books from page {page num}" await browser.close return results async def main : books = await scrape books max pages=2 print f"\nTotal books scraped: {len books }" print json.dumps books :3 , indent=2 asyncio.run main What this does: wait for selector is the key call here. Instead of sleeping for a fixed time and hoping the content has loaded, it watches the DOM and proceeds the moment the target element appears, or raises a TimeoutError if it does not appear within the timeout window. That is the right behavior: fail fast and explicitly rather than silently extracting from an empty page. The rating extraction deserves attention. The star rating is encoded as a CSS class star-rating Three , not a number. The code strips “star-rating” from the class string to get the text value. This is the kind of thing you only know by inspecting the actual HTML. When you hand this task to a raw LLM with no browser, it has no way to know what the class structure looks like. With Playwright, you can inspect it directly and extract it exactly. Form Completion and Multi-Step Flows Filling forms is where browser agents earn their keep and where most automation scripts fail. The reason is that web forms are not just inputs and buttons. They fire focus, input, change , and blur events in sequence. JavaScript validation listens for those events. If you inject a value into an input field by directly setting value in the DOM as older automation tools often do , the validation listeners never fire and the form breaks. Playwright’s fill and click methods fire real browser events in the right order, which is why they work on form validation that would block lower-level approaches. The target below is the-internet.herokuapp.com/login http://the-internet.herokuapp.com/login , a public test site maintained specifically for automation practice. It accepts tomsmith / SuperSecretPassword as valid credentials and returns clear success/failure messages. How to run: Save as form submit.py and run python form submit.py form submit.py Complete and submit a multi-field login form on a public demo site. Target: https://the-internet.herokuapp.com/login public test site Prerequisites: pip install playwright && playwright install chromium How to run: python form submit.py import asyncio from playwright.async api import async playwright async def login and verify username: str, password: str - dict: """ Attempt to log in to a demo site and return whether it succeeded. Handles: input filling, button clicking, and result verification. """ async with async playwright as p: browser = await p.chromium.launch headless=True context = await browser.new context page = await context.new page await page.goto "https://the-internet.herokuapp.com/login" Wait for the form to be visible before interacting. state="visible" is the default but makes the intent explicit. await page.wait for selector " username", state="visible" fill clears the field first, then types the value. It fires the focus, input, and change events in order. await page.fill " username", username await page.fill " password", password click fires real mouse events -- mousedown, mouseup, click. This triggers JavaScript listeners that a plain DOM click misses. await page.click "button type='submit' " Wait for the page to settle after form submission await page.wait for load state "networkidle" Check which result element appeared success el = await page.query selector ".flash.success" error el = await page.query selector ".flash.error" if success el: message = await success el.inner text result = {"success": True, "message": message.strip } elif error el: message = await error el.inner text result = {"success": False, "message": message.strip } else: result = {"success": False, "message": "Unknown result"} await browser.close return result async def main : Valid credentials for the demo site result = await login and verify "tomsmith", "SuperSecretPassword " print f"Valid login: {result}" Invalid credentials to verify error handling result fail = await login and verify "wronguser", "wrongpass" print f"Invalid login: {result fail}" asyncio.run main 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465 form submit.py Complete and submit a multi-field login form on a public demo site. Target: https://the-internet.herokuapp.com/login public test site Prerequisites: pip install playwright && playwright install chromium How to run: python form submit.py import asynciofrom playwright.async api import async playwright async def login and verify username: str, password: str - dict: """ Attempt to log in to a demo site and return whether it succeeded. Handles: input filling, button clicking, and result verification. """ async with async playwright as p: browser = await p.chromium.launch headless=True context = await browser.new context page = await context.new page await page.goto "https://the-internet.herokuapp.com/login" Wait for the form to be visible before interacting. state="visible" is the default but makes the intent explicit. await page.wait for selector " username", state="visible" fill clears the field first, then types the value. It fires the focus, input, and change events in order. await page.fill " username", username await page.fill " password", password click fires real mouse events -- mousedown, mouseup, click. This triggers JavaScript listeners that a plain DOM click misses. await page.click "button type='submit' " Wait for the page to settle after form submission await page.wait for load state "networkidle" Check which result element appeared success el = await page.query selector ".flash.success" error el = await page.query selector ".flash.error" if success el: message = await success el.inner text result = {"success": True, "message": message.strip } elif error el: message = await error el.inner text result = {"success": False, "message": message.strip } else: result = {"success": False, "message": "Unknown result"} await browser.close return result async def main : Valid credentials for the demo site result = await login and verify "tomsmith", "SuperSecretPassword " print f"Valid login: {result}" Invalid credentials to verify error handling result fail = await login and verify "wronguser", "wrongpass" print f"Invalid login: {result fail}" asyncio.run main What this does: The pattern here, fill → click → wait for load state → check for result element, is the template for almost any form interaction. The wait for load state “networkidle” after the submit is important: without it, you query the DOM before the page has updated and get the pre-submission state, not the result. For more complex forms with file uploads, dropdowns, and checkboxes: File upload await page.set input files " file-upload", "/path/to/document.pdf" Select dropdown by visible label text await page.select option " country-select", label="Nigeria" Check a checkbox await page.check " agree-terms" Handle a modal dialog confirm/alert page.on "dialog", lambda dialog: asyncio.ensure future dialog.accept 1234567891011 File uploadawait page.set input files " file-upload", "/path/to/document.pdf" Select dropdown by visible label textawait page.select option " country-select", label="Nigeria" Check a checkboxawait page.check " agree-terms" Handle a modal dialog confirm/alert page.on "dialog", lambda dialog: asyncio.ensure future dialog.accept Tool Orchestration with LangChain and LangGraph Raw Playwright scripts are powerful but fixed. They do exactly what you coded, no more. The moment a page changes its structure, or the task requires a decision the script did not anticipate, it breaks. Connecting Playwright to an LLM changes this. Browser actions become tools the agent can call when it decides they are needed. The agent reads the task, reasons about what to do, calls a tool, reads the result, and decides what to do next. That loop handles variation that a fixed script cannot. This is the bridge from “browser automation script” to “ AI agent .” How to run: Save as agent tools.py , ensure OPENAI API KEY is in your .env , then run python agent tools.py agent tools.py LangGraph agent with three browser tools: navigate and extract, fill and submit form, take screenshot Prerequisites: pip install playwright langchain langchain-openai langgraph python-dotenv playwright install chromium How to run: python agent tools.py import asyncio import os from dotenv import load dotenv from langchain openai import ChatOpenAI from langchain.tools import tool from langchain core.messages import HumanMessage from langgraph.prebuilt import create react agent from playwright.async api import async playwright load dotenv ── SHARED BROWSER STATE ────────────────────────────────────────────────────── We keep a single browser instance alive for the agent's lifetime. Creating and destroying a browser on every tool call is slow and wasteful. browser = None page = None playwright = None async def get page : """Return the shared page, launching the browser if needed.""" global browser, page, playwright if browser is None: playwright = await async playwright .start browser = await playwright.chromium.launch headless=True context = await browser.new context viewport={"width": 1280, "height": 720} page = await context.new page return page async def close browser : """Clean up browser resources when the agent session ends.""" global browser, page, playwright if browser: await browser.close await playwright.stop browser = None page = None playwright = None ── BROWSER TOOLS ───────────────────────────────────────────────────────────── Note: these are async tools async def . LangChain's @tool decorator supports async functions directly, and the agent must be invoked with ainvoke so that tool calls run on the same event loop instead of trying to start a second one. @tool async def navigate and extract url: str - str: """ Navigate to a URL and return the visible text content of the page. Use this to visit websites and read their content. Input: a full URL string including https:// e.g., 'https://example.com' . """ page = await get page await page.goto url, wait until="domcontentloaded", timeout=15000 await page.wait for load state "networkidle" content = await page.inner text "body" Truncate to avoid flooding the LLM context window return content :3000 if len content 3000 else content @tool async def fill and submit form selector value pairs: str - str: """ Fill form fields and submit a form on the currently loaded page. Input: a comma-separated string of 'selector:value' pairs ending with 'submit:button selector'. Example: ' email:user@example.com, password:secret,submit:button type=submit ' """ page = await get page try: pairs = selector value pairs.split "," submit selector = None for pair in pairs: key, val = pair.split ":", 1 key = key.strip val = val.strip if key == "submit": submit selector = val else: await page.fill key, val if submit selector: await page.click submit selector await page.wait for load state "networkidle" return f"Form submitted. Current URL: {page.url}" except Exception as e: return f"Form interaction failed: {str e }" @tool async def take screenshot filename: str - str: """ Take a screenshot of the current browser page and save it to a file. Use this to visually verify the current state of the page. Input: filename string e.g., 'result.png' . """ page = await get page await page.screenshot path=filename, full page=False return f"Screenshot saved to {filename}" ── AGENT SETUP ─────────────────────────────────────────────────────────────── llm = ChatOpenAI model="gpt-4o", temperature=0, api key=os.getenv "OPENAI API KEY" tools = navigate and extract, fill and submit form, take screenshot create react agent wires together the LLM, the tools, and the ReAct reasoning loop. The agent decides which tool to call, calls it, reads the result, and continues. agent = create react agent llm, tools ── DEMO ────────────────────────────────────────────────────────────────────── async def main : result = await agent.ainvoke { "messages": HumanMessage content= "Go to https://example.com, read the page content, " "then take a screenshot called example.png" } print result "messages" -1 .content await close browser asyncio.run main 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139 agent tools.py LangGraph agent with three browser tools: navigate and extract, fill and submit form, take screenshot Prerequisites: pip install playwright langchain langchain-openai langgraph python-dotenv playwright install chromium How to run: python agent tools.py import asyncioimport osfrom dotenv import load dotenvfrom langchain openai import ChatOpenAIfrom langchain.tools import toolfrom langchain core.messages import HumanMessagefrom langgraph.prebuilt import create react agentfrom playwright.async api import async playwright load dotenv ── SHARED BROWSER STATE ────────────────────────────────────────────────────── We keep a single browser instance alive for the agent's lifetime. Creating and destroying a browser on every tool call is slow and wasteful. browser = None page = None playwright = None async def get page : """Return the shared page, launching the browser if needed.""" global browser, page, playwright if browser is None: playwright = await async playwright .start browser = await playwright.chromium.launch headless=True context = await browser.new context viewport={"width": 1280, "height": 720} page = await context.new page return page async def close browser : """Clean up browser resources when the agent session ends.""" global browser, page, playwright if browser: await browser.close await playwright.stop browser = None page = None playwright = None ── BROWSER TOOLS ───────────────────────────────────────────────────────────── Note: these are async tools async def . LangChain's @tool decorator supports async functions directly, and the agent must be invoked with ainvoke so that tool calls run on the same event loop instead of trying to start a second one. @toolasync def navigate and extract url: str - str: """ Navigate to a URL and return the visible text content of the page. Use this to visit websites and read their content. Input: a full URL string including https:// e.g., 'https://example.com' . """ page = await get page await page.goto url, wait until="domcontentloaded", timeout=15000 await page.wait for load state "networkidle" content = await page.inner text "body" Truncate to avoid flooding the LLM context window return content :3000 if len content 3000 else content @toolasync def fill and submit form selector value pairs: str - str: """ Fill form fields and submit a form on the currently loaded page. Input: a comma-separated string of 'selector:value' pairs ending with 'submit:button selector'. Example: ' email:user@example.com, password:secret,submit:button type=submit ' """ page = await get page try: pairs = selector value pairs.split "," submit selector = None for pair in pairs: key, val = pair.split ":", 1 key = key.strip val = val.strip if key == "submit": submit selector = val else: await page.fill key, val if submit selector: await page.click submit selector await page.wait for load state "networkidle" return f"Form submitted. Current URL: {page.url}" except Exception as e: return f"Form interaction failed: {str e }" @toolasync def take screenshot filename: str - str: """ Take a screenshot of the current browser page and save it to a file. Use this to visually verify the current state of the page. Input: filename string e.g., 'result.png' . """ page = await get page await page.screenshot path=filename, full page=False return f"Screenshot saved to {filename}" ── AGENT SETUP ─────────────────────────────────────────────────────────────── llm = ChatOpenAI model="gpt-4o", temperature=0, api key=os.getenv "OPENAI API KEY" tools = navigate and extract, fill and submit form, take screenshot create react agent wires together the LLM, the tools, and the ReAct reasoning loop. The agent decides which tool to call, calls it, reads the result, and continues.agent = create react agent llm, tools ── DEMO ────────────────────────────────────────────────────────────────────── async def main : result = await agent.ainvoke { "messages": HumanMessage content= "Go to https://example.com, read the page content, " "then take a screenshot called example.png" } print result "messages" -1 .content await close browser asyncio.run main What this does: The three @tool -decorated functions are registered with the agent. Each docstring is what the LLM reads to understand what the tool does and when to use it. Write them like job descriptions, not code comments. The shared browser and page globals mean the browser stays open across multiple tool calls, which is essential for tasks that span several pages in the same session. Because the tools are defined with async def , the agent is invoked with ainvoke rather than invoke , so the tool calls run on the same event loop that main is already using. The key design decision in this snippet is the shared browser instance. If each tool call launched and closed its own browser, you would lose all session state between calls, such as cookies, navigation history, and any form state the agent had already built up. Keeping the browser alive for the full agent session preserves that context. Using browser-use for High-Level Agent Tasks Raw Playwright with @tool functions gives you precise control. The trade-off is that you are still writing selectors, still thinking about page structure, still handling every edge case manually. If the site changes its HTML, your selectors break. browser-use https://github.com/browser-use/browser-use takes a different approach. Instead of writing selectors, you give the agent a task in plain English. browser-use uses Playwright under the hood, but the LLM reads the current page state on each step and decides what to do next: which element to click, what to type, and when the task is complete. The page structure is not hardcoded into your code. The agent figures it out at runtime. browser-use is a Python library that gives an LLM a working browser. The LLM reads each page and decides what to click, type, and extract. This makes it resilient to site changes that would break a selector-based script. When to use browser-use over raw Playwright: - If the task is exploratory and the page structure is unpredictable, use browser-use . - If you are running a fixed, repeatable workflow where every selector is known and stable, raw Playwright is more reliable and cheaper per run. - A browser-use agent makes multiple LLM calls per task step; a scripted Playwright run makes none. How to run : Save as browser use agent.py , ensure OPENAI API KEY is in your .env , then run python browser use agent.py browser use agent.py A browser-use agent that accepts a natural language task and completes it without any CSS selectors or hardcoded page structure. Prerequisites: pip install browser-use playwright python-dotenv playwright install chromium How to run: python browser use agent.py import asyncio import os from dotenv import load dotenv from langchain openai import ChatOpenAI from browser use import Agent load dotenv async def run browser task task: str - str: """ Hand a natural language task to a browser-use agent. The agent handles navigation, clicks, and extraction without selectors. """ temperature=0 keeps decisions deterministic and reduces hallucinated actions llm = ChatOpenAI model="gpt-4o", temperature=0, api key=os.getenv "OPENAI API KEY" Agent wraps the browser, the LLM, and the task loop together. max actions per step limits how many actions the agent takes before re-reading the page -- prevents runaway loops on complex pages. agent = Agent task=task, llm=llm, max actions per step=5 run executes the full task loop: read page → decide action → take action → read updated page → repeat result = await agent.run final result returns the agent's extracted content or conclusion return result.final result or "Task completed with no extracted output." async def main : task = "Go to https://books.toscrape.com and find the 3 most expensive books " "on the first page. Return their titles and prices." print f"Task: {task}\n" output = await run browser task task print f"Result:\n{output}" asyncio.run main 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455 browser use agent.py A browser-use agent that accepts a natural language task and completes it without any CSS selectors or hardcoded page structure. Prerequisites: pip install browser-use playwright python-dotenv playwright install chromium How to run: python browser use agent.py import asyncioimport osfrom dotenv import load dotenvfrom langchain openai import ChatOpenAIfrom browser use import Agent load dotenv async def run browser task task: str - str: """ Hand a natural language task to a browser-use agent. The agent handles navigation, clicks, and extraction without selectors. """ temperature=0 keeps decisions deterministic and reduces hallucinated actions llm = ChatOpenAI model="gpt-4o", temperature=0, api key=os.getenv "OPENAI API KEY" Agent wraps the browser, the LLM, and the task loop together. max actions per step limits how many actions the agent takes before re-reading the page -- prevents runaway loops on complex pages. agent = Agent task=task, llm=llm, max actions per step=5 run executes the full task loop: read page → decide action → take action → read updated page → repeat result = await agent.run final result returns the agent's extracted content or conclusion return result.final result or "Task completed with no extracted output." async def main : task = "Go to https://books.toscrape.com and find the 3 most expensive books " "on the first page. Return their titles and prices." print f"Task: {task}\n" output = await run browser task task print f"Result:\n{output}" asyncio.run main What this does : The entire task, navigating to the site, reading the page, identifying the three highest prices, and extracting them, is handled by the agent without a single CSS selector in your code. If books.toscrape.com redesigns its price display tomorrow, the script still works. With a selector-based scraper, it would break silently. The max actions per step=5 parameter is worth explaining. On each step, the agent reads the page and can decide to take up to five actions click, type, scroll, navigate before re-reading the page. Keeping this low forces the agent to check its work more frequently, which catches mistakes earlier. Handling the Hard Parts Three things break most browser agents in production. Each has a solution, but none of them is obvious until you have already been burned. 1. Anti-Bot Detection Websites that do not want to be automated detect automation in several ways, such as checking the navigator.webdriver property which Playwright sets to true by default , looking for headless browser fingerprints in the JavaScript environment, and analyzing interaction patterns that are too fast or too uniform to be human. The most important mitigation is removing the webdriver flag. Beyond that, a realistic user agent string, a standard viewport size, and a realistic locale and timezone cover most detection methods short of sophisticated fingerprint analysis. hard parts.py -- Part 1: Anti-bot stealth launch Prerequisites: pip install playwright && playwright install chromium How to run: python hard parts.py import asyncio import json from pathlib import Path from playwright.async api import async playwright async def launch stealth browser playwright : """ Launch a browser context that looks more like a real human session. Covers: realistic viewport, user-agent, locale, timezone, webdriver flag. Note: For serious anti-bot targets, consider a paid service like Browserbase. """ browser = await playwright.chromium.launch headless=True, args= "--disable-blink-features=AutomationControlled", Hides webdriver detection "--no-sandbox", "--disable-dev-shm-usage", context = await browser.new context viewport={"width": 1366, "height": 768}, Common desktop resolution user agent= "Mozilla/5.0 Windows NT 10.0; Win64; x64 " "AppleWebKit/537.36 KHTML, like Gecko " "Chrome/124.0.0.0 Safari/537.36" , locale="en-US", timezone id="America/New York", java script enabled=True, Remove the 'webdriver' property that Playwright injects by default. Bot detection systems check for this in the browser's JS environment. await context.add init script "Object.defineProperty navigator, 'webdriver', {get: = undefined} " return browser, context 12345678910111213141516171819202122232425262728293031323334353637383940414243 hard parts.py -- Part 1: Anti-bot stealth launch Prerequisites: pip install playwright && playwright install chromium How to run: python hard parts.py import asyncioimport jsonfrom pathlib import Pathfrom playwright.async api import async playwright async def launch stealth browser playwright : """ Launch a browser context that looks more like a real human session. Covers: realistic viewport, user-agent, locale, timezone, webdriver flag. Note: For serious anti-bot targets, consider a paid service like Browserbase. """ browser = await playwright.chromium.launch headless=True, args= "--disable-blink-features=AutomationControlled", Hides webdriver detection "--no-sandbox", "--disable-dev-shm-usage", context = await browser.new context viewport={"width": 1366, "height": 768}, Common desktop resolution user agent= "Mozilla/5.0 Windows NT 10.0; Win64; x64 " "AppleWebKit/537.36 KHTML, like Gecko " "Chrome/124.0.0.0 Safari/537.36" , locale="en-US", timezone id="America/New York", java script enabled=True, Remove the 'webdriver' property that Playwright injects by default. Bot detection systems check for this in the browser's JS environment. await context.add init script "Object.defineProperty navigator, 'webdriver', {get: = undefined} " return browser, context What this does : The add init script call runs before any page JavaScript executes, which means the navigator.webdriver override is in place before the site’s detection code can check for it. The –disable-blink-features=AutomationControlled launch argument removes a separate automation flag at the browser engine level. Together, these two changes handle the most common detection methods. For sites with aggressive fingerprinting and CAPTCHA systems, these mitigations will not be enough. Services like Browserbase https://www.browserbase.com/ , Spidra http://www.spidra.io and Brightdata’s Scraping Browser https://brightdata.com/products/scraping-browser handle CAPTCHA solving, residential IP rotation, and browser fingerprint management as managed infrastructure. 2. Smart Waiting The second failure mode is timing. The reflex is to add time.sleep calls and increase them when things break. This is wrong in both directions: too short on slow connections, too long on fast ones, and completely opaque when debugging. Playwright has four proper wait strategies. Use the one that matches what you are actually waiting for: Part 2: Smart waiting strategies add to your scraper or agent tools async def smart wait examples page : """ Four ways to wait for the right page state, without arbitrary sleeps. """ STRATEGY 1: Wait for a specific element to appear in the DOM Use when you know exactly what element signals content has loaded await page.wait for selector ".product-list", state="visible", timeout=10000 STRATEGY 2: Wait for a specific API response Use when the content comes from an XHR/fetch call you can identify async with page.expect response lambda r: "/api/products" in r.url and r.status == 200 as response info: await page.click " load-more" response = await response info.value print f"API responded: {response.status}" STRATEGY 3: Wait for the URL to change after form submission Use when a successful submit redirects to a new page await page.wait for url " /dashboard ", timeout=10000 STRATEGY 4: Wait for a JavaScript variable to be set Use when no visual element reliably signals the ready state await page.wait for function " = window. dataLoaded === true", timeout=10000 1234567891011121314151617181920212223242526272829 Part 2: Smart waiting strategies add to your scraper or agent tools async def smart wait examples page : """ Four ways to wait for the right page state, without arbitrary sleeps. """ STRATEGY 1: Wait for a specific element to appear in the DOM Use when you know exactly what element signals content has loaded await page.wait for selector ".product-list", state="visible", timeout=10000 STRATEGY 2: Wait for a specific API response Use when the content comes from an XHR/fetch call you can identify async with page.expect response lambda r: "/api/products" in r.url and r.status == 200 as response info: await page.click " load-more" response = await response info.value print f"API responded: {response.status}" STRATEGY 3: Wait for the URL to change after form submission Use when a successful submit redirects to a new page await page.wait for url " /dashboard ", timeout=10000 STRATEGY 4: Wait for a JavaScript variable to be set Use when no visual element reliably signals the ready state await page.wait for function " = window. dataLoaded === true", timeout=10000 What this does: Each strategy is tied to a specific observable event rather than an arbitrary time delay. wait for selector watches the DOM. expect response hooks into the network layer. wait for url monitors navigation. wait for function evaluates JavaScript in the browser context. Use whichever one most directly signals “the thing I need is now ready.” 3. Session and Cookie Persistence The third failure mode is losing session state. If your agent logs into a site during step one and then the browser context is destroyed, step two has no authentication. Recreating the login on every run is slow and can trigger rate limiting or lockout. The solution is saving cookies to disk after login and loading them at the start of every subsequent run: Part 3: Session persistence across runs COOKIES FILE = Path "session cookies.json" async def save session context - None: """Save browser cookies to disk after a successful login.""" cookies = await context.cookies COOKIES FILE.write text json.dumps cookies, indent=2 print f"Session saved: {len cookies } cookies written." async def load session context - bool: """Load saved cookies before navigating. Returns True if session was found.""" if not COOKIES FILE.exists : print "No saved session. Fresh login required." return False cookies = json.loads COOKIES FILE.read text await context.add cookies cookies print f"Session restored: {len cookies } cookies loaded." return True 1234567891011121314151617181920 Part 3: Session persistence across runs COOKIES FILE = Path "session cookies.json" async def save session context - None: """Save browser cookies to disk after a successful login.""" cookies = await context.cookies COOKIES FILE.write text json.dumps cookies, indent=2 print f"Session saved: {len cookies } cookies written." async def load session context - bool: """Load saved cookies before navigating. Returns True if session was found.""" if not COOKIES FILE.exists : print "No saved session. Fresh login required." return False cookies = json.loads COOKIES FILE.read text await context.add cookies cookies print f"Session restored: {len cookies } cookies loaded." return True What this does: context.cookies returns all cookies for the current browser context, including session tokens and authentication cookies. Writing them to JSON and reloading them on the next run means the browser starts in an authenticated state. Note that sessions expire; add a check that falls back to a fresh login if the saved session returns a redirect to the login page. Deploying Browser Agents Getting a browser agent working locally is one thing. Running it reliably in a cloud environment is another. The main difference between a Python script that works on your laptop and one that fails in CI is system dependencies. Playwright’s Chromium browser requires a set of shared libraries that are present on most developer machines but absent from minimal cloud images. The cleanest solution is Docker. Dockerfile — build a container that ships everything Playwright needs: Dockerfile for headless Playwright-based browser agent Build: docker build -t browser-agent . Run: docker run --rm -e OPENAI API KEY=your key browser-agent FROM python:3.11-slim Install system dependencies required by Chromium RUN apt-get update && apt-get install -y \ libnss3 libatk1.0-0 libatk-bridge2.0-0 libcups2 \ libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 \ libxrandr2 libgbm1 libasound2 libpangocairo-1.0-0 \ libpango-1.0-0 libcairo2 libx11-6 libxext6 libxfixes3 \ fonts-liberation wget ca-certificates \ && rm -rf /var/lib/apt/lists/ WORKDIR /app Install Python dependencies first cached layer -- only rebuilds on requirements change COPY requirements.txt . RUN pip install --no-cache-dir -r requirements.txt Install Playwright browser binaries into the image RUN playwright install chromium RUN playwright install-deps chromium Copy application code last changes here don't invalidate the pip/playwright layers COPY . . CMD "python", "agent tools.py" requirements.txt: playwright browser-use langchain langchain-openai langgraph python-dotenv 12345678910111213141516171819202122232425262728293031323334353637 Dockerfile for headless Playwright-based browser agent Build: docker build -t browser-agent . Run: docker run --rm -e OPENAI API KEY=your key browser-agent FROM python:3.11-slim Install system dependencies required by ChromiumRUN apt-get update && apt-get install -y \ libnss3 libatk1.0-0 libatk-bridge2.0-0 libcups2 \ libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 \ libxrandr2 libgbm1 libasound2 libpangocairo-1.0-0 \ libpango-1.0-0 libcairo2 libx11-6 libxext6 libxfixes3 \ fonts-liberation wget ca-certificates \ && rm -rf /var/lib/apt/lists/ WORKDIR /app Install Python dependencies first cached layer -- only rebuilds on requirements change COPY requirements.txt .RUN pip install --no-cache-dir -r requirements.txt Install Playwright browser binaries into the imageRUN playwright install chromiumRUN playwright install-deps chromium Copy application code last changes here don't invalidate the pip/playwright layers COPY . . CMD "python", "agent tools.py" requirements.txt:playwrightbrowser-uselangchainlangchain-openailanggraphpython-dotenv For concurrent workloads running multiple browser sessions in parallel, use Playwright’s async API with asyncio.gather : Parallel scraping with semaphore rate limiting Runs up to 3 browser sessions simultaneously import asyncio from playwright.async api import async playwright async def scrape url browser, url: str, semaphore: asyncio.Semaphore - dict: """Scrape a single URL, respecting the concurrency semaphore.""" async with semaphore: context = await browser.new context page = await context.new page await page.goto url, wait until="domcontentloaded" title = await page.title await context.close Close context not browser to release resources return {"url": url, "title": title} async def scrape parallel urls: list str , max concurrent: int = 3 - list dict : """Scrape a list of URLs in parallel, capped at max concurrent sessions.""" semaphore = asyncio.Semaphore max concurrent Cap concurrent sessions async with async playwright as p: One browser shared across all contexts -- much cheaper than one browser per URL browser = await p.chromium.launch headless=True tasks = scrape url browser, url, semaphore for url in urls results = await asyncio.gather tasks await browser.close return list results 1234567891011121314151617181920212223242526272829 Parallel scraping with semaphore rate limiting Runs up to 3 browser sessions simultaneously import asynciofrom playwright.async api import async playwright async def scrape url browser, url: str, semaphore: asyncio.Semaphore - dict: """Scrape a single URL, respecting the concurrency semaphore.""" async with semaphore: context = await browser.new context page = await context.new page await page.goto url, wait until="domcontentloaded" title = await page.title await context.close Close context not browser to release resources return {"url": url, "title": title} async def scrape parallel urls: list str , max concurrent: int = 3 - list dict : """Scrape a list of URLs in parallel, capped at max concurrent sessions.""" semaphore = asyncio.Semaphore max concurrent Cap concurrent sessions async with async playwright as p: One browser shared across all contexts -- much cheaper than one browser per URL browser = await p.chromium.launch headless=True tasks = scrape url browser, url, semaphore for url in urls results = await asyncio.gather tasks await browser.close return list results What this does : The asyncio.Semaphore max concurrent caps how many browser contexts run at the same time. Without it, launching 50 concurrent browser contexts will exhaust memory. One browser process is shared across all contexts; a context is cheap; a full browser instance is not. On the managed infrastructure side, Amazon Nova Act https://aws.amazon.com/nova/act/ launched in March 2025 as a dedicated SDK for building browser agents on AWS, integrating natively with Playwright for browser control. Playwright’s own MCP server https://playwright.dev/python/ gives AI assistants full browser control through the Model Context Protocol, using structured accessibility snapshots rather than screenshots, which means token costs stay low while the agent’s understanding of the page stays high. Putting It All Together Here is a complete end-to-end agent that takes a research question, navigates to a public data source, extracts structured results, and returns a clean summary. It uses the browser tools from Section 5 orchestrated by a LangGraph agent. How to run: Save as reference agent.py , ensure OPENAI API KEY is in your .env , and run python reference agent.py reference agent.py Full browser-using AI agent: navigates, extracts, summarizes. Target: books.toscrape.com public scraping sandbox Prerequisites: pip install playwright langchain langchain-openai langgraph python-dotenv playwright install chromium How to run: python reference agent.py import asyncio import os from dotenv import load dotenv from langchain openai import ChatOpenAI from langchain.tools import tool from langchain core.messages import HumanMessage, SystemMessage from langgraph.prebuilt import create react agent from playwright.async api import async playwright load dotenv ── BROWSER STATE ───────────────────────────────────────────────────────────── browser = None context = None page = None playwright = None async def get page : global browser, context, page, playwright if browser is None: playwright = await async playwright .start browser = await playwright.chromium.launch headless=True context = await browser.new context viewport={"width": 1280, "height": 720}, user agent= "Mozilla/5.0 Windows NT 10.0; Win64; x64 " "AppleWebKit/537.36 KHTML, like Gecko " "Chrome/120.0.0.0 Safari/537.36" Remove webdriver fingerprint await context.add init script "Object.defineProperty navigator, 'webdriver', {get: = undefined} " page = await context.new page return page async def teardown : global browser, playwright if browser: await browser.close await playwright.stop browser = None playwright = None ── TOOLS ───────────────────────────────────────────────────────────────────── @tool async def navigate url: str - str: """ Navigate the browser to a URL and return the page's text content. Use when you need to open a website or move to a new page. Input: full URL with https:// prefix. """ page = await get page await page.goto url, wait until="domcontentloaded", timeout=20000 await page.wait for load state "networkidle" content = await page.inner text "body" return content :4000 @tool async def extract structured css selector: str - str: """ Extract text from all elements matching a CSS selector on the current page. Use when you need to pull specific elements from the loaded page. Input: valid CSS selector string e.g., 'h3 a', '.price color', 'article.product pod' . """ page = await get page try: await page.wait for selector css selector, timeout=5000 elements = await page.query selector all css selector texts = for el in elements :20 : Cap at 20 elements to keep output manageable text = await el.inner text texts.append text.strip return "\n".join texts if texts else "No elements found." except Exception as e: return f"Extraction failed: {str e }" @tool async def get current url - str: """Return the URL the browser is currently on. No input required.""" page = await get page return page.url ── AGENT ───────────────────────────────────────────────────────────────────── llm = ChatOpenAI model="gpt-4o", temperature=0, api key=os.getenv "OPENAI API KEY" tools = navigate, extract structured, get current url agent = create react agent llm, tools SYSTEM = "You are a browser-based research agent. You have access to a real browser. " "Use navigate to open pages, extract structured to pull specific elements, " "and get current url to check where you are. " "Always navigate first, then extract. Be concise in your final answer." async def run agent query: str - str: result = await agent.ainvoke { "messages": SystemMessage content=SYSTEM , HumanMessage content=query } await teardown return result "messages" -1 .content ── DEMO ────────────────────────────────────────────────────────────────────── if name == " main ": query = "Go to https://books.toscrape.com and extract the titles and prices " "of the first 5 books listed. Return them as a structured list." print f"Query: {query}\n" answer = asyncio.run run agent query print f"Answer:\n{answer}" 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137 reference agent.py Full browser-using AI agent: navigates, extracts, summarizes. Target: books.toscrape.com public scraping sandbox Prerequisites: pip install playwright langchain langchain-openai langgraph python-dotenv playwright install chromium How to run: python reference agent.py import asyncioimport osfrom dotenv import load dotenvfrom langchain openai import ChatOpenAIfrom langchain.tools import toolfrom langchain core.messages import HumanMessage, SystemMessagefrom langgraph.prebuilt import create react agentfrom playwright.async api import async playwright load dotenv ── BROWSER STATE ───────────────────────────────────────────────────────────── browser = None context = None page = None playwright = None async def get page : global browser, context, page, playwright if browser is None: playwright = await async playwright .start browser = await playwright.chromium.launch headless=True context = await browser.new context viewport={"width": 1280, "height": 720}, user agent= "Mozilla/5.0 Windows NT 10.0; Win64; x64 " "AppleWebKit/537.36 KHTML, like Gecko " "Chrome/120.0.0.0 Safari/537.36" Remove webdriver fingerprint await context.add init script "Object.defineProperty navigator, 'webdriver', {get: = undefined} " page = await context.new page return page async def teardown : global browser, playwright if browser: await browser.close await playwright.stop browser = None playwright = None ── TOOLS ───────────────────────────────────────────────────────────────────── @toolasync def navigate url: str - str: """ Navigate the browser to a URL and return the page's text content. Use when you need to open a website or move to a new page. Input: full URL with https:// prefix. """ page = await get page await page.goto url, wait until="domcontentloaded", timeout=20000 await page.wait for load state "networkidle" content = await page.inner text "body" return content :4000 @toolasync def extract structured css selector: str - str: """ Extract text from all elements matching a CSS selector on the current page. Use when you need to pull specific elements from the loaded page. Input: valid CSS selector string e.g., 'h3 a', '.price color', 'article.product pod' . """ page = await get page try: await page.wait for selector css selector, timeout=5000 elements = await page.query selector all css selector texts = for el in elements :20 : Cap at 20 elements to keep output manageable text = await el.inner text texts.append text.strip return "\n".join texts if texts else "No elements found." except Exception as e: return f"Extraction failed: {str e }" @toolasync def get current url - str: """Return the URL the browser is currently on. No input required.""" page = await get page return page.url ── AGENT ───────────────────────────────────────────────────────────────────── llm = ChatOpenAI model="gpt-4o", temperature=0, api key=os.getenv "OPENAI API KEY" tools = navigate, extract structured, get current url agent = create react agent llm, tools SYSTEM = "You are a browser-based research agent. You have access to a real browser. " "Use navigate to open pages, extract structured to pull specific elements, " "and get current url to check where you are. " "Always navigate first, then extract. Be concise in your final answer." async def run agent query: str - str: result = await agent.ainvoke { "messages": SystemMessage content=SYSTEM , HumanMessage content=query } await teardown return result "messages" -1 .content ── DEMO ────────────────────────────────────────────────────────────────────── if name == " main ": query = "Go to https://books.toscrape.com and extract the titles and prices " "of the first 5 books listed. Return them as a structured list." print f"Query: {query}\n" answer = asyncio.run run agent query print f"Answer:\n{answer}" What this does: This agent has three clean tools: navigate, extract structured , and get current url , plus a system prompt that tells it exactly when to use each one. The agent calls navigate to load the page, extract structured to pull the book titles and prices by CSS selector, and synthesizes a structured list in the final answer. The teardown call after the agent finishes closes the browser cleanly so no zombie Chromium processes are left running. Conclusion The browser is not a specialized tool for automation engineers. It is the universal interface for the web, and the web is where most of the world’s actual work gets done. An AI agent that can use a browser does not need a partner team maintaining API integrations. It can reach anything a human can reach. What makes this practical now, not just theoretically interesting, is the maturity of the tooling. Playwright handles the hard parts of browser interaction. browser-use removes the need to write selectors for exploratory tasks. LangGraph gives the LLM clean tool hooks and a reasoning loop that handles variable page structures. The patterns in this article are not demos. They are the same patterns 51% of enterprises now running AI agents in production are building on. Start with the scraping example. Get it running against a site you actually need data from. Add the agent layer when you need decisions the script cannot anticipate. Add browser-use when the page structure is too dynamic for selectors. Deploy in Docker when you need it running somewhere other than your laptop. The hard part is not the code. It is knowing which tool to reach for at each layer. Hopefully this article made that clearer.