Skip to content
Back to search

codex-browser-use

Let any coding agent control your real Chrome browser — a fast, open-source clone of Codex Browser Use.

Safety scan

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

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/khanhle1406--codex-browser-use/badge.svg)](/listings/khanhle1406--codex-browser-use)

HTML

<a href="/listings/khanhle1406--codex-browser-use"><img src="/api/listings/khanhle1406--codex-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.

You need **Node.js 26.12.1 or newer**, npm, and Chrome (or Chromium, Edge, or Brave).

Set up your agent

**Option 1 — 1-command install via npm (fastest):**

# Quick run via npx (or install globally with `npm install -g codex-browser-use` for a permanent binary path)
npx -y codex-browser-use install --client antigravity --write --skill
npx -y codex-browser-use doctor --json

Install just the Agent Skill (`SKILL.md` + cookbook) into any compatible client via [`skills.sh`](https://skills.sh):

npx skills add https://github.com/khanhle1406/codex-browser-use

**Option 2 — From source (`git clone`):**

npm --prefix mcp-server ci
node mcp-server/bin/browser-use.js install --client antigravity --write --skill
node mcp-server/bin/browser-use.js doctor --json

`install --skill` copies the Chrome extension (`v0.6.4`), registers the local Chrome Native Messaging host, writes your client's MCP config (saving a `.bak` backup first), installs the full skill bundle (`skill/SKILL.md` + `skill/references/cookbook.md` + `skill/references/tools.md`), and automatically installs the always-on rules file (`rules/browser_use.md`, or `.cursor/rules/browser_use.mdc` for Cursor) when supported (pass `--no-rules` to skip, or `--rules` standalone).

<details> <summary><strong>Supported clients &amp; tool profiles (<code>--profile auto | compact | standard | full</code>)</strong></summary>

| Client | MCP Config | Skill Folder | Rules Installed by `--skill` | | --- | --- | --- | --- | | `antigravity` | `~/.gemini/config/mcp_config.json` | `~/.gemini/config/skills/codex-browser-use/` | `~/.gemini/config/rules/browser_use.md` | | `commandcode` | `~/.commandcode/mcp.json` | `~/.agents/skills/codex-browser-use/` | `~/.agents/rules/browser_use.md` *(recommend `--profile compact` or `auto`)* | | `cursor` | `~/.cursor/mcp.json` | `~/.cursor/skills/codex-browser-use/` | `~/.cursor/rules/browser_use.mdc` *(with Cursor frontmatter)* | | `windsurf` | `~/.codeium/windsurf/mcp_config.json` | `~/.codeium/windsurf/skills/codex-browser-use/` | `~/.codeium/windsurf/rules/browser_use.md` | | `copilot` | `~/.copilot/mcp-config.json` | `~/.agents/skills/codex-browser-use/` | `~/.agents/rules/browser_use.md` | | `claude_code` | `~/.claude.json` | `~/.claude/skills/codex-browser-use/` | *(skipped)* | | `codex` | Print TOML via `config` | `~/.codex/skills/codex-browser-use/` | *(skipped)* | | `opencode` / `generic` | Print config via `config` | `~/.agents/skills/codex-browser-use/` | `~/.agents/rules/browser_use.md` |

For non-lazy CLI clients (Codex, Claude Code, Command Code, Copilot, OpenCode), pass `--profile auto` (auto-picks `"compact"` for CLIs and `"full"` for lazy-loading IDEs) or `--profile compact` / `BROWSER_USE_TOOL_PROFILE=compact` to register only the 7 core tools and cut fixed tool schema size by **75.4%** (`7,457` bytes / `~1,865` est. tokens vs `30,302` bytes / `~7,576` est. tokens):

node mcp-server/bin/browser-use.js install --client commandcode --write --skill --profile auto
node mcp-server/bin/browser-use.js config --client codex --profile auto

For Codex or OpenCode, print the config snippet and install the skill:

node mcp-server/bin/browser-use.js config --client codex
node mcp-server/bin/browser-use.js config --client opencode
node mcp-server/bin/browser-use.js install --client codex --skill

</details>

Connect Chrome

1. Open `chrome://extensions`, turn on **Developer mode**, click **Load unpacked**, and choose `~/.local/share/browser-use/extension`. 2. That's it — **Portable Browser Bridge** connects automatically in the background (hover the icon to check status, or click to pause/reconnect). 3. Restart your coding agent so it loads the MCP tools.

Ask your agent

Once connected, just ask in plain English:

Open http://127.0.0.1:3000 in a Chrome tab group called "App QA".
Test the signup form on desktop and mobile sizes, check for any console

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 · 313 lines
  1. <div align="center">
  2. <img src="docs/assets/logo.png" alt="codex-browser-use logo" width="96" />
  3. # codex-browser-use
  4. ### One fast local MCP that gives any coding agent your real Chrome browser.
  5. **Codex's Browser Use feature is so good — so I cloned it and made a faster, open-source version for every coding agent.**
  6. **English** · [Tiếng Việt](docs/i18n/README_vi.md) · [简体中文](docs/i18n/README_zh-CN.md) · [日本語](docs/i18n/README_ja.md) · [한국어](docs/i18n/README_ko.md)
  7. [![License: MIT](https://img.shields.io/badge/license-MIT-f4c430?style=flat-square)](LICENSE)
  8. [![npm](https://img.shields.io/npm/v/codex-browser-use?style=flat-square&color=cb3837)](https://www.npmjs.com/package/codex-browser-use)
  9. [![Website](https://img.shields.io/badge/Website-codex--browser--use.vercel.app-2563EB?style=flat-square)](https://codex-browser-use.vercel.app)
  10. [![Node.js](https://img.shields.io/badge/Node.js-26.12.1%2B-339933?style=flat-square&logo=nodedotjs&logoColor=white)](#quick-start)
  11. [![Version](https://img.shields.io/badge/MCP-v4.8.2%20%7C%2036%20tools-5B8DEF?style=flat-square)](#why-its-better)
  12. [![Extension](https://img.shields.io/badge/Extension-v0.6.4-34D399?style=flat-square)](#quick-start)
  13. [![GitHub stars](https://img.shields.io/github/stars/khanhle1406/codex-browser-use?style=flat-square)](https://github.com/khanhle1406/codex-browser-use/stargazers)
  14. [Website](https://codex-browser-use.vercel.app) · [Quick start](#quick-start) · [How it works](#how-it-works) · [What you can do](#what-you-can-do) · [Why it's better](#why-its-better) · [FAQ](#faq) · [Documentation](#documentation)
  15. <code>npx -y codex-browser-use install --client antigravity --write --skill</code>
  16. </div>
  17. <div align="center">
  18. <br />
  19. <img src="docs/assets/banner.png" alt="codex-browser-use — Local Chrome MCP Bridge" width="100%" />
  20. </div>
  21. ---
  22. Want your coding agent to open a website, click buttons, fill out forms, and test if your app actually works? Usually that means installing Playwright, launching a heavy extra browser, and burning through your token limit on giant HTML dumps and screenshots.
  23. OpenAI Codex solved this cleanly by connecting straight to your real Chrome browser and reading pages as a short numbered list instead of raw HTML. The only catch is that it only works inside Codex. So I cloned the idea from scratch as a free, open-source tool that works with **any coding agent** — and tuned it to run even faster.
  24. Setup takes one command. It installs a small Chrome extension, registers the local bridge, and installs the complete agent skill bundle and always-on rules automatically. Your agent works right inside your currently open Chrome — keeping your existing cookies and signed-in sessions — while leaving your own open tabs and ongoing work completely untouched.
  25. ## Quick start
  26. You need **Node.js 26.12.1 or newer**, npm, and Chrome (or Chromium, Edge, or Brave).
  27. ### Set up your agent
  28. **Option 1 — 1-command install via npm (fastest):**
  29. ```sh
  30. # Quick run via npx (or install globally with `npm install -g codex-browser-use` for a permanent binary path)
  31. npx -y codex-browser-use install --client antigravity --write --skill
  32. npx -y codex-browser-use doctor --json
  33. ```
  34. Install just the Agent Skill (`SKILL.md` + cookbook) into any compatible client via [`skills.sh`](https://skills.sh):
  35. ```sh
  36. npx skills add https://github.com/khanhle1406/codex-browser-use
  37. ```
  38. **Option 2 — From source (`git clone`):**
  39. ```sh
  40. npm --prefix mcp-server ci
  41. node mcp-server/bin/browser-use.js install --client antigravity --write --skill
  42. node mcp-server/bin/browser-use.js doctor --json
  43. ```
  44. `install --skill` copies the Chrome extension (`v0.6.4`), registers the local Chrome Native Messaging host, writes your client's MCP config (saving a `.bak` backup first), installs the full skill bundle (`skill/SKILL.md` + `skill/references/cookbook.md` + `skill/references/tools.md`), and automatically installs the always-on rules file (`rules/browser_use.md`, or `.cursor/rules/browser_use.mdc` for Cursor) when supported (pass `--no-rules` to skip, or `--rules` standalone).
  45. <details>
  46. <summary><strong>Supported clients &amp; tool profiles (<code>--profile auto | compact | standard | full</code>)</strong></summary>
  47. | Client | MCP Config | Skill Folder | Rules Installed by `--skill` |
  48. | --- | --- | --- | --- |
  49. | `antigravity` | `~/.gemini/config/mcp_config.json` | `~/.gemini/config/skills/codex-browser-use/` | `~/.gemini/config/rules/browser_use.md` |
  50. | `commandcode` | `~/.commandcode/mcp.json` | `~/.agents/skills/codex-browser-use/` | `~/.agents/rules/browser_use.md` *(recommend `--profile compact` or `auto`)* |
  51. | `cursor` | `~/.cursor/mcp.json` | `~/.cursor/skills/codex-browser-use/` | `~/.cursor/rules/browser_use.mdc` *(with Cursor frontmatter)* |
  52. | `windsurf` | `~/.codeium/windsurf/mcp_config.json` | `~/.codeium/windsurf/skills/codex-browser-use/` | `~/.codeium/windsurf/rules/browser_use.md` |
  53. | `copilot` | `~/.copilot/mcp-config.json` | `~/.agents/skills/codex-browser-use/` | `~/.agents/rules/browser_use.md` |
  54. | `claude_code` | `~/.claude.json` | `~/.claude/skills/codex-browser-use/` | *(skipped)* |
  55. | `codex` | Print TOML via `config` | `~/.codex/skills/codex-browser-use/` | *(skipped)* |
  56. | `opencode` / `generic` | Print config via `config` | `~/.agents/skills/codex-browser-use/` | `~/.agents/rules/browser_use.md` |
  57. For non-lazy CLI clients (Codex, Claude Code, Command Code, Copilot, OpenCode), pass `--profile auto` (auto-picks `"compact"` for CLIs and `"full"` for lazy-loading IDEs) or `--profile compact` / `BROWSER_USE_TOOL_PROFILE=compact` to register only the 7 core tools and cut fixed tool schema size by **75.4%** (`7,457` bytes / `~1,865` est. tokens vs `30,302` bytes / `~7,576` est. tokens):
  58. ```sh
  59. node mcp-server/bin/browser-use.js install --client commandcode --write --skill --profile auto
  60. node mcp-server/bin/browser-use.js config --client codex --profile auto
  61. ```
  62. For Codex or OpenCode, print the config snippet and install the skill:
  63. ```sh
  64. node mcp-server/bin/browser-use.js config --client codex
  65. node mcp-server/bin/browser-use.js config --client opencode
  66. node mcp-server/bin/browser-use.js install --client codex --skill
  67. ```
  68. </details>
  69. ### Connect Chrome
  70. 1. Open `chrome://extensions`, turn on **Developer mode**, click **Load unpacked**, and choose `~/.local/share/browser-use/extension`.
  71. 2. That's it — **Portable Browser Bridge** connects automatically in the background (hover the icon to check status, or click to pause/reconnect).
  72. 3. Restart your coding agent so it loads the MCP tools.
  73. ### Ask your agent
  74. Once connected, just ask in plain English:
  75. ```text
  76. Open http://127.0.0.1:3000 in a Chrome tab group called "App QA".
  77. Test the signup form on desktop and mobile sizes, check for any console
  78. or failed network errors, save an element screenshot of the signup card,
  79. and leave the final tab open for me to check.
  80. ```
  81. ## How it works
  82. ### 1. Everything stays on your computer
  83. Your agent talks to a local MCP server (`v4.8.1`), which sends commands straight into your running Chrome browser through a lightweight extension (`v0.6.4`). There is no cloud service, no Playwright browser download, and no hidden background server.
  84. <img src="docs/assets/how-it-works-architecture.png" alt="4-layer local flow from AI Agent to MCP Server to Local Bridge to Chrome Tab" width="100%" />
  85. ### 2. One turn, tiny token usage, zero wasted waiting
  86. Instead of taking one tiny step per AI message, your agent can run a whole multi-step flow (up to `300,000` ms / `5` min per `browser_run` call) and even process up to `10` URLs in parallel (`browser.tabs.content()`). Page snapshots default to `mode: "compact"` (with `"full"` and `"interactive"` available) across `browser_run`, `browser_batch`, and `ariaSnapshot()`, share a unified AX diff baseline across `ariaSnapshot()` and `getState()`, support scoped `locator.ariaSnapshot()` subtrees (such as a single dialog or card), structured content export (`browser_get_content` & `page.content.export()` / `.tables()` / `.links()`), CSS-scaled screenshots (`max_width` default `1280` px, JPEG quality `75`), and diff-only updates — keeping token usage tiny.
  87. In `v4.7.0`–`v4.8.1`, `browser_run` adds zero-bloat local file helpers (`saveFile`, `readFile`, `saveScreenshot` with `emit: true`, `nodeRepl` alias) that auto-report `saved_files` metadata, tightly clipped `locator.screenshot()` / `page.elementScreenshot()`, `tab.ax.paste()` / `tab.ax.selectText()`, `page.innerText()` / `page.textContent()` / `page.check()` shorthands, read-only `evaluate()` support for local `{}`/`[]` container builds, network response body capture via `tab.dev.enableNetwork({ captureBodies: true })` + `tab.dev.responseBody(requestId)`, consolidated auto-uncollapsing Chrome Tab Groups, and `--profile auto` client selection.
  88. <img src="docs/assets/how-it-works-workflow.png" alt="One-call workflow: run script, read only what changed, and act without timer polling" width="100%" />
  89. <details>
  90. <summary><strong>Example: parallel multi-URL extraction, file output, and element Proof of Work</strong></summary>
  91. ```json
  92. {
  93. "name": "browser_run",
  94. "arguments": {
  95. "return_state": "none",
  96. "end_turn": true,
  97. "code": "await browser.nameSession('Docs Audit', 'cyan');\nconst pages = await browser.tabs.content([\n 'https://example.com/docs',\n 'https://example.com/pricing'\n], { format: 'markdown', concurrency: 2 });\nconst saved = await saveFile('/abs/path/docs-export.json', pages);\nconst pricingTab = await browser.tabs.new('https://example.com/pricing');\nawait pricingTab.locator('css=.plan-card').first().saveScreenshot('/abs/path/plan-card.png', { padding: 12, emit: true });\nawait pricingTab.markDeliverable();\nreturn { extracted: pages.length, file: saved.path };"
  98. }
  99. }
  100. ```
  101. Or pass a list of steps (`goto`, `set_viewport`, `locator_fill`, `locator_click`, `wait`, `get_state`, `get_content`, `read_tab`, `evaluate`) to `browser_batch`.
  102. </details>
  103. ### 3. Control existing open tabs or isolated agent tabs — with non-blocking virtual cursor
  104. Your agent can open fresh tabs in its own colored Chrome Tab Group (with `target="_blank"` popups auto-claimed and observable via `page.waitForEvent("popup")`), read an open user tab passively without attaching the Chrome debugger (`browser.tabs.read(id)` / `browser.user.getTabContext(id)` and passive `browser_get_content` via `chrome.scripting.executeScript`), or claim a specific matching tab you already have open. While your agent works, a virtual cursor and tab badge show where it clicks and types (`BROWSER_USE_CURSOR_MODE=fast|smooth|off`; `fast` is default with `0` ms blocking). When the task finishes, temporary agent tabs close automatically while your own tabs are safely released and left open.
  105. <img src="docs/assets/how-it-works-isolation.png" alt="Chrome Tab Groups keeping Personal Tabs untouched while isolating Agent A and Agent B" width="100%" />
  106. ## What you can do
  107. | What you want to do | How it helps |
  108. | --- | --- |
  109. | **Test your web app** | Fill out forms (including rich-text smart fill for CKEditor 4/5, TinyMCE, Quill, `contenteditable`, and `ax.paste`/`ax.selectText`), test mobile/desktop viewports, capture element screenshots (`locator.screenshot()`), and inspect console errors or API response bodies (`dev.responseBody()`). |
  110. | **Scrape & check multiple pages cleanly** | Extract up to `10` URLs in parallel (`browser.tabs.content()`), run 5-minute (`300s`) pagination loops, save bulk results to disk with `saveFile()` without bloating chat context, and read `page.assets.list()` or WebMCP tools (`page.webmcp`). |
  111. | **Click tricky UIs** | Works inside Shadow DOM, same/cross-origin iframes (OOPIFs), file upload pickers, and long file downloads, with closest-locator fallback hints on `not_found` timeouts. |
  112. | **Keep Chrome neat** | Group an agent's tabs under a named, colored Chrome tab label while temporary tabs clean themselves up automatically. |
  113. | **Handle logins & CAPTCHAs safely** | Never tries to bypass security checks — the agent pauses (`handoff`) and leaves the tab open so you can sign in yourself. |
  114. ## Why it's better
  115. | Feature | Playwright / Screenshot MCPs | Codex Built-in Browser Use | `codex-browser-use` |
  116. | --- | :---: | :---: | :---: |
  117. | Works with any coding agent | ✅ | ❌ Codex only | ✅ Any MCP agent |
  118. | Uses your real Chrome (no extra browser) | ❌ Heavy extra browser | ✅ | ✅ |
  119. | 100% open-source MIT (no closed binary) | ✅ | ❌ Closed runtime | ✅ Pure Node.js + MV3 |
  120. | Multi-step scripts & parallel tabs in 1 call | ❌ One step per turn | ✅ | ✅ + `tabs.new` & `tabs.content` |
  121. | Short numbered outlines + local `saveFile` | ❌ Huge DOM / PNGs | ✅ | ✅ Diff-first + `mode` compression |
  122. | Named Chrome Tab Groups | ❌ | ✅ | ✅ |
  123. | Fast local speed without timer polling | ❌ Slow per-step wait | ✅ | ✅ Up to 6.83x faster in parallel |
  124. Under the hood, commands run in parallel over the local bridge and wait directly on Chrome page events instead of polling on timers — making 4-tab parallel runs **6.83x faster** and full page + iframe + screenshot reads **~3x faster**. Across `v4.6.0`–`v4.8.1`, the persistent in-page locator runtime cache (`globalThis.__buRt` v2) cuts 10 warm locator payloads from `379,520` bytes to `1,260` bytes (**99.7% reduction**), `compact` AX snapshots shrink output by **81.7%** (`3,812` → `699` chars), `markdown` content extraction shrinks raw text by **94.1%** (`1,524` → `90` chars), and `--profile compact` cuts MCP tool schema size by **75.4%**. In a live end-to-end Chrome agent benchmark on the exact same model (`gpt-6.1-terra`, medium), `codex-browser-use` (`--profile compact`) completed the 4-task suite **28.8% faster** (`55.79s` vs `78.38s`) with **3.80x faster** browser execution (`3.48s` vs `13.21s`) and **51.9% fewer total input tokens** (`305,934` vs `636,008`) than Codex's built-in Chrome plugin.
  125. <details>
  126. <summary><strong>See full benchmark numbers &amp; run it yourself</strong></summary>
  127. #### Live Same-Model Agent Benchmark (`gpt-6.1-terra medium`, Real Chrome)
  128. Measured end-to-end with [agent-benchmark.mjs](mcp-server/bench/agent-benchmark.mjs) against a deterministic 4-task Chrome portal (2-page modal scraping, Shadow DOM + `contenteditable` form submission, screenshot Proof of Work, and token audit; both scored **100/100**):
  129. | Metric | Codex Built-in Chrome Plugin (`node_repl:js`) | `codex-browser-use v4.8.1` (`--profile compact`) | Verified Gain |
  130. | --- | ---: | ---: | --- |
  131. | **Grade** | `100 / 100` | **`100 / 100`** | Equal accuracy (`8/8` modals, `1` submit) |
  132. | **Total Wall-Clock** | `78.38s` (`78,380 ms`) | **`55.79s`** (`55,792 ms`) | **28.8% faster** (`-22.59s`) |
  133. | **Time to First Browser Action (TTFA)** | `28.65s` (`28,646 ms`) | **`12.86s`** (`12,860 ms`) | **55.1% faster** |
  134. | **Browser Execution Time** | `13.21s` (`13,207 ms`) | **`3.48s`** (`3,476 ms`) | **3.80x faster** (`-73.7%`) |
  135. | **Browser Tool Calls** | `12` | **`8`** | **33.3% fewer calls** |
  136. | **Total Input Tokens (incl. cache)** | `636,008` | **`305,934`** | **51.9% fewer tokens** |
  137. | **Uncached Input Tokens** | `52,584` | **`20,494`** | **61.0% fewer uncached tokens** |
  138. Run the live agent benchmark on Chrome (`same-model`, `head-to-head`, or `all`):
  139. ```sh
  140. npm --prefix mcp-server run bench:agents -- --mode same-model
  141. ```
  142. #### Core IPC &amp; Payload Micro-Benchmarks
  143. Measured on Node `v26.13.0` with [perf-benchmark.mjs](mcp-server/bench/perf-benchmark.mjs) using real local sockets, Native Messaging streams, in-memory MCP transport, and simulated page latencies held identical before vs. after optimization:
  144. | What was measured | Before / Baseline | After / Optimized | Verified Gain |
  145. | --- | --- | --- | --- |
  146. | **4 Parallel Tabs** (`goto` + read page) | `606.79 ms` | **`88.86 ms`** | **6.83x faster** (`-85.4%`) |
  147. | **Page + 4 Iframes + Screenshot** | `267.63 ms` / `226.38 ms` | **`90.88 ms`** / **`72.59 ms`** | **2.94x** cold / **3.12x** warm |
  148. | **Wait for Page Load** (+ assets) | `130.54 ms` (`10` polls) | **`113.58 ms`** (**`0`** polls) | **Zero polling checks** |
  149. | **Wait for Element & Text** (`90ms` delay) | `406.74 ms` (`8` checks) | **`289.37 ms`** (`3` checks) | **1.41x faster** / `-62.5%` calls |
  150. | **Fill 10 Fields in a Row** | `399.85 ms` (`40` calls) | **`187.89 ms`** (`20` calls) | **2.13x faster** (half the calls) |
  151. | **Click 10 Times Inside an Iframe** | `494.31 ms` (`51` calls) | **`151.28 ms`** (`15` calls) | **3.27x faster** (`-70.6%` calls) |
  152. | **Extension Stream & 40 Large Replies** | `34.18 ms` / `120` msgs | **`26.57 ms`** / **`40` msgs** | `-22.3%` CPU / **`-66.7%` msgs** |
  153. | **40 MB Over Local Socket** | `263.01 ms` (`152.1 MB/s`) | **`132.20 ms`** (**`302.6 MB/s`**) | **~2.0x throughput** |
  154. | **Locator Runtime Cache (`10` calls)** | `379,520 B` (`2.73 ms`) | **`1,260 B`** (**`1.13 ms`**) | **99.7% smaller payload** |
  155. | **MCP Tool Schema (`compact` vs `full`)** | `30,302 B` (`~7,576` tok, `36` tools) | **`7,457 B`** (**`~1,865` tok, `7` tools**) | **75.4% smaller schema** |
  156. | **AX `compact` & Markdown Content** | `3,812` AX / `1,524` text chars | **`699`** AX / **`90`** md chars | **81.7%** AX / **94.1%** content saved |
  157. Run the benchmark locally:
  158. ```sh
  159. npm --prefix mcp-server run bench
  160. ```
  161. </details>
  162. <details>
  163. <summary><strong>View all 36 MCP tools &amp; tool profiles (compact / standard / full)</strong></summary>
  164. Use `--profile compact|standard|full` (or `BROWSER_USE_TOOL_PROFILE`): **`compact`** registers 7 core tools (`browser_run`, `browser_batch`, `browser_get_state`, `browser_goto`, `browser_list_tabs`, `browser_screenshot`, `browser_end_turn`, cutting fixed tool schema size by `75.4%` from `30,302 B` / `~7,576` tokens to `7,457 B` / `~1,865` tokens); **`standard`** registers 14 tools (`~3,023` tokens); **`full`** (all 36 tools) is the default for lazy-loading clients.
  165. | Group | Tools |
  166. | --- | --- |
  167. | **Multi-step & Status** (`3`) | `browser_run`, `browser_batch`, `browser_status` |
  168. | **Read & Debug** (`8`) | `browser_get_state`, `browser_screenshot`, `browser_get_content`, `browser_dom_snapshot`, `browser_inspect_element`, `browser_console_logs`, `browser_network_logs`, `browser_evaluate` |
  169. | **Click, Type & Files** (`9`) | `browser_click`, `browser_set_value`, `browser_type_text`, `browser_press_key`, `browser_select_option`, `browser_hover`, `browser_drag`, `browser_scroll`, `browser_upload_files` |
  170. | **Smart Locators, Waits & Screen Size** (`4`) | `browser_locator_click`, `browser_locator_fill`, `browser_wait_for`, `browser_set_viewport` |
  171. | **Navigation, Tabs & Groups** (`9`) | `browser_goto`, `browser_back`, `browser_forward`, `browser_reload`, `browser_list_tabs`, `browser_new_tab`, `browser_select_tab`, `browser_close_tab`, `browser_name_session` |
  172. | **Popups & Cleanup** (`3`) | `browser_handle_dialog`, `browser_end_turn`, `browser_reset` |
  173. </details>
  174. ## FAQ
  175. <details>
  176. <summary><strong>Which coding agents work with this?</strong></summary>
  177. Any agent that supports local MCP tools: Antigravity, Claude Code, Codex CLI, Cursor, Windsurf, GitHub Copilot CLI, Command Code, OpenCode, or custom setups.
  178. </details>
  179. <details>
  180. <summary><strong>Can the agent see my personal tabs or saved passwords?</strong></summary>
  181. By default, the extension creates isolated tabs for the agent session and leaves your personal tabs, bookmarks, and unrelated windows untouched. When you explicitly ask to inspect an existing tab, passive reads (`browser.tabs.read(id)` / `browser.user.getTabContext(id)` / passive `browser_get_content`) run without attaching the Chrome debugger, and read-only page checks (`browser_evaluate`) block page edits, storage writes, and network calls.
  182. </details>
  183. <details>
  184. <summary><strong>Why not just use Playwright MCP?</strong></summary>
  185. Playwright installs heavy separate browsers, starts cold with no cookies or logins every time, and often sends large DOM dumps or full PNGs per action. `codex-browser-use` connects straight to your running Chrome — keeping your existing cookies, signed-in sessions, and ongoing work untouched — with short page outlines, named Tab Groups, local `saveFile`/`saveScreenshot`, and 1-call scripts.
  186. </details>
  187. <details>
  188. <summary><strong>What happens on login pages, 2FA, or CAPTCHAs?</strong></summary>
  189. Agents are told never to bypass logins or CAPTCHAs. When a page needs you to sign in, the agent pauses (`handoff`) and asks you to complete it in Chrome yourself, then picks right back up.
  190. </details>
  191. <details>
  192. <summary><strong>How do I update or check if everything is working?</strong></summary>
  193. Pull the latest code, run `node mcp-server/bin/browser-use.js install --client <your-client> --skill`, click **Reload** on **Portable Browser Bridge** in `chrome://extensions`, and run `node mcp-server/bin/browser-use.js doctor --json`.
  194. </details>
  195. ## Documentation
  196. Run tests, lint, and health checks anytime:
  197. ```sh
  198. npm --prefix mcp-server test
  199. npm --prefix mcp-server run lint
  200. npm --prefix mcp-server run bench
  201. npm --prefix mcp-server run bench:agents -- --mode same-model
  202. node mcp-server/bin/browser-use.js doctor --json
  203. ```
  204. - [Agent Skill Instructions](skill/SKILL.md) — workflow guide and v4.8.1 API reference installed for your coding agent
  205. - [Workflow Cookbook](skill/references/cookbook.md) — copy-paste recipes for pagination, passive reads, `responseBody()`, and screenshots
  206. - [Tool Profiles & Inventory](skill/references/tools.md) — `--profile auto|compact|standard|full` comparison and full 36-tool list
  207. - [Browser Policy Rule](rules/browser_use.md) — always-on safety and token-efficiency rules
  208. - [Compatibility & Engine Modes](docs/compatibility.md) — standalone setup details
  209. - [Transport & IPC Notes](docs/transport-investigation.md) — how the local socket and native bridge work
  210. - [Legacy v1 Notes](docs/legacy-v1.md) — older v1 architecture reference
  211. ## Contributing
  212. Issues and pull requests are welcome at [khanhle1406/codex-browser-use](https://github.com/khanhle1406/codex-browser-use).
  213. ## License
  214. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

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