Skip to content
Back to search

fast-browser-use

A fast browser-use skill powered by local LLMs via single-token reflexes. Fast, local-first, zero hallucinations.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/apus-ai-lab--fast-browser-use/badge.svg)](/listings/apus-ai-lab--fast-browser-use)

HTML

<a href="/listings/apus-ai-lab--fast-browser-use"><img src="/api/listings/apus-ai-lab--fast-browser-use/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

- **System**: Linux, Windows or macOS; Python 3.12+, [uv](https://docs.astral.sh/uv/getting-started/installation/) - **Optional**: Node.js / npm (for `npx skills` installation) - **Hardware**: Apple M1/M2/M3/M4/M5 chips (for MLX); or NVIDIA GPU or CPU supporting PyTorch

Fast Browser Use runs 100% locally with zero cloud API calls. Recommended configurations:

<table> <thead> <tr> <th align="center">Platform / Device</th> <th align="center">Recommended Backend</th> <th align="center">Recommended Model</th> <th align="center">Minimum Memory</th> <th align="left">Peak Runtime Memory / VRAM</th> <th align="left">Recommended Hardware</th> </tr> </thead> <tbody> <tr> <td rowspan="2" align="center"><strong>Apple Silicon Mac<br>(M1 / M2 / M3 / M4 / M5)</strong></td> <td rowspan="2" align="center"><strong>MLX</strong><br><code>(FBU_BACKEND=mlx)</code></td> <td align="center"><code>Qwen3.5-9B MLX 4-bit</code></td> <td align="center"><strong>16 GB</strong></td> <td>~6.5 – 7.5 GB</td> <td>16 GB+ Unified Memory</td> </tr> <tr> <td align="center"><code>Qwen3.5-35B-A3B MLX 4-bit</code></td> <td align="center"><strong>32 GB</strong></td> <td>~20.3 – 21.1 GB</td> <td>36 GB / 48 GB / 64 GB+ Unified Memory</td> </tr> <tr> <td rowspan="2" align="center"><strong>NVIDIA GPU<br>(Linux / Windows)</strong></td> <td rowspan="2" align="center"><strong>PyTorch CUDA</strong><br><code>(FBU_BACKEND=torch)</code></td> <td align="center"><code>Qwen3.5-9B BF16</code></td> <td align="center"><strong>24 GB VRAM</strong></td> <td>~20 – 22 GB VRAM</td> <td>RTX 3090 / 4090 / 6000 Ada / A10 / A5000</td> </tr> <tr> <td align="center"><code>Qwen3.5-35B-A3B BF16</code></td> <td align="center"><strong>80 GB VRAM</strong></td> <td>~75 – 80 GB VRAM</td> <td>RTX PRO 6000 Blackwell (96 GB) / A100 / H100</td> </tr> <tr> <td align="center"><strong>x86 / ARM CPU</strong></td> <td align="center"><strong>PyTorch CPU</strong><br><code>(FBU_BACKEND=torch)</code></td> <td align="center"><code>Qwen3.5-9B FP32/BF16</code></td> <td align="center"><strong>32 GB RAM</strong></td> <td>~20 – 24 GB RAM</td> <td>Multi-core Workstation</td> </tr> </tbody> </table>

---

📦 Agent Skill Setup (Claude Code / Codex / Cursor)

Fast Browser Use is packaged as a standard [Agent Skill](https://github.com/vercel-labs/skills).

Step 1: Register the Skill

# Register globally for Claude Code and Codex (-g = global across all projects)
npx skills add APUS-AI-Lab/fast-browser-use --skill fast-browser-use -a claude-code -a codex -g -y

Step 2: Install Local Runtime and Download Model Weights

Apple Silicon / MLX (for other platforms, use the PyTorch setup below):

# 1. Install the CLI in an isolated Python environment
uv tool install --python 3.12 "git+https://github.com/APUS-AI-Lab/fast-browser-use.git"

# 2. Install matching Playwright Chromium
fbu install-browser

# 3. Cache the pinned Qwen3.5-9B 4-bit weights (~5.95 GB)
fbu download

*(If you already have local Qwen3.5-9B 4-bit weights, specify `export FBU_MODEL=/path/to/weights` to skip downloading.)*

Step 3: Invoke from Your Host Agent

Launch a new agent session in any project:

**In Claude Code:**

/fast-browser-use Open https://en.wikipedia.org/wiki/Main_Page, find the Python programming language article, and verify the final URL and title.

**In Codex:**

$fast-browser-use Open https://en.wikipedia.org/wiki/Main_Page, find the Python programming language article, and verify the final URL and title.

---

Linux / Windows / GPU (PyTorch)

The `torch` extra adds PyTorch, Transformers and Accelerate. `FBU_BACKEND=auto` selects MLX on Apple Silicon and PyTorch elsewhere; `--backend torch` selects PyTorch explicitly.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 457 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <img src="docs/banner.svg" alt="Fast Browser Use — Real browser actions with local LLM" width="100%" />
  3. # Fast Browser Use
  4. **An ultra-fast, local-first "System 1" browser automation engine & Agent Skill for Claude Code, Codex, and Cursor.**
  5. *Powered by local Qwen3.5-9B / Qwen3.5-35B-A3B via MLX or PyTorch (CUDA / CPU). Zero cloud inference, second-level reflexes, zero selector hallucinations.*
  6. [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
  7. [![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
  8. [![Platform: Cross-platform](https://img.shields.io/badge/Platform-Linux%20%7C%20Windows%20%7C%20macOS-black.svg)](#linux--windows--gpu-pytorch)
  9. [![Model: Qwen3.5-9B | 35B-A3B](https://img.shields.io/badge/Model-Qwen3.5--9B%20%7C%2035B--A3B-purple.svg)](https://huggingface.co/Qwen)
  10. [![Cloud Inference: None](https://img.shields.io/badge/Cloud%20API-Zero%20(%20100%25%20Offline%20)-orange.svg)](#-local-first-architecture)
  11. [![Agent Skill: Claude Code & Codex](https://img.shields.io/badge/Agent%20Skill-Claude%20Code%20%7C%20Codex-brightgreen.svg)](skills/fast-browser-use/SKILL.md)
  12. [English](README.md) · [简体中文](README.zh-CN.md) · [Quickstart](#-quickstart) · [Architecture & Deep Dive](#-architecture--deep-dive) · [Benchmarks](#-benchmarks--measurements) · [Agent Skill Setup](#-agent-skill-setup) · [Python API](#-python-api)
  13. </div>
  14. ---
  15. <div align="center">
  16. <a href="docs/qwen9b-demo.mp4"><img src="docs/qwen9b-demo.gif" alt="Local Qwen3.5-9B browser run on GPU, 1x real-time original playback" width="100%" /></a>
  17. **[Recording preview (1× original playback)](docs/qwen9b-demo.mp4)** · **[Measurement Telemetry (JSON)](docs/qwen9b-demo-measurement.json)** · **[Performance Benchmarks](docs/performance.md)**
  18. </div>
  19. > **Open-Source Reverse Engineering of Jev · Pure Local Browser-Use Agent Skill**
  20. > Fast Browser Use reproduces Jev's System 1 discrete decision paradigm using open-source weights (Qwen3.5-9B / Qwen3.5-35B-A3B), grounded in real-world browser automation. By mapping visible interactive elements to vocabulary tokens for single-step logits scoring, it structurally eliminates selector hallucinations—packaged as an out-of-the-box agent skill for 100% local, offline execution.
  21. ---
  22. ## 💡 Background: Open-Source Reverse Engineering of Jev for Browser Use
  23. In mid-September 2026, TypeSafe AI announced **Jev** (co-founded by ex-OpenAI researcher Diogo Almeida), sparking widespread discussion across the AI developer community:
  24. > *"Why do we default to forcing massive 100B+ parameter LLMs to decode tokens one-by-one for bounded automated actions—enduring multi-second latencies and frequent hallucinations—when most software decisions are deterministic?"*
  25. TypeSafe AI framed the paradigm around **System 1 (fast, calibrated discrete decisions)** vs. **System 2 (slow, deliberative planning)**. By training models via RLCD (Reinforcement Learning for Calibrated Decisions) to directly score bounded, typed decision spaces instead of generating free-form text, Jev demonstrated decision speeds 20–200× faster than traditional LLMs.
  26. Currently, Jev is provided as a cloud API service without publicly available model weights or internal implementation details. While early community projects such as [`jev-ultrafast`](https://github.com/browser-use/jev-ultrafast) showcased the speed potential by connecting to this cloud endpoint, **Fast Browser Use** explores bringing this decision paradigm fully onto local devices using open-source weights—enabling a 100% offline, private, and zero-cloud-cost experience.
  27. ### Bringing the Paradigm 100% On-Device with Open Models
  28. **Fast Browser Use** is an open-source reverse engineering and local reproduction of Jev's core decision mechanics, purpose-built for the demanding domain of **browser automation (`browser-use`)**.
  29. By analyzing Jev's documented interface paradigms and evaluation logic, as well as drawing inspiration from open-source projects, we decoupled bounded categorical decisions from slow autoregressive text generation and ported the architecture to run 100% locally on Apple Silicon / GPU using **Qwen3.5-9B / Qwen3.5-35B-A3B**:
  30. - **From Code Generation to Bounded Categorical Choice**: Traditional browser agents ask an LLM to generate raw Playwright scripts or CSS selectors, frequently causing "selector hallucinations" on dynamic pages. Fast Browser Use scans the rendered DOM tree, extracts only visible, interactable elements, and formats them into discrete candidate tuples `(CLICK, btn_7)`. The model selects exclusively from objectively existing elements—eliminating selector hallucinations by design.
  31. - **Single-Token Logits Scoring ($O(1)$ Reflexes)**: Legal candidate actions are dynamically mapped to single discrete tokens in the vocabulary (`A`, `B`, `C`...). With a single forward pass, the engine evaluates normalized Softmax probabilities over candidate logits in **seconds (single forward pass)**, skipping the multi-second autoregressive text decoding loop entirely.
  32. - **Decoupled Action & Generation**: Structural page actions (click, select, scroll) use discrete logits scoring; generative text completion is invoked only when typing content into fields (`TYPE_TEXT`).
  33. - **100% Offline & Private**: Zero cloud API calls, zero telemetry, and zero subscription costs. The entire inference loop runs on your machine through MLX or PyTorch.
  34. ---
  35. ## 📊 Comparison: Cloud Agents vs. Fast Browser Use
  36. | Dimension | Traditional Cloud Multimodal Agents | Fast Browser Use (Local System 1) |
  37. | :--- | :--- | :--- |
  38. | **Inference Location** | Cloud APIs (OpenAI, Anthropic, etc.) | **100% Local** (MLX or PyTorch CUDA / CPU) |
  39. | **Step Latency** | 3,000 – 8,000 ms (Network + Decoding) | **Second-level** (Pure Logits Forward Pass) |
  40. | **Decision Mechanism** | Autoregressive text/JSON generation | **Discrete candidate selection** (Single-Token) |
  41. | **Selector Reliability** | Prone to invented CSS/XPath selectors | **Zero Hallucination** (Derived from visible DOM) |
  42. | **Syntax Validity** | Subject to broken JSON, missing quotes | **100% Valid Syntax** (Deterministic host assembly) |
  43. | **Data Privacy** | Full pages/screenshots transmitted to cloud | **100% Air-Gapped**, inference data stays on your machine |
  44. | **Inference Cost** | Pay per token / per screenshot | **$0.00** (Free, on-device compute) |
  45. | **Host Integration** | Standalone monolithic agent | **Standard Agent Skill** for Claude Code & Codex |
  46. ---
  47. ## 🧠 System 1 vs. System 2: Division of Labor
  48. Fast Browser Use does not aim to replace macro-reasoning LLMs. Instead, it provides the missing **"System 1" (muscle memory & fast reflexes)** to complement **"System 2" (slow deliberate reasoning)**:
  49. <img src="docs/02-action-selection.en.svg" alt="From Code Generation to Constrained Candidate Selection" width="100%" />
  50. - **System 2 (Host Brain: Claude Code, Codex, Cursor, Antigravity)**:
  51. Handles high-level user intent, multi-file code analysis, macro planning, and independent outcome verification.
  52. - **System 1 (Local Engine: Fast Browser Use)**:
  53. Handles high-frequency DOM sensing, micro-action selection, bounded waiting, and atomic page interactions.
  54. - **Independent Audit**:
  55. Upon completion, Fast Browser Use returns an immutable execution trace. The host agent independently verifies the resulting page state against ground truth before proceeding.
  56. ---
  57. ## 🔬 Architecture & Deep Dive
  58. How does Fast Browser Use achieve extreme speed without closed-source weights? By transforming open-ended text generation into a **bounded categorical decision problem**:
  59. <img src="docs/01-jev-parallel-decision.en.svg" alt="Constrained Decision Architecture" width="100%" />
  60. ### 1. Structurally Eliminating Selector Hallucinations
  61. A lightweight in-page scanner inspects the rendered layout tree, extracting only **currently visible, interactable** elements. These are formatted into discrete candidate tuples:
  62. ```python
  63. ("CLICK", "btn_search")
  64. ("SELECT", "opt_timezone_sg")
  65. ("TYPE_TEXT", "input_query")
  66. ("DONE", "task_completed")
  67. ```
  68. The model selects an action from this finite set. Because the model never writes selectors or Playwright code, selector hallucinations and syntax errors are mathematically impossible.
  69. ### 2. Single-Token Logits Scoring
  70. Each legal candidate action is dynamically mapped to a unique single token in the tokenizer vocabulary (`A`, `B`, `C`...).
  71. Rather than generating text, the engine performs **one single forward pass**, extracts the next-token logits, and evaluates normalized Softmax probabilities:
  72. $$P(c_i \mid \text{Context}) = \frac{\exp(z_i / T)}{\sum_{j=1}^K \exp(z_j / T)}$$
  73. This reduces scoring from an $O(\text{tokens} \times \text{layers})$ autoregressive decoding loop to an $O(1)$ logits projection completed in seconds.
  74. ### 3. Action Selection & Text Generation Decoupling
  75. Most browser interactions (clicking buttons, expanding dropdowns, scrolling) do not require creative writing.
  76. Fast Browser Use decouples structural navigation from text input:
  77. - Structural choices use **single-token discrete scoring**.
  78. - Only when the chosen action is `TYPE_TEXT` does the model perform targeted generative inference to compose the required field text.
  79. ### 4. KV-Cache Broadcasting & Batched Evaluation
  80. By prefilling the common page context once and broadcasting the base KV-Cache across candidate dimensions, evaluating multiple fields or candidate options is parallelized into a single batch forward pass without cascading autoregressive error.
  81. ---
  82. ## 🛡️ Guarded Loop Engineering (The Harness)
  83. A fast model without rigorous guardrails is brittle. Fast Browser Use wraps local inference inside a robust multi-layer harness:
  84. <img src="docs/03-execution-loop.en.svg" alt="Guarded Closed-Loop Execution Architecture" width="100%" />
  85. 1. **Bounded Settling Window**: Dynamic single-page apps (SPAs) often render asynchronously. A mandatory 150ms quiet window (≥500ms on new documents, ≥300ms post-input) ensures controls are fully mounted before scoring begins.
  86. 2. **Joint Action & `DONE` Scoring**: Candidate actions and completion (`DONE`) are scored within the same forward pass, slashing per-task inference passes from 14 to 4.
  87. 3. **Pre-Execution Physical Guards**:
  88. - **Visibility & Occlusion**: Ensures target elements are not hidden beneath overlays, modals, or banners.
  89. - **DOM Freshness**: Confirms that referenced nodes have not been detached or replaced by dynamic frameworks.
  90. - **Read-Only Protection**: Intercepts disabled or read-only controls before mutations occur.
  91. 4. **Write-Once Trace & No Mutation Retries**: Every action is immutably recorded to the execution trace before dispatch. Dispatched mutations are **never blindly retried** to prevent duplicate form submissions or destructive side effects.
  92. 5. **Independent Outcome Verification**: The model's `DONE` output is treated as a subjective hypothesis. Automated workflows must verify success through external assertions (`--expect-url`, `--expect-title`, `--expect-text`).
  93. ---
  94. ## ⚡ Benchmarks & Measurements
  95. All measurements below were collected on NVIDIA RTX PRO 6000 Blackwell Workstation (96 GB VRAM) with **100% local inference** (zero cloud API requests):
  96. - **Hardware**: NVIDIA RTX PRO 6000 Blackwell Workstation (96 GB VRAM, Linux x86_64)
  97. - **Inference Stack**: PyTorch 2.14.0 (CUDA 13.0) + Flash Linear Attention (`fla`) + `causal-conv1d` native hardware kernels
  98. - **Evaluated Models**: `Qwen3.5-9B` (BF16) & `Qwen3.5-35B-A3B` (BF16)
  99. ### 1. Wikipedia End-to-End Live Navigation
  100. Task: *"Find and open the Wikipedia article about Python (programming language) starting from Main_Page, strictly verifying final URL and title."*
  101. | Run Trial | Qwen3.5-9B Task Time | Qwen3.5-35B-A3B Task Time |
  102. | :---: | :---: | :---: |
  103. | Trial 1 | 4.055 s | 8.221 s |
  104. | Trial 2 | 3.935 s | 4.933 s |
  105. | Trial 3 | 4.067 s | 4.944 s |
  106. | **Median** | **4.055 s** | **4.944 s** |
  107. *Task completed in 4 discrete single-token scoring steps.*
  108. ### 2. Multi-Scenario Suite Performance
  109. | Scenario & Task | Qwen3.5-9B Task Time | Qwen3.5-35B-A3B Task Time | Actions Executed | Independent Verification |
  110. | :--- | :---: | :---: | :---: | :--- |
  111. | **Wikipedia Navigation** (Find & open Python article) | **4.055 s** | **4.944 s** | Search focus, fill, select result, done | Strict match on final canonical URL & page title |
  112. | **Workspace Settings Form** (Name, timezone dropdown, toggle weekly digest) | **2.488 s** | **3.360 s** | Fill, Select, Toggle, Save | Exact match on saved confirmation notification |
  113. | **Local Reading Room Navigation** | **0.808 s** | **1.049 s** | Search, Link Click | Exact match on target article URL and title |
  114. | **Python.org Navigation** (Navigate to About page) | **1.789 s** | **2.120 s** | Nav menu hover & click | Exact match on target `/about/` URL |
  115. | **Example.com → IANA Info** | **1.263 s** | **1.535 s** | Anchor detection & jump | Exact match on destination domain |
  116. ---
  117. ## 🚀 Quickstart
  118. ### Prerequisites
  119. - **System**: Linux, Windows or macOS; Python 3.12+, [uv](https://docs.astral.sh/uv/getting-started/installation/)
  120. - **Optional**: Node.js / npm (for `npx skills` installation)
  121. - **Hardware**: Apple M1/M2/M3/M4/M5 chips (for MLX); or NVIDIA GPU or CPU supporting PyTorch
  122. Fast Browser Use runs 100% locally with zero cloud API calls. Recommended configurations:
  123. <table>
  124. <thead>
  125. <tr>
  126. <th align="center">Platform / Device</th>
  127. <th align="center">Recommended Backend</th>
  128. <th align="center">Recommended Model</th>
  129. <th align="center">Minimum Memory</th>
  130. <th align="left">Peak Runtime Memory / VRAM</th>
  131. <th align="left">Recommended Hardware</th>
  132. </tr>
  133. </thead>
  134. <tbody>
  135. <tr>
  136. <td rowspan="2" align="center"><strong>Apple Silicon Mac<br>(M1 / M2 / M3 / M4 / M5)</strong></td>
  137. <td rowspan="2" align="center"><strong>MLX</strong><br><code>(FBU_BACKEND=mlx)</code></td>
  138. <td align="center"><code>Qwen3.5-9B MLX 4-bit</code></td>
  139. <td align="center"><strong>16 GB</strong></td>
  140. <td>~6.5 – 7.5 GB</td>
  141. <td>16 GB+ Unified Memory</td>
  142. </tr>
  143. <tr>
  144. <td align="center"><code>Qwen3.5-35B-A3B MLX 4-bit</code></td>
  145. <td align="center"><strong>32 GB</strong></td>
  146. <td>~20.3 – 21.1 GB</td>
  147. <td>36 GB / 48 GB / 64 GB+ Unified Memory</td>
  148. </tr>
  149. <tr>
  150. <td rowspan="2" align="center"><strong>NVIDIA GPU<br>(Linux / Windows)</strong></td>
  151. <td rowspan="2" align="center"><strong>PyTorch CUDA</strong><br><code>(FBU_BACKEND=torch)</code></td>
  152. <td align="center"><code>Qwen3.5-9B BF16</code></td>
  153. <td align="center"><strong>24 GB VRAM</strong></td>
  154. <td>~20 – 22 GB VRAM</td>
  155. <td>RTX 3090 / 4090 / 6000 Ada / A10 / A5000</td>
  156. </tr>
  157. <tr>
  158. <td align="center"><code>Qwen3.5-35B-A3B BF16</code></td>
  159. <td align="center"><strong>80 GB VRAM</strong></td>
  160. <td>~75 – 80 GB VRAM</td>
  161. <td>RTX PRO 6000 Blackwell (96 GB) / A100 / H100</td>
  162. </tr>
  163. <tr>
  164. <td align="center"><strong>x86 / ARM CPU</strong></td>
  165. <td align="center"><strong>PyTorch CPU</strong><br><code>(FBU_BACKEND=torch)</code></td>
  166. <td align="center"><code>Qwen3.5-9B FP32/BF16</code></td>
  167. <td align="center"><strong>32 GB RAM</strong></td>
  168. <td>~20 – 24 GB RAM</td>
  169. <td>Multi-core Workstation</td>
  170. </tr>
  171. </tbody>
  172. </table>
  173. ---
  174. ### 📦 Agent Skill Setup (Claude Code / Codex / Cursor)
  175. Fast Browser Use is packaged as a standard [Agent Skill](https://github.com/vercel-labs/skills).
  176. #### Step 1: Register the Skill
  177. ```bash
  178. # Register globally for Claude Code and Codex (-g = global across all projects)
  179. npx skills add APUS-AI-Lab/fast-browser-use --skill fast-browser-use -a claude-code -a codex -g -y
  180. ```
  181. #### Step 2: Install Local Runtime and Download Model Weights
  182. Apple Silicon / MLX (for other platforms, use the PyTorch setup below):
  183. ```bash
  184. # 1. Install the CLI in an isolated Python environment
  185. uv tool install --python 3.12 "git+https://github.com/APUS-AI-Lab/fast-browser-use.git"
  186. # 2. Install matching Playwright Chromium
  187. fbu install-browser
  188. # 3. Cache the pinned Qwen3.5-9B 4-bit weights (~5.95 GB)
  189. fbu download
  190. ```
  191. *(If you already have local Qwen3.5-9B 4-bit weights, specify `export FBU_MODEL=/path/to/weights` to skip downloading.)*
  192. #### Step 3: Invoke from Your Host Agent
  193. Launch a new agent session in any project:
  194. **In Claude Code:**
  195. ```text
  196. /fast-browser-use Open https://en.wikipedia.org/wiki/Main_Page, find the Python programming language article, and verify the final URL and title.
  197. ```
  198. **In Codex:**
  199. ```text
  200. $fast-browser-use Open https://en.wikipedia.org/wiki/Main_Page, find the Python programming language article, and verify the final URL and title.
  201. ```
  202. ---
  203. ### Linux / Windows / GPU (PyTorch)
  204. The `torch` extra adds PyTorch, Transformers and Accelerate. `FBU_BACKEND=auto` selects MLX on
  205. Apple Silicon and PyTorch elsewhere; `--backend torch` selects PyTorch explicitly.
  206. ```bash
  207. # From a checkout in a Linux GPU environment
  208. uv sync --locked --extra torch --python 3.12
  209. uv run fbu install-browser --with-deps
  210. # Download 9B weights (default) or 35B-A3B weights
  211. uv run fbu download --backend torch --model 9b
  212. uv run fbu download --backend torch --model 35b
  213. # Compare and record 9B vs 35B-A3B tasks
  214. uv run fbu record --backend torch --device cuda --model 9b --scenario wikipedia --output artifacts/wikipedia_9b
  215. uv run fbu record --backend torch --device cuda --model 35b --scenario wikipedia --output artifacts/wikipedia_35b
  216. ```
  217. `--with-deps` installs Chromium's Linux system libraries and may require root/sudo. Neither a desktop,
  218. `DISPLAY`, Xvfb, VNC nor the inspector is needed. All recordings explicitly use headless Chromium.
  219. The original `browser.webm`, screenshots, trace and independent verification are saved on the server.
  220. For a globally available CLI:
  221. ```bash
  222. uv tool install --python 3.12 'fast-browser-use[torch] @ git+https://github.com/APUS-AI-Lab/fast-browser-use.git'
  223. fbu install-browser --with-deps # On Windows/macOS, omit --with-deps
  224. fbu download --backend torch --model 9b
  225. ```
  226. PyTorch supports selecting between the pinned original [Qwen/Qwen3.5-9B](https://huggingface.co/Qwen/Qwen3.5-9B)
  227. and the MoE [Qwen/Qwen3.5-35B-A3B](https://huggingface.co/Qwen/Qwen3.5-35B-A3B) checkpoints
  228. through the [Transformers text-only loader](https://huggingface.co/docs/transformers/model_doc/qwen3_5).
  229. Select via `--model 9b` / `--model 35b` or `FBU_MODEL=35b` (defaults to `9b`).
  230. MLX 4-bit files cannot be reused by PyTorch. When switching backends, remove an old `FBU_MODEL`
  231. override or point it to matching local weights. Downloads use Hugging Face; the existing ModelScope
  232. mirror is available for MLX only. After downloading, `HF_HUB_OFFLINE=1` prevents further Hub access;
  233. browsing live websites still requires network access.
  234. | Setting | Default / supported values |
  235. | :--- | :--- |
  236. | `FBU_BACKEND` / `--backend` | `auto`, `mlx`, `torch` |
  237. | `FBU_DEVICE` / `--device` | `auto` → available CUDA, otherwise CPU; `cpu`, `cuda`, `cuda:N` |
  238. | `FBU_DTYPE` / `--dtype` | `auto` → CUDA BF16 if supported, otherwise FP16; CPU FP32. Explicit `bfloat16`, `float16`, `float32` |
  239. | `FBU_MODEL` / `--model` | Pinned repository, aliases (`9b`, `35b`), or a local compatible model directory |
  240. CUDA runs on one selected GPU; `cuda:N` uses the index visible to PyTorch (including
  241. `CUDA_VISIBLE_DEVICES`). Install a [PyTorch build matching your GPU driver](https://pytorch.org/get-started/locally/)
  242. if the installed build does not expose CUDA. On Windows, the same CLI works from PowerShell;
  243. use `$env:FBU_BACKEND='torch'` when setting environment variables.
  244. ### 💻 Standalone CLI Usage & CI Assertions
  245. Run tasks directly from the command line with external outcome verifiers:
  246. ```bash
  247. # Generic web task with strict assertions
  248. fbu run https://en.wikipedia.org/wiki/Main_Page \
  249. --goal 'Find and open the Wikipedia article about Python, the programming language.' \
  250. --expect-url 'https://en.wikipedia.org/wiki/Python_(programming_language)' \
  251. --expect-title 'Python (programming language) - Wikipedia' \
  252. --trace artifacts/wikipedia_trace.json
  253. ```
  254. ```bash
  255. # Complex form filling with multiple expected text checks
  256. fbu run 'https://target.example/settings' \
  257. --goal 'Save workspace preferences with timezone Asia/Singapore and weekly digest enabled.' \
  258. --expect-title 'Preferences saved' \
  259. --expect-text 'Timezone: Asia/Singapore.' \
  260. --expect-text 'Weekly digest: enabled.' \
  261. --trace artifacts/preferences.json
  262. ```
  263. - `--expect-url` & `--expect-title`: Exact equality matching on final page state.
  264. - `--expect-text`: Substring check on page text content (repeatable).
  265. - Assertions read a fresh post-execution DOM state, are never passed into the model prompt, and fail the command if unmet.
  266. <details>
  267. <summary>Install from Local Checkout / Without Node.js</summary>
  268. ```bash
  269. git clone https://github.com/APUS-AI-Lab/fast-browser-use.git
  270. cd fast-browser-use
  271. uv tool install --python 3.12 .
  272. fbu install-browser
  273. fbu download
  274. ```
  275. Manual symlinks without Node.js:
  276. ```bash
  277. mkdir -p "$HOME/.claude/skills" "$HOME/.agents/skills"
  278. ln -s "$PWD/skills/fast-browser-use" "$HOME/.claude/skills/fast-browser-use"
  279. ln -s "$PWD/skills/fast-browser-use" "$HOME/.agents/skills/fast-browser-use"
  280. ```
  281. </details>
  282. <details>
  283. <summary>Hugging Face Model Download & Offline Mode</summary>
  284. Download pre-quantized 4-bit weights directly from Hugging Face:
  285. ```bash
  286. # Download to the default local cache
  287. fbu download
  288. # Or specify a custom output directory
  289. uv run fbu download --output models/Qwen3.5-9B-4bit
  290. FBU_MODEL=models/Qwen3.5-9B-4bit fbu run https://www.python.org/ \
  291. --goal 'Open the About Python page.' --expect-url 'https://www.python.org/about/'
  292. ```
  293. After downloading, enable offline execution:
  294. ```bash
  295. export HF_HUB_OFFLINE=1
  296. ```
  297. </details>
  298. ---
  299. ## 🐍 Python API
  300. Integrate Fast Browser Use directly into your Python automation workflows:
  301. ```python
  302. from fast_browser_use import Agent
  303. from fast_browser_use.model import get_model
  304. # Warm up weights once
  305. get_model()
  306. # Execute task with fine-grained state streaming
  307. with Agent("https://example.com", "Open the More information link.") as agent:
  308. for state in agent.run():
  309. print(f"[{state['elapsed_ms']}ms] Step status: {state['status']}")
  310. if "action" in state:
  311. print(f" Action: {state['action']}")
  312. ```
  313. ---
  314. ## 🎥 Recording & Reproducing Demos
  315. Recordings use Playwright Chromium video capture in headless mode, even if `FBU_HEADLESS=0`
  316. is set for interactive debugging. No desktop recorder is used. Generate auditable videos with
  317. labeled playback speeds (preview rendering requires `ffmpeg`/`ffprobe`; raw recording does not):
  318. ```bash
  319. # Headless recording: saves 1x original video + telemetry, including inference/waits
  320. uv run fbu record --scenario wikipedia
  321. uv run fbu record --scenario wikipedia --model 35b
  322. # Render labeled preview (target <= 10s with preserved original)
  323. uv run python scripts/render_demo.py artifacts/recordings/<timestamp> --max-seconds 10
  324. ```
  325. ---
  326. ## 🛠️ Verification & Development
  327. Run the full local test and guard suite:
  328. ```bash
  329. uv run ruff check .
  330. uv run pytest
  331. # Also run tiny random-model PyTorch tests without downloading pretrained weights:
  332. uv run --extra torch pytest tests/test_torch_backend.py
  333. node --check fast_browser_use/static/app.js
  334. node --check fast_browser_use/snapshot.js
  335. uv run python scripts/check_guards.py
  336. uv build
  337. ```
  338. ---
  339. ## 📄 License & Attribution
  340. This project is licensed under the [MIT License](LICENSE).
  341. Inspired by [Jev Ultrafast](https://github.com/browser-use/jev-ultrafast). Upstream MIT attribution and notices are preserved in [NOTICE](NOTICE). This project also draws inspiration and ideas from [openjev](https://github.com/TheoLeeCJ/openjev) and [Qwen-2.5-1B-RLCD](https://huggingface.co/harshatheg/Qwen-2.5-1B-RLCD).
  342. ---
  343. <div align="center">
  344. <b>Fast Browser Use</b> · Built for the next generation of autonomous local-first agents.
  345. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.