This post organizes open-source options for browser control into general browser automation libraries and wrappers/environments closer to Agent (LLM) browser operation, with scenario recommendations.
1) General, mature open-source browser automation libraries (common Agent foundations)
Playwright (recommended as an Agent foundation)
- Languages: Node.js / Python / Java / .NET
- Features: Cross-browser (Chromium/Firefox/WebKit); friendlier waiting and concurrency; strong locators (text/role/aria, etc.); supports trace, video, HAR.
- Agent-friendly points:
- Access to the DOM, screenshots (visual agents), and ARIA/role-based stable locators (more robust than pure CSS).
- Common uses: Web task automation, Agent tool calls, end-to-end flows.
- Languages: Nearly full coverage (Python/Java/C#/JS/…)
- Features: Based on the WebDriver standard; strong compatibility with various browsers and enterprise environments.
- Agent-friendly points: Mature with abundant documentation; but for modern SPAs, waiting/stability is usually less hassle-free than Playwright.
- Language: Node.js (community Python port exists, but Node is the mainline)
- Features: Chromium/Chrome first, via CDP; quick to get started.
- Agent-friendly points: Very direct Chrome control; but cross-browser capability is weaker than Playwright.
- Features: Rich plugins/ecosystem, suited to Node stacks; can connect to Selenium Grid, etc.
- Agent-friendly points: A good choice if your Agent runs in Node and you want to reuse WebDriver infrastructure.
- Features: Keyword-driven, suitable for wrapping browser operations into highly readable flows.
- Agent-friendly points: Agents generating/modifying keyword scripts is more controllable than writing code directly (depends on team preference).
- Positioning: Gives LLMs/Agents a wrapper that can "understand web pages and execute actions" (usually Playwright underneath).
- Advantages: Closer to the "let the model browse the web itself" usage (automatic page information extraction, executable action generation).
- Caveat: These projects iterate fast; stability / anti-bot resistance depends on the specific version and site.
- Positioning: Provide standardized environments/tasks/evaluation for "web task Agents" (usually with browser control scripts).
- Advantages: Great fit for Agent capability evaluation, training, benchmarks.
- Caveat: More research/environment oriented; not necessarily equivalent to production-grade RPA.
- Positioning: Wrap Playwright/Selenium as Tools (e.g. "navigate / click / extract") for Agent calls.
- Advantages: Quick to adopt if you already use these Agent frameworks; composable with other tools (search, databases, APIs, etc.).
- Caveat: Quality varies greatly across versions/components; many are still "thin wrappers", with core stability depending on Playwright/Selenium.
- chrome-remote-interface (Node)
- pychrome (Python)
- Note that Playwright/Puppeteer themselves heavily rely on CDP capabilities (generally no need to add your own layer).
- Want stable, general, easy concurrency: Prefer Playwright (then wrap it into your Agent's tool layer as needed).
- Existing Selenium infrastructure / strong enterprise browser compatibility requirements: Choose Selenium/WebDriver.
- Chrome-only, CDP route, Node stack: Choose Puppeteer or CDP directly.
- Want an out-of-the-box LLM browser Agent experience: Look at high-level wrappers like browser-use (but expect maintenance costs / site adaptation work).
Selenium (largest ecosystem)
Puppeteer
WebdriverIO (Node framework on WebDriver)
Robot Framework + SeleniumLibrary (RPA/test orchestration oriented)
2) Wrappers/environments closer to "Agent operating a browser" (higher-level action abstraction)
> These usually build on Playwright/Selenium and provide: higher-level actions (click/input/find element), page state extraction (DOM/accessibility tree/screenshot), and even tool interfaces prepared for LLMs.