Skip to content

Tool Pick|turbo-browser-mcp — 10 batched tools instead of 25 scattered ones

Nov 16, 20261 min
TL;DRturbo-browser-mcp merges @playwright/mcp's 25 fine-grained tools into 10 batched tools. Install: npx -y turbo-browser-mcp. It fixes the problem where every small browser action costs a full MCP round trip and the conversation history keeps growing.

Look up & save

Loading dictionary…

🌏 中文版

Tool Info

ItemValue
Nameturbo-browser-mcp
TypeMCP server
GitHubTthanh2k6/turbo-browser-mcp
Stars101 (at time of writing; repo created 2026-11-14)
LanguageJavaScript (Node.js, single dependency: playwright-core)
LicenseMIT
Installnpx -y turbo-browser-mcp (requires Node ≥ 20)

What Problem It Solves

Have you noticed how filling out one form with a browser agent can burn through a dozen tool calls? The standard pattern: snapshot the full ARIA tree, then fill one field at a time, select_option for dropdowns, a separate round for file uploads — and every single round resends the growing conversation history back to the model. A benchmark against a 10-field form took 11 turns and replayed over 70,000 tokens cumulatively, most of it the same barely-changed DOM tree being restated over and over.

turbo-browser-mcp's answer is to collapse @playwright/mcp's 25 fine-grained tools (browser_click, browser_type, browser_select_option, and so on) and chrome-devtools-mcp's 33 tools into 10 batched ones. inspect_compact returns a trimmed list of interactive elements by default, and with onlyChanged: true it returns only what changed since the last snapshot instead of rescanning the whole tree. smart_fill_form takes an entire list of fields at once — React-controlled inputs, Shadow DOM, fields inside iframes, contenteditable editors — fills them in one call, and validates the result in the same response. File uploads take a disk path directly, so a PDF never gets Base64-encoded into context. The README's own tiktoken-measured benchmark: the same 10-field form drops from 11 turns and 72,614 cumulative tokens to 1 turn and 811 tokens.

Just as important is the built-in human-in-the-loop submit guard: allowSubmit defaults to false, so anything that looks like a Submit, Publish, Send, or payment button gets blocked unless you explicitly pass allowSubmit: true. It's a good fit for agents that need to operate on web pages frequently and in many steps — scraping, automated testing, form-filling agents — especially when context window size or token cost is the bottleneck. It also suits workflows where an agent should fill out a form but a human needs to approve the actual submission.

Collapsing four separate calls into two batched calls
Collapsing four separate calls into two batched callsThe standard approach splits work into snapshot, field-by-field fill, select_option, and upload calls; turbo-browser-mcp merges these into a delta snapshot plus one batch fill. Before 11 turns · 72,614 cumulative tokens After 1 turn · 811 tokens snapshot full ARIA tree fill field one call per field ×10 select_option dropdown needs its own turn upload inline Base64 inspect_compact delta snapshot, onlyChanged smart_fill_form batch fill + direct disk upload − − − − + + Changes − Removed: 4 separate calls — snapshot, per-field fill, select, upload + Added inspect_compact: returns only what changed + Added smart_fill_form: fills the form and uploads files in one call

Turn counts and token counts come from the README benchmark (10-field form, measured with tiktoken o200k_base); the call stages shown here are simplified.

Quick Start

Install

# Option 1: run directly with npx (fastest)
npx -y turbo-browser-mcp

# Option 2: local clone, with an environment check
git clone https://github.com/Tthanh2k6/turbo-browser-mcp.git
cd turbo-browser-mcp
npm install
npm run doctor   # prints Node / Playwright / Chromium / CDP diagnostics

# If no Chrome/Edge/Brave is installed, grab Playwright's bundled Chromium
npx playwright-core install chromium

MCP client config (same shape for Claude Code, Cursor, and Codex):

{
  "mcpServers": {
    "turbo-browser": {
      "command": "npx",
      "args": ["-y", "turbo-browser-mcp"]
    }
  }
}

Basic Usage

You: Open example.com/signup and fill out the registration form with this
     data, but don't submit it yet.

What the agent actually calls:
1. tabs_batch { operations: [{ op: "open", url: "https://example.com/signup" }] }
2. inspect_compact { mode: "forms" }                      → form elements only, ~1,000 tokens
3. smart_fill_form { fields: [...10 fields...], returnSnapshot: true }
   → fills text fields, dropdowns, and checkboxes in one call, returns the
     filled-in snapshot for confirmation
4. Submitting for real requires passing allowSubmit: true — otherwise
   clicking Submit gets blocked

Advanced Usage

// Turn off image/media loading before scraping a page — saves bandwidth
// and cuts the diagnostics noise that comes with unrelated requests
{
  "name": "network_session",
  "arguments": { "preset": "turbo" }
}
// Hand off to a human when a login or bot check blocks the flow; the agent
// resumes in the same tab once the condition is met
{
  "name": "wait_for_human",
  "arguments": {
    "message": "Please finish logging in or pass the verification, then leave the window open.",
    "selector": "#account-menu",
    "timeoutMs": 120000
  }
}

Comparison with Existing Tools

turbo-browser-mcp@playwright/mcpchrome-devtools-mcp
Tool count10 (batched)25 (fine-grained)33 (fine-grained)
Delta snapshots (only changed elements)✅❌ (full ARIA tree every time)❌
Fill an entire form in one call (React/Shadow DOM/iframe)✅❌ (needs multiple calls)Basic fill_form only
File upload without Base64 (direct disk path)✅Needs a separate browser_file_upload callNeeds a separate upload_file call
Default human-in-the-loop submit guard✅❌❌
Lighthouse / performance tracing / heap snapshots❌❌✅

Caveats

  • Still a new project. The repo was created on 2026-11-14 and has 101 stars. It does have CI (400+ tests across Node 20/22), but a low issue count doesn't mean there are no edge cases — test it yourself before wiring it into anything that touches real money or real data.
  • The submit guard isn't an anti-detection mechanism. The README is explicit that it does no stealth, doesn't patch navigator.webdriver, and doesn't solve CAPTCHAs. For sites that detect automation, use --open-profile to let a human log in or pass verification in a normal Chrome window first, then have the agent take over the same browser profile.
  • The network submit guard is off by default. TURBO_BROWSER_NETWORK_GUARD defaults to false because multi-step wizards often POST on every "Next" click; turning it on without checking your flow first can block normal navigation.

Today's Takeaway

I used to think MCP tools should be sliced as finely as possible, so an agent could call exactly what it needed. turbo-browser-mcp's benchmark makes the opposite case: the real cost of a tool call isn't just the tokens in that one call — it's that every round trip resends the entire conversation history. Ten rounds means ten history replays, and that adds up to far more than the output tokens of a single round. Batching actions that naturally happen together — filling every field in a form, opening several tabs — trades away call-by-call flexibility for savings that scale with the number of rounds. It's a useful check for anyone designing an agent's tool surface: ask whether a group of actions usually happens together before assuming every low-level operation deserves its own tool.

References