This repository is a large monorepo for a multimodal AI agent platform developed by ByteDance. It includes a desktop Electron application (UI-TARS Desktop) that allows users to control their computer using natural language via vision-language models (UI-TARS, GPT-4o, Claude, etc.). Additionally, it provides a CLI tool (Agent TARS) for running agents in browser/desktop environments, a server for multi-user agent sessions, a web UI for interacting with agents, MCP servers for browser/filesystem/commands, and a comprehensive SDK for building custom agents and operators. The architecture is heavily componentized with multiple packages for agent core, tool-calling engines (native, prompt-engineering, structured-outputs), browser automation (local, remote, sandbox), desktop automation (NutJS, ADB), and UI components. While the codebase demonstrates strong engineering with clean abstractions (event streams, plugin systems, strategy patterns), it also shows signs of rapid growth with some duplication (two agent server implementations, overlapping operator packages) and ongoing migrations. The repository is actively maintained with frequent releases and comprehensive test coverage across unit, integration, and e2e tests.
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.
This is a comprehensive academic paper downloader application that retrieves PDFs from over 20 sources, including open access repositories (Unpaywall, OpenAlex, arXiv, EuropePMC), publisher APIs (Elsevier, Springer Nature TDM, Wiley), and institutional access channels (WebVPN, CARSI, EZProxy). It is distributed as a Python CLI tool (Typer), an MCP server (FastMCP) for AI agent integration, and a web UI, with support for batch processing, browser automation (Playwright/CloakBrowser), Tor, and FlareSolverr for anti-bot bypass. The architecture is centered on a multi-lane scheduling pipeline (publisher-specific, OA, grey sources, institutional) with tiered parallel racing, adaptive scoring, and negative caching. It includes publisher-specific PDF routing strategies for 19+ publishers, a registry pattern for extensibility, and a CookieStore for persistent session management. The application also provides citation export (BibTeX/RIS/Endnote), Zotero integration, and markdown conversion. While the primary character is a software application, it exhibits hybrid data-research traits through its extensive data source integration, metadata enrichment (Crossref, Semantic Scholar), and caching layer. The codebase is well-structured with clear modules but suffers from some code duplication (notably an institutional subpackage that mirrors core modules) and hardcoded paths, reducing maintainability. Overall, it is a sophisticated, production-ready tool that demonstrates advanced patterns in browser automation and anti-crawl techniques.
Stagehand is a Python SDK for the Stagehand API, an AI-driven browser automation framework. The SDK provides sync and async clients (`Stagehand`, `AsyncStagehand`) that interact with remote or local browser sessions via natural language commands like `observe`, `act`, `extract`, and `execute`. It supports both cloud-based (via REST API) and local execution modes, the latter using a compiled SEA binary managed by `SeaServerManager`. The codebase is primarily auto-generated by Stainless from an OpenAPI spec, with hand-written custom modules for session binding, binary management, and local server orchestration. The architecture follows a resource-based client pattern: the main client holds resource objects (e.g., `sessions`) that expose typed methods returning Pydantic models. Request parameters are defined as `TypedDict` subclasses with camelCase aliases, and responses are deserialized into strongly-typed models. The SDK includes comprehensive error handling (hierarchy of `APIError` subclasses), configurable retries and timeouts, SSE streaming support, and Pydantic v1/v2 compatibility. External dependencies include `httpx` for HTTP, `pydantic` for models, and optional `aiohttp`, `playwright`, or `pydoll` for advanced browser control. Key entry points are the `Stagehand` and `AsyncStagehand` classes, which can be instantiated with an API key and base URL. Sessions are started via `client.sessions.start()`, then methods like `session.act()`, `session.extract()`, `session.observe()`, and `session.execute()` perform browser automation tasks. The `_custom/session.py` module wraps the generated resource to provide a bound session object with page-aware frame handling. The SDK also ships a `_sea` binary for local execution, packaged via custom Hatch build hooks.
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.
This repository is a monorepo of 'skills' for the Minis AI assistant platform, designed to extend the assistant's capabilities with domain-specific workflows, API integrations, and automation scripts. Each skill is a self-contained directory with a SKILL.md (instruction set for the AI), executable scripts (Python/shell), reference documentation, and evaluation test cases. The skills cover a wide range of tasks: social media management (Weibo, Twitter/X, Xiaohongshu, Telegram, Bilibili), media processing (YouTube downloader, PDF conversion, TTS, image generation), financial data retrieval (US/Korea/China stocks, fund flows), productivity (Notion API, todoocard e-paper, whenpeak energy prediction), video composition (HyperFrames framework), and system utilities (Android dev environment, Cloudflare DNS, qBittorrent). The architecture is modular and agent-driven: the AI selects a skill based on user intent, reads its SKILL.md, and invokes the provided scripts via shell_execute. Output is typically JSON for machine consumption. The codebase demonstrates strong engineering practices with structured skill definitions, evaluation frameworks, and reusable patterns like cookie-based auth, SQLite message stores, and deterministic animation analysis. However, many skills depend on reverse-engineered or unofficial APIs, hardcoded paths tied to the Minis iOS environment, and external tools (ffmpeg, pandoc, typst), introducing maintenance and portability risks.
AgenticSeek is a private, local autonomous AI assistant built as an alternative to Manus AI. The system features a multi-agent architecture with six specialized agents (Casual, Coder, File, Browser, Planner, MCP) selected by a hybrid router using BART zero-shot classification and an adaptive few-shot classifier. It provides a React frontend, FastAPI backend with Celery, CLI with voice support, and Docker Compose orchestration for self-hosted services including SearxNG search and Redis caching. The codebase demonstrates solid engineering with clean abstractions for LLM providers (14+ options), tool execution, browser automation, and workspace isolation. It is under active development but shows signs of technical drift in deprecated components (llm_server, SerpApi-based web search) and fragile browser automation. The architecture is modular and contains several reusable patterns, though the codebase is tightly coupled to its specific agent system and has substantial external dependencies.
EasySpider is a visual, no-code web scraping tool that combines an Electron desktop application, a Chrome browser extension, and a Python execution engine. Users design scraping workflows via a flowchart-based UI (Vue.js) where they define steps like opening pages, clicking elements, extracting data, looping, and conditional branching. The task definitions are saved as JSON graphs. The Python backend (ExecuteStage) loads these graphs and drives Chrome using Selenium with an undetected-chromedriver fork to evade bot detection. Extracted data can be written to CSV, Excel, JSON, or MySQL. The tool also includes OCR support (ddddocr), custom JavaScript/Python execution, and Cloudflare bypass capabilities. The architecture is a hybrid desktop app with a local HTTP server (Express) that spawns executor processes and communicates via WebSocket. The Chrome extension assists in element selection and XPath generation. While the tool is functional and popular (44k+ stars), the codebase exhibits significant duplication (e.g., identical task files across platform directories, duplicated Bootstrap and content scripts), hardcoded paths, monolithic executor scripts, and mixed-language strings. Several experimental modules (LLM, federated learning) are present but not integrated. The project is actively maintained with recent commits and packaging scripts, but technical debt and drift (Bootstrap 4, Vue 2, pinned Python dependencies) are moderate.
Eko is a TypeScript framework for building production-ready AI agents that can automate workflows across browser, Node.js, and web extension environments. The core orchestration engine (Eko class) takes a natural language task, uses an LLM to generate a multi-agent workflow plan encoded as XML, then executes it with parallel/serial agent execution, replanning, and human-in-the-loop support. The system provides a clean abstraction over LLM providers (OpenAI, Anthropic, etc.) with retry and fallback, a ReAct tool-calling loop, and built-in browser automation agents that operate via screenshots or DOM labels. It also includes MCP client implementations (SSE, HTTP, stdio) for integrating external tools, and a chat agent for conversational interactions with tool delegation. The architecture is modular with separate npm packages: @eko-ai/eko-core (core engine), @eko-ai/eko-nodejs (Playwright-based browser agent), @eko-ai/eko-extension (Chrome extension agent), and @eko-ai/eko-web (web environment agent). The repository includes working examples (Chrome extension with side panel, Node.js automation using Playwright, and a React web app). The framework is designed for developers who want to automate complex, multi-step tasks using language models, with a focus on reliability, human oversight, and extensibility via custom agents and tools.
Botright is a Python library built on Playwright that provides advanced browser automation with stealth features to evade bot detection. It includes proxy management, fingerprint spoofing using real browser profiles (chrome-fingerprints), human-like mouse movements, and CAPTCHA solving for hCaptcha, reCAPTCHA, and Geetest (though Geetest support is currently disabled). The library wraps Playwright's API with a custom layer that intercepts browser events, modifies user agent, platform, and other fingerprinting vectors, and injects anti-detection scripts. It supports both headless and headed modes, proxy rotation, and response caching. The codebase is well-structured but has commented-out modules indicating incomplete transitions (e.g., Geetest).
Wirebrowser is an Electron desktop application that provides an integrated runtime instrumentation platform for web applications, built entirely on the Chrome DevTools Protocol (CDP). In production, it acts as a unified debugger, memory inspector, network interceptor, and automation runner for JavaScript running in Chromium-based browsers. The application launches a headless or headful Chrome instance via Puppeteer-core, attaches CDP debuggers to multiple pages, and presents a rich GUI (React, Ant Design, Monaco Editor, AG Grid) through an Electron window. The architecture follows a modular event-driven design: core back-end modules (Heap, Debugger, Network, Automation) are loaded by a ModuleManager and communicate with the front-end via custom DOM events and Electron IPC. The debugger module implements a sophisticated hook system that injects user-defined JavaScript callbacks on function entry/leave/return without monkeypatching, using CDP breakpoints and a state machine to serialize asynchronous events. The heap module supports both live object search (via injected QueryObjects) and offline snapshot analysis with object similarity matching (Jaccard/Dice/SimHash) for origin tracing. Key data flows include user-defined automation scripts (Node-side or browser-side) that interact with pages through the WB.Node and WB.Browser APIs, network requests that can be intercepted and modified in real-time, and memory snapshots that are queried for structural matches across multiple snapshots (BDHS). External dependencies are heavy: Puppeteer (bundled Chrome), AG-Grid (community), Monaco Editor, Ant Design, lowdb, and several CDP-specific features that lock the tool to Chromium. The project is primarily targeted at security researchers, reverse engineers, and advanced frontend developers who need introspection beyond standard DevTools.
This repository is a curated collection of skill plugins for AI coding agents such as Claude Code, Codex, and Cursor. Each skill is a self-contained directory with a SKILL.md descriptor, executable scripts, reference documents, and templates. The ecosystem covers a wide range of capabilities: multi-provider media generation (images, video, audio), browser automation via CDP, macOS app telemetry auditing, document format replication, open-source preparation (secret scanning, license generation), Cloudflare Workers deployment, trend aggregation, and video processing. The skills are designed to be invoked by an AI agent reading the SKILL.md and executing workflows via CLI scripts. While primarily an application-oriented collection, some skills (e.g., happy-app-audit) incorporate data analysis and reverse-engineering methodology, giving it a hybrid character. The architecture is modular: each skill is independent, with consistent patterns for provider abstraction, async polling, and template-based output. This makes the repository a practical toolkit for extending agent capabilities rather than a standalone production service.
This repository is a Claude Code skill that enables an AI agent to audit bank transaction CSVs, identify recurring subscriptions, and automate cancellations via browser control. It contains no traditional application code; instead, it provides a structured instruction set (SKILL.md), an interactive HTML report template (template.html), a reference guide for cancellation URLs and dark patterns (common-services.md), and a JSON dataset of common subscription pricing (subscriptions.json). The skill is designed to be used with Anthropic's Claude Code CLI, which executes the workflow: reading CSV files, asking the user to categorize subscriptions, generating a local HTML audit report, and optionally using browser automation to cancel services. The repository is well-documented with a getting-started guide and a Vercel-hosted landing page, but it is not a standalone application—it is a configuration/prompt package for an AI agent.
ClawCloud-Run is a GitHub Actions-based automation script designed to automatically log into ClawCloudRun cloud service to maintain account activity. The system handles GitHub OAuth authentication, device verification, and two-factor authentication (via GitHub Mobile or Telegram-delivered TOTP codes). After login, it navigates to the console and apps pages to keep the session active, extracts the updated session cookie, and either updates it in GitHub Secrets or sends it via Telegram for manual update. The architecture consists of a workflow triggering a Python script that uses Playwright for browser automation, requests for API interactions, and pynacl for secret encryption. Key entry points are the GitHub Actions workflow (scheduled every 5 days) and the Python script's main execution loop.
This Python application automates the registration of new Cursor IDE accounts, including browser-based sign-up, email verification code retrieval (via tempmail.plus or IMAP/POP3), and updates of Cursor's local authentication tokens and machine identifiers. It serves as a workaround for Cursor's trial limitations by continuously generating fresh accounts. The architecture is a monolithic script with modular components: a browser manager (DrissionPage), email handler, configuration loader, authentication database updater, and machine ID resetter. The entry point is `cursor_pro_keep_alive.py`, which offers two modes: reset machine code only or full registration flow. The code is functional but not highly polished; it relies on third-party email services and browser automation that may break with Cursor or service changes. The project is explicitly deprecated by the author, who recommends alternative tools like Claude Code.
This repository is a collection of Tampermonkey userscripts for Chinese cloud storage services: Baidu Pan, Aliyun/AliDrive, Quark, Tianyi/189, LanZou, Xunlei, Weiyun, Caiyun, and 123Pan. In practice, the scripts do much more than the README's vague description of "resource search": they inject download-link buttons into cloud-drive pages, resolve private API endpoints to expose direct download URLs, auto-fill share passwords from local cache or a remote LeanCloud backend, generate Aria2 RPC pushes and BitComet bc:// links, and replace native web players with APlayer/ArtPlayer-based audio/video players. The 管家婆 script additionally maintains a local cache of visited share links/passwords and provides a search dialog pointing at many third-party resource-search sites.
SocialFish is a modern dynamic phishing toolkit designed for credential harvesting, session hijacking, and social engineering attacks. It provides a Flask-based web application with an admin dashboard for managing cloned login pages, capturing credentials, intercepting OTP/2FA codes, tracking victim sessions, and injecting post-capture attack payloads (e.g., keyloggers, clipboard stealers, tab jacking). The system supports browser automation via Playwright and Selenium to clone JavaScript-heavy and SPA login flows, and includes tunneling via ngrok/cloudflared for exposing phishing URLs remotely. The architecture is a monolithic Flask app with SQLite storage, WebSocket real-time updates, and a mobile API authenticated by QR tokens. External dependencies include Flask, Flask-SocketIO, Flask-Login, Playwright, Selenium, nmap, qrcode, and PyLaTeX. Despite its feature-rich surface, the codebase exhibits significant quality issues: broken async flows, missing database columns, incomplete routes, version mismatches between requirements files, and security concerns such as default credentials and insecure secret key generation. The project is actively maintained (last commit 2026-05-20) but the code is not production-ready as claimed in documentation.
This is a proof-of-concept Next.js application that demonstrates a web-browsing AI agent. Users submit a natural language goal (e.g., 'What is NVIDIA stock price?'), and the system creates a Browserbase browser session, then uses an LLM (Claude via Anthropic) to plan and execute steps (navigate, click, extract) via Stagehand. The frontend displays the agent's reasoning steps and a live browser view. The code is tightly coupled to Browserbase and Stagehand SDKs, with the agent loop split between client-side orchestration (ChatFeed) and server-side API routes. It is a simple, functional demo but lacks tests, modularity, and is no longer maintained (moved to another repo).