Notte is a full-stack web AI agent framework and browser automation SDK. The implementation is a multi-package Python monorepo: notte-core provides shared domain models, actions, error hierarchies, telemetry, and configuration; notte-browser implements Playwright/Patchright browser control, DOM snapshotting, scraping pipelines, and form-filling heuristics; notte-agent contains the LLM-driven agent loop, deterministic fallback, and workflow execution; notte-llm wraps LiteLLM with structured completions, retries, and a file-based prompt library; notte-sdk is the client for the hosted Notte cloud API with remote sessions, agents, vaults, personas, and serverless functions; notte-integrations adds notifiers and third-party CDP session providers. Primary entry points are `NotteClient` for cloud usage, `NotteSession` for local browser automation, and `Agent`/`AgentFallback` for autonomous and hybrid scripted-agent workflows.
Ui.Vision is a browser extension for Robotic Process Automation (RPA) that provides web and desktop automation capabilities. It features a React/Redux UI with Ant Design, supporting both table-based macros (Selenium IDE compatible) and JavaScript script macros. The extension includes computer vision for image-based automation, OCR functionality, AI-assisted macro creation, and desktop automation through native XModules. It implements a storage abstraction layer supporting browser and file system modes, backup/restore functionality, and an MCP bridge for external AI agent control. The architecture follows web extension patterns with background scripts, content scripts, and a rich UI layer, communicating via IPC mechanisms.
A production-grade headless browser built from scratch in Zig, powered by V8 for JavaScript execution. It implements a vast subset of Web Platform APIs (DOM, CSSOM, HTML/SVG elements, canvas, WebGL, IndexedDB, workers, fetch, WebSocket, etc.) and exposes them through Chrome DevTools Protocol (CDP), WebDriver BiDi, and MCP (Model Context Protocol) servers. Includes a built-in LLM agent mode for natural-language-driven automation, a scripting system (PandaScript) for deterministic replay, and a full network stack with ad blocking, rate limiting, caching, and TLS. Designed for AI agents and automation workloads, it claims significant performance advantages over Chromium in startup time and resource usage. Architecturally, the browser is a monolithic server binary with distinct internal modules: a browser core managing pages, frames, and V8 isolates; a network layer using libcurl with connection pooling and request deduplication; protocol servers (CDP, BiDi, MCP) communicating over WebSocket or HTTP; and an agent subsystem that wraps LLM APIs for task planning and execution. The codebase is heavily tested with hundreds of hand-written HTML conformance tests and runs Web Platform Tests via CI. The engineering demonstrates high craftsmanship: custom arena allocators with V8 memory accounting, compile-time prototype hierarchy reflection for Web IDL bindings, a GCRA rate limiter, a singleflight pattern for request deduplication, and a generic live-collection iterator. While some APIs are stubbed or partially implemented (e.g., WebGL always returns null, video dimensions are hardcoded), the core functionality is extensive and spec-compliant where implemented. The project is actively maintained with nightly orderfile optimizations and regular CI.
MagenticLite (Magentic-UI 2.0) is a full-stack, open-source agentic application from Microsoft AI Frontiers that pairs an orchestrator agent (MagenticBrain / OmniAgent) with a browser-use sub-agent (Fara) to automate web research, form filling, file management, and code execution in real time. The architecture comprises a Python/FastAPI backend with WebSocket-based streaming, a React/TypeScript frontend (Vite, Tailwind, Zustand, TanStack Query), and a Quicksand VM sandbox for isolated browser and code execution. The system is designed for local-first, single-user operation with a CLI entry point (`magentic-ui`) and optional Docker-based deployment. The application emphasizes human-in-the-loop control: approval policies for bash and file commands, pause/resume, mid-run user interjection, browser takeover mode, and folder-mount consent dialogs. It supports two agent roles (orchestrator and web surfer) with configurable endpoint providers and max-round caps. The frontend offers session management, chat view with rich message rendering (CUA browser actions, code execution, file preview, reasoning traces), and a real-time browser viewer via VNC. The codebase demonstrates strong engineering practices: a sandbox abstraction with host/guest path translation, secure token-based authentication, host-header allowlisting, path traversal validation, and a modular tool registry. It includes extensive unit and integration tests covering agent state persistence, compaction, command classification, and sandbox lifecycle. Despite being labeled a research prototype (v0.2.2, alpha), the repository shows active maintenance, clean architecture, and several reusable patterns that could be extracted into independent projects.
HeadlessX is a self-hosted web scraping and browser automation platform with anti-detection capabilities. It provides a Next.js 16 dashboard, an Express 5 API with Prisma/PostgreSQL, a BullMQ queue worker, and a published CLI. The core value proposition is anti-detection scraping via the headfox-js package (Camoufox-compatible Firefox bundles), fingerprint generation, CAPTCHA solving, and LLM-friendly markdown output. The system supports multiple operators: website scraping/crawling/mapping, Google AI Search, Tavily search, Exa search, and YouTube extraction. It includes sidecar services for HTML-to-Markdown (Go) and YouTube extraction (Python FastAPI). The architecture is a monorepo with Nx orchestration, Docker Compose deployment, and an MCP endpoint for AI assistant integration. External dependencies include Redis, Postgres, Playwright, MaxMind GeoIP, and external APIs (Tavily, Exa, Google). The codebase is well-structured with clear separation of concerns, modern TypeScript, and reusable patterns in both frontend and backend.
The OpenCode Browser plugin provides browser automation capabilities through direct connections to the Chrome DevTools Protocol (CDP). It exposes a set of tools (browser_list, browser_navigate, browser_snapshot, browser_click, browser_fill, browser_eval, browser_screenshot) that allow an AI agent to control a browser by specifying the browser's debugging endpoint (browser_url) and optionally a target ID. The plugin consists of three main parts: the plugin interface (src/plugin.ts), a lightweight CDP client over WebSocket (src/lib/cdp.ts), and accessibility tree snapshot utilities with unique element IDs for interaction (src/lib/snapshot.ts). The CDP client handles connection, message exchange, and event handling, while the snapshot utility processes the accessibility tree to generate a tree of nodes with stable UIDs for use in click and fill operations.
google-images-download is a Python application for searching and downloading images from Google Images. It functions as both a command-line tool and a library that can be imported into other Python scripts. The system uses Selenium with Chrome to handle JavaScript-heavy Google Images pages, automatically manages chromedriver via webdriver-manager, and supports extensive filtering options (size, color, format, usage rights, etc.). Key features include filename sanitization for cross-platform compatibility, metadata extraction, similar image search, and robust error handling for network issues. The architecture is monolithic with a clear separation between argument parsing, URL building, browser automation, and download execution.
Helium is a Python library that provides a higher-level, more intuitive API for browser automation, built on top of Selenium. It simplifies common web automation tasks such as clicking buttons, filling forms, handling alerts, switching windows, and dragging elements by allowing developers to reference page elements by their visible labels rather than low-level CSS selectors or XPath expressions. Under the hood, Helium translates each high-level command into Selenium calls, managing implicit waits, iframe traversal, and window focus automatically. The library is designed for both interactive use (e.g., testing) and scripting (e.g., web scraping), and it seamlessly integrates with raw Selenium for advanced use cases. The architecture follows a layered pattern: a public API module (`helium/__init__.py`) exposes functions and GUI element classes; an implementation layer (`helium/_impl/__init__.py`) contains the core logic including element location via XPath construction, frame iteration, and error handling; and utility modules provide geometry, string, and system helpers. The codebase is well-organized with clear separation between API and implementation, though the main implementation file is large and tightly coupled. The library is actively used (over 8,300 stars) and though maintenance is low-effort, it remains functional with recent Selenium compatibility.
This repository provides a stealth browser automation MCP (Model Context Protocol) server that offers undetectable control over real browser instances (Chrome, Chromium, Edge) via the Chrome DevTools Protocol (CDP) and the `nodriver` library. It exposes 97 tools across 11 sections including navigation, DOM interaction, element extraction (styles, structure, events, animations), network interception and modification (including dynamic Python-powered hooks), CDP command execution, cookie management, tab control, and proxy forwarding with authentication. The architecture is a FastMCP-based server with singleton managers for browser instances, network interception, element cloning, and process cleanup. It supports stdio and HTTP transports, Docker deployment, and optional bearer auth. The system is designed to bypass anti-bot detection (Cloudflare, CreepJS, login walls) and is used for scraping, testing, and AI agent automation. While the codebase is well-structured and the functionality is comprehensive, there is some code duplication across multiple element cloner implementations and technical drift risk due to tight coupling with CDP APIs and the `py2js` transpiler dependency.
Local Browser is a Chrome extension that enables on-device AI-powered web automation using WebLLM. The system implements a two-agent architecture (Planner + Navigator) where users enter natural language tasks in the popup UI, which are then executed through a loop of DOM observation, action planning, and browser interaction. All AI processing occurs locally on the device with no cloud APIs or API keys required. The extension features site-specific state machines for common tasks like Amazon shopping and YouTube navigation (minimizing LLM calls), obstacle detection for login requirements/CAPTCHAs/out-of-stock items, and robust action execution with retry logic and semantic selectors. Built with React, TypeScript, Vite, and CRXJS for MV3 Chrome extension architecture.
Bluebox is a library and agent framework for reverse engineering web applications by monitoring browser interactions via Chrome DevTools Protocol (CDP). It captures network requests, DOM snapshots, storage changes, and user interactions into JSONL files, then uses LLM-driven agents to discover reusable automation routines (parameterized workflows) that can navigate, fetch, click, type, and extract structured data from live websites. The system includes a conversational agent (BlueBoxAgent) that searches a routine index and falls back to an AI browser agent, a GuideAgent for interactive routine creation, and a PrincipalInvestigator orchestrator that runs parallel specialist agents (network, DOM, storage, UI) to build routine catalogs from captured sessions. Architecturally, Bluebox is a modular Python application with clear separation: CDP monitors and session management, Pydantic data models for routines and events, abstract base classes for agents and data loaders, LLM vendor clients (OpenAI, Anthropic), a workspace abstraction for artifact management, and CLI/HTTP entry points. The SDK provides high-level methods (monitor_browser, discover_routine, execute_routine) and the package ships with example routines for real-world sites (Amtrak, Polymarket, Massachusetts corporate search). While primarily an application/library, Bluebox has a strong data pipeline character: it ingests raw CDP events, transforms them through data loaders and vectorstores, and produces structured routine definitions. The benchmark framework evaluates routine quality with deterministic and LLM-based tests. The codebase demonstrates high craftsmanship with reusable patterns (agent tool decorator, workspace abstraction, sandboxed execution, data loader interface) and extensive unit tests, though some specialist agents are marked as beta and the orchestration pipeline is complex.
This repository is a TypeScript monorepo for an AI-powered autonomous web browsing agent called 'open-browser'. It consists of three packages: core library (open-browser), CLI (@open-browser/cli), and sandbox (@open-browser/sandbox). The core library orchestrates an agent loop that uses Playwright to control a Chromium browser, extracts DOM state via CDP, sends it to an LLM (OpenAI, Anthropic, Google) which decides actions in structured JSON, and executes those actions via a CommandExecutor. The system supports vision screenshots, extended thinking, compact mode, planning, evaluation, replay recording, and MCP server integration. The CLI provides commands for running agents, interactive sessions, and direct browser manipulation. The sandbox provides resource-limited execution. Key entry points include the Agent class, Viewport browser session, CommandExecutor, and BridgeServer. External dependencies include Playwright, Vercel AI SDK, Zod, Turndown, and various LLM provider SDKs. The architecture follows a modular monorepo with clear separation of concerns, event-driven communication via EventHub, and a guard/watchdog pattern for browser lifecycle management. The codebase demonstrates strong engineering practices with extensive use of Zod schemas for structured outputs, a command catalog pattern, and comprehensive telemetry and cost tracking.