Skip to main content
Glama

BrowserDo

Website: embiody.com/browserdo

Listed on mcpservers.org

BrowserDo demo: the agent fills 4 form fields in 2.5 seconds, shops in its own tabs, keeps going while minimized, fills a checkout in one combo and hands you the tab to pay

Built for AI agents. Shared with people.

Embiody is a Windows browser your AI agent works in, in the background and at full speed, while you keep using your PC and can step in at any time. BrowserDo is the MCP server that connects your agent to it. Add it to Claude Code, Claude Desktop, Codex, Cursor, VS Code or Gemini CLI, and your agent can browse, click, type and read pages, including sites you are signed in to.

Why BrowserDo

Each point below has a short clip recorded on real sites. The side-by-side ones run the same task at the same moment through Playwright MCP and BrowserDo, from one Claude Code session.

1. Works in the background at full speed, and leaves your screen to you

Chrome and Embiody countdowns in a background tab, behind a window and minimized Chrome and Embiody countdowns in a background tab, behind a window and minimized. Click for the 38-second clip.

Pages run at full speed in background tabs, background windows, minimized windows and hidden windows. Your agent does not need the browser in front of you, so you keep using your computer while it works, and it can work in a dozen tabs at once.

Ordinary Chrome slows down pages you are not looking at. In our test, a browser window was completely covered by another window for 7 minutes:

Timers

A countdown on the page

Embiody, front tab

10 per second throughout

on time

Embiody, background tab

10 per second throughout

on time

Chrome, front tab

slowed down after 12 seconds

355 seconds behind

No launch flags are needed for this. One limit: a page opened while its window is minimized may come back without a screenshot; its text and element numbers are still there.

2. Works where bots get blocked — because it isn't one

Walmart, Target, adidas and realtor.com stop Playwright MCP with a bot check; Embiody goes straight through Walmart, Target, adidas and realtor.com stop Playwright MCP with a bot check; Embiody goes straight through. Click for the 24-second clip.

Your agent works in your own browser, on your behalf, so sites with anti-bot protection treat it the way they treat you. We also signed in to an account on a site protected by a leading commercial bot-detection service, the kind that usually stops automation tools.

3. Sees the whole page and clicks the right thing

On nytimes.com a privacy overlay swallows Playwright MCP’s click; BrowserDo gives the agent only the overlay’s buttons, so it closes it first On nytimes.com a privacy overlay swallows Playwright MCP’s click; BrowserDo gives the agent only the overlay’s buttons, so it closes it first. Click for the 28-second clip.

  • Elements covered by a popup or overlay get no number, so the agent can't click something you can't see.

  • Content inside embedded frames from other sites, such as payment forms and sign-in boxes, can be read and clicked.

  • Long pages are read whole, not only the part on screen.

  • An element off screen is scrolled into view before it is clicked.

  • Clicks land where they should across multiple monitors and at any display scaling.

  • Every element number belongs to one snapshot. A number from an older snapshot is refused before anything is clicked, instead of hitting whatever took its place.

4. You can see what the agent is doing

The "AI-controlled tab" badge, then the highlighted border and the agent’s own cursor The "AI-controlled tab" badge, then the highlighted border and the agent’s own cursor. Click for the 15-second clip.

A tab the agent is working in shows a virtual mouse pointer, a frame around the page and a marker on the tab. Open it any time to watch.

5. You and the agent share one tab

Disputing a charge on Uber Help: the agent hands you the tab for the sign-in code, then takes it back Disputing a charge on Uber Help: the agent hands you the tab for the sign-in code, then takes it back. Click for the 38-second clip.

The agent fills in the forms; you step in for the sign-in code, the captcha or the payment, then hand the tab back, and the agent picks up where you left off. If you click or type in a tab the agent is working in, you are asked whether to take it over. The agent asks before it touches a tab of yours.

6. Fewer tokens for the whole page

Tokens per whole-page snapshot: Playwright MCP, Chrome DevTools MCP and BrowserDo on Wikipedia, GitHub, CNN, ESPN and Apple

The browser engine itself boils each page down for the agent: its text, plus every element the agent can act on, numbered. On Wikipedia, GitHub, CNN, ESPN and Apple, a whole-page snapshot took 37% of the tokens of Playwright MCP's (o200k tokenizer, same 1600×1000 viewport, November 2026), and the agent can read just the screen it is working on.

7. Several steps in one call

Real speed: the agent fills 4 form fields in 2.5 seconds with one call Real speed: the agent fills 4 form fields in 2.5 seconds with one call. Click for the 3-second clip.

browser_batch runs several actions (clicks, typing, key presses) in a row and returns a fresh snapshot of the page, so the agent needs fewer round trips and fewer tokens. A step can wait for a text to appear and aim at the element showing it ("type, wait for the suggestions, click the second one" in one call), and the snapshot can be cut to the lines that changed.

8. Reads the page itself, not a summary

A JB Hi-Fi search page: Claude Code’s built-in fetch gets a browser warning and 0 products; BrowserDo reads all 18 with prices A JB Hi-Fi search page: Claude Code’s built-in fetch gets a browser warning and 0 products; BrowserDo reads all 18 with prices. Click for the 30-second clip.

browser_read_pages returns the page's own text, links included, from pages built by scripts and from sites you are signed in to. It can stand in for Claude Code's WebFetch, which fetches the page without running its scripts and hands back a short model-written summary.

9. Sees the browser's own popups

McDonald’s store finder asks for your location: Playwright MCP’s agent never sees the prompt; BrowserDo reports it and the agent allows it once McDonald’s store finder asks for your location: Playwright MCP’s agent never sees the prompt; BrowserDo reports it and the agent allows it once. Click for the 30-second clip.

Permission bubbles, menus, Save As dialogs, "Leave site?" prompts and alerts are reported in every snapshot, with the ways each one can be answered.

10. Current engine, signed releases

Built on Chromium 156. The installer carries the digital signature of SELECTIOUS PTY LTD, which BrowserDo verifies before running it, and the browser updates itself, checking the signature of every update.

Related MCP server: Echo

Requirements

  • Windows 10 or 11, 64-bit (Embiody is Windows only for now)

  • Node.js 20 or newer. Check with node -v. Without it, BrowserDo fails to start (Claude Code shows "Failed to connect"). Install it with winget install OpenJS.NodeJS.LTS, then restart your client.

  • The Embiody browser, version 0.9.0.3 or newer: installed automatically the first time BrowserDo starts. That is a download of about 140 MB and takes a few minutes; your client can use BrowserDo at once, and until the browser is ready each tool replies with the progress. With an older one, BrowserDo opens the browser's update page and asks you to restart the browser and BrowserDo once it has updated (details).

No API key is needed. Your agent drives the browser with its own model.

Install

BrowserDo runs as npx -y browserdo-mcp. Pick your client and follow only that section; the others are for other clients.

Claude Code

claude mcp add browserdo -- npx -y browserdo-mcp

Add --scope project to share it with your team through .mcp.json, or --scope user to use it in every project.

Claude Desktop

Edit %APPDATA%\Claude\claude_desktop_config.json:

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

Codex

codex mcp add browserdo -- npx -y browserdo-mcp

Or add to ~/.codex/config.toml:

[mcp_servers.browserdo]
command = "npx"
args = ["-y", "browserdo-mcp"]

Cursor

Add to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "browserdo": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "browserdo-mcp"]
    }
  }
}

VS Code

Run MCP: Add Server from the Command Palette, choose Command (stdio) and enter npx -y browserdo-mcp. Or add to .vscode/mcp.json:

{
  "servers": {
    "browserdo": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "browserdo-mcp"]
    }
  }
}

Gemini CLI

Add to ~/.gemini/settings.json (all projects) or .gemini/settings.json (one project):

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

Other MCP clients

Add a local (stdio) MCP server in your client's settings, with command npx and arguments -y browserdo-mcp. Most clients take it in this shape:

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

The skill

The browserdo skill tells your agent when and how to use these tools, for example to search with BrowserDo instead of a built-in search tool. BrowserDo installs it the first time it starts (see Privacy). To install it on its own, for example before adding BrowserDo, run npx skills add zhaijunlong/browserdo -g (the skills command needs Node.js 22.20 or newer and Git). An agent that has the skill but not the tools offers to add BrowserDo for you.

Then ask your agent to do something on the web:

Find me a direct flight from Sydney to Melbourne next Wednesday morning and show me the three cheapest options.

Tools

Each tool is one browser action. windowId and tabId are optional everywhere; leave them out and the frontmost window and tab are used.

Tool

What it does

browser_take_snapshot

The page as one line per element, each actionable element with a number, plus the page position, URL, title, any popups in the way and a snapshotId. Says when the page is a PDF, an error page or a crashed tab. includeImage adds the annotated screenshot; readWholePage reads beyond the screen; changesSince gives only the lines changed since an earlier snapshot.

browser_read_pages

Read up to 10 pages at once in background tabs and get their text, with links as footnotes.

browser_batch

Several actions on one tab in a row, then a fresh snapshot (whole, only the changes, or none). A step can aim by text at what an earlier one made appear, and may be skipped when it fails. Stops at the first failure otherwise.

browser_click, browser_input_text, browser_press_key, browser_select_editable_text, browser_scroll

Act on an element by its number and the snapshotId it came from. browser_input_text can also edit at a place named by the surrounding words.

browser_move, browser_drag

Hover; press, carry and release. Drag works sliders, canvases and reorderable lists.

browser_navigate, browser_go_back, browser_go_forward, browser_reload, browser_stop_loading, browser_wait

Getting around.

browser_get_window_info, browser_new_window, browser_close_window, browser_show, browser_minimize

Windows. browser_get_window_info lists every window and tab with their ids.

browser_new_tab, browser_select_tab, browser_close_tab, browser_set_audio_muted

Tabs.

browser_close_popup_bubble

Answer a permission bubble or dialog.

browser_start_human_control, browser_stop_human_control

Hand the tab to a person for a password or captcha, then take it back.

browser_status

Whether the browser is ready, or how far its first install has got.

Settings

Set these in the env block of your client's config, or put them in a config file (copy browserdo.config.example.yaml to browserdo.config.yaml next to where the server runs, or pass --config <path>). Environment variables win over the config file.

Variable

What it does

EMBIODY_TOOLS

browser (the tools above), task (browser_run_task only) or all (default).

EMBIODY_SAVE_SNAPSHOTS

1 saves every snapshot's screenshots and page text under run/browser_data, for debugging. Off by default.

EMBIODY_EXE_PATH

Launch your own Embiody build, on a separate profile, instead of the installed one.

EMBIODY_USER_DATA_DIR

Give the agent a separate profile folder instead of your own Embiody; BrowserDo then starts a browser of its own on it.

EMBIODY_VLLM_ENDPOINT, EMBIODY_VLLM_MODEL, EMBIODY_VLLM_API_KEY

The model for browser_run_task (below).

The example config file explains the rest: fallback models, timeouts, how long to let pages settle. --transport sse serves MCP over HTTP at http://127.0.0.1:3000/sse instead of stdio; it answers this machine only.

Privacy

BrowserDo has no telemetry, usage statistics or error reporting.

  • Downloads: the first time it starts without Embiody installed, it downloads the installer from GitHub, or from a mirror if GitHub can't be reached. The installer carries the digital signature of SELECTIOUS PTY LTD; BrowserDo checks it before running the installer and refuses one that is unsigned or signed by anyone else.

  • Updates: when your client starts BrowserDo with npx, npm checks the npm registry for the latest version when it starts BrowserDo. That request is made by npm, not by BrowserDo.

  • Your model: only browser_run_task sends anything to a model, and only to the endpoint you configure. The browser tools return pages to your own agent.

  • On your computer: a debug log at %LOCALAPPDATA%\Embiody\BrowserDo\logs records the URLs visited and the steps taken, never page content or your task. It keeps at most three 5 MB files. Snapshots are not saved unless you set EMBIODY_SAVE_SNAPSHOTS=1.

  • Skill files: when it starts, BrowserDo puts its skill in ~/.claude/skills/browserdo (read by Claude Code), ~/.agents/skills/browserdo (Codex, Cursor, Gemini CLI) and ~/.copilot/skills/browserdo (GitHub Copilot in VS Code), each only when such an agent is installed. It never replaces a skill of the same name that it did not put there, keeps its own up to date, and does not put one back once you delete it. The Claude plugin carries the skill itself, so with the plugin it leaves ~/.claude/skills alone.

  • Your profile: the agent works in your own Embiody, in its Default profile, so it can use the sites you are signed in to there. Other Embiody profiles are not used, and neither are other browsers on your computer, such as Chrome or Edge. To keep the agent apart, set EMBIODY_USER_DATA_DIR to a folder of its own.

See the privacy policy and the Embiody end-user license agreement.

Optional: browser_run_task

If you would rather hand over a whole task than drive the browser step by step, browser_run_task runs it inside BrowserDo with a vision model of your choice (any OpenAI-compatible endpoint), and keeps the screenshots out of your agent's context.

"env": {
  "EMBIODY_VLLM_ENDPOINT": "<your-openai-compatible-endpoint>",
  "EMBIODY_VLLM_MODEL": "<your-vision-model>",
  "EMBIODY_VLLM_API_KEY": "<your-api-key>"
}

Parameter

Notes

task

Required. The task, in plain language.

windowId, tabId

Pass both to continue an earlier task in the same tab.

maxRounds

Default 12.

closeTabWhenDone, closeBrowserWindowWhenDone

Default false.

humanReply

Your answer to the question a previous run stopped on, when your client can't ask you mid-task.

When the task needs you, it asks. A step only you can do, like a password or a code sent to you, hands you the tab first and continues once you say you're done. In clients that support questions during a task (tasks.requests.elicitation.create, as in Claude Code), the question appears in your conversation; elsewhere the task ends with the question, and you answer by calling it again with humanReply.

browser_stop_task stops a running task at the end of its current step.

Keep your API key out of files that get committed. If your client can expand environment variables in its config, use that; otherwise keep the key in a config file outside the repository and point at it with --config.

Notes

  • Claude Code keeps old tool definitions in a conversation. After BrowserDo is upgraded, start a new conversation to see new tools and parameters.

  • BrowserDo speaks MCP protocol version 2025-11-25 and negotiates down to older versions.

Development

npm install
npm run build
npm test          # 902 tests
npm run test:fast # unit and module tests only

See test/README.md for the test layout.

License

BrowserDo is licensed under the Apache License, Version 2.0; see LICENSE. The Embiody browser it installs is covered by the Embiody EULA.

Available Tools

31 tools
browser_batch

Run several page actions on one tab in a row, then get a fresh snapshot back — one call instead of one per step; worth it for a single action too. Steps aim with the numbers of one snapshot. For something an earlier step makes appear (a suggestion list, a menu), wait for it with browser_wait forText, then aim with find instead of emsn: {"tool": "browser_click", "args": {"find": {"text": "Bluetooth headphones"}}}. Stops at the first failure, unless the step says onFail: skip (a banner that may not show). After a step the browser says changed the page, the later steps that aim by number are not run; waits and finds still are.

Inputs: actions (required), tabId, snapshot, windowId, +1 more.

browser_clickA

Click an element by its number (emsn) from the latest snapshot. The kernel asks the page where that element is right now and refuses if it has gone, moved out of reach, or is covered by something else — it does not pretend to succeed. Passing x/y instead skips all of that checking, so prefer emsn.

Inputs: snapshotId (required), x, y, emsn, +4 more.

browser_close_popup_bubbleA

Answer the popup blocking a tab (permission bubbles, dialogs). browser_take_snapshot reports which popups are open and what each one accepts. When unsure use dismiss: it refuses without writing a decision into the browser profile, where it would outlive the task.

Inputs: tabId, action, windowId.

browser_close_tabC

Close a tab.

Inputs: tabId, windowId.

browser_close_windowA

Close a browser window and every tab in it. Other windows are unaffected. To close a single tab use browser_close_tab.

Inputs: windowId (required).

browser_dragA

Press on something, carry it somewhere, let go. The one gesture a click cannot make, so this is for sliders, panning a canvas, split bars and lists that reorder. Give the destination exactly one way: toEmsn (with toX and toY for a spot inside it), or toX and toY, or dx and dy. Both ends must already be on screen — the far end is not scrolled into view, so scroll first.

Inputs: snapshotId (required), x, y, dx, +10 more.

browser_get_window_info

List every browser window and its tabs, with the windowId and tabId of each. When the person says a page is already open, call this to find its tab and work there rather than opening it again: they may have got it to a state that takes steps to reach.

Inputs: no named parameters.

browser_go_backA

Go back one step in this tab's history. browser_get_window_info reports whether a tab can go back; calling this when it cannot will fail.

Inputs: tabId, windowId.

browser_go_forwardB

Go forward one step in this tab's history.

Inputs: tabId, windowId.

browser_input_text

Type text into an element by its number (emsn), or into whatever has focus when no emsn is given. Fails, typing nothing, when the field does not take focus. Also sets a dropdown (SELECT, or its label): text is the option exactly as listed in its options; and a date (YYYY-MM-DD), time (HH:MM), date and time (YYYY-MM-DDTHH:MM), month (YYYY-MM), week (YYYY-Www) or colour (#rrggbb) field, without opening a picker. Use this rather than clicking a SELECT: its list is not in snapshots. To edit a text field or editable area (a mail body, a rich-text editor) in the middle, give one of before / after / replace / at with its emsn. Copy the words from its snapshot value as they are written there: \n for a line break, ¤ escapes kept; ‸ (the caret) and ⟦⟧ (the selection) are ignored. Not found, or found in several places without occurrence: nothing is typed and the places are listed. The text is read back afterwards and the reply quotes the changed lines; if they differ (the editor reformatted it), it fails saying the text was typed. Without these, text goes in at the caret; the element is clicked first unless focus is already in it. Text is typed key by key, about 50 characters a second: a few thousand take a minute or more, and the call waits for it.

Inputs: text (required), snapshotId (required), at, emsn, +8 more.

browser_minimizeA

Minimize one of your windows (every tab in it yours), to keep it out of a person's way while you work in it. Pages in it keep running at full speed and snapshots keep working. browser_show brings it back.

Inputs: windowId (required).

browser_moveA

Hover the pointer over an element, for a menu or a tooltip that only appears under it. Whatever appears is not numbered until you take a fresh snapshot, so hover first, then snapshot, then act. The reply says where the pointer ended up.

Inputs: snapshotId (required), x, y, emsn, +2 more.

browser_navigateB

Open a URL in a tab. Element numbers from before the navigation are void afterwards.

Inputs: url (required), tabId, windowId, timeoutMs, +1 more.

browser_new_tabB

Open a new tab. Returns the new tabId.

Inputs: url, windowId, timeoutMs, waitUntil, +1 more.

browser_new_windowB

Open a new browser window. Returns the new windowId.

Inputs: url, incognito, hideWindow.

browser_press_keyA

Press keys, in order, where focus is: Escape closes a dialog on the page, Tab moves to the next field, ArrowDown/Enter pick from a suggestion list, End or arrows move the caret before browser_input_text without emsn types there, Control+Z undoes. Not for typing text. Refused, nothing pressed: copy/cut/paste, and the browser's own shortcuts (use browser_close_tab, browser_reload and so on). Replies once the page has handled the last key; it does not say what the keys did, so snapshot to see. A list highlighted under the pointer counts arrows from that item, which a snapshot does not show: to pick a given item, click it.

Inputs: keys (required), snapshotId (required), emsn, tabId, +2 more.

browser_read_pagesA

Read web pages; use it instead of a built-in fetch tool (WebFetch): it returns the page's own text, not a summary, including pages built by scripts and sites the person is signed in to. Each URL opens in a background tab of an existing window, the whole page is read and the tab closed again, so nothing is left open. Returns each page's text with no element numbers — to act on a page, open it with browser_new_tab instead. Links are marked [^3], with the addresses after the text. Each page gives up to 15000 characters and says how to read on. One page failing does not fail the others. Not for search results URLs: engines often answer those with a captcha, so search by typing into the engine's own search box.

Inputs: urls (required), from, maxChars, windowId, +1 more.

browser_reloadA

Reload the tab. Element numbers from before the reload are void afterwards.

Inputs: tabId, windowId.

browser_run_taskA

Carry out a whole web task in a real browser and report what happened. This takes minutes, not seconds, and reports progress as it goes. Describe the task in plain language; it works out the steps itself. If it hits a login, a captcha or a payment screen it stops and hands the browser to the person, then picks up where it left off once they are done. Needs a vision model configured (EMBIODY_VLLM_*); for a small job you can drive the browser yourself with browser_take_snapshot / browser_click / browser_input_text instead, which needs no model.

Inputs: task (required), tabId, history, windowId, +7 more.

browser_scrollA

Scroll. Give deltaY (how far; positive is down, as scrollTop counts) or toY (where to end up; 0 is the top, 999999 the bottom), not both; deltaX / toX are the horizontal ones. What scrolls is whatever is under the pointer: to scroll a pane that scrolls on its own (a mail list, a results panel), give its emsn; emsn -1 scrolls the whole page, only when the snapshot's page position line offers it. Replies once the scroll is at rest, saying when it moved less than asked (at the end, or the page took the wheel); coordinates are void after a scroll, so take a fresh snapshot to see where you are.

Inputs: x, y, toX, toY, +10 more.

browser_select_editable_textA

Select words in a text field or editable area (a mail body, a rich-text editor), as a person drags over them, so a toolbar button (bold, colour, link) acts on them next: a click on it can follow in the same batch. Nothing else changes, except that a click giving it focus stays. Give one of select, from with to, or all. Copy the words from the element's snapshot value as for browser_input_text's before/after. The reply quotes the lines the selection is on, marked ⟦…⟧. Refused, nothing selected: not found, or in several places without occurrence (the places are listed); an end inside a picture, a list number or an @mention; across table cells where the editor keeps a selection in one cell (select cell by cell); over a picture with its own editable caption (click the picture instead); a password, read-only or disabled field.

Inputs: emsn (required), snapshotId (required), to, all, +6 more.

browser_select_tabC

Bring a tab to the front of its window.

Inputs: tabId (required), windowId (required).

browser_set_audio_mutedC

Mute or unmute a tab.

Inputs: muted (required), tabId, windowId.

browser_showA

Bring a window on screen. Windows driven by an agent are often hidden or off screen, so show one before asking a person to look at it.

Inputs: windowId (required), toState.

browser_start_human_controlA

Hand the tab to a person so they can use the real keyboard and mouse on it. Required for anything only a person can do — a password, a code sent to them, a captcha, proving who they are — because while the agent drives the tab their physical input does not reach the page at all. The window is brought on screen. While the person has it, every command on that tab fails except browser_take_snapshot, which is how you tell when they are done. Call browser_stop_human_control to resume.

Inputs: tabId, windowId, showWindow.

browser_status

Say whether the browser is ready, without doing anything in it. On first use BrowserDo downloads and installs the Embiody browser, which takes a few minutes; until then every other tool replies with the progress instead of acting, and this one reports it.

Inputs: no named parameters.

browser_stop_human_controlA

Take the tab back and resume automating it. A handover the agent started can be ended freely; if the person took the tab over themselves, they are asked first and may refuse.

Inputs: tabId, windowId.

browser_stop_loadingA

Stop the page loading in this tab, like the browser's stop button. This is about page loading only. To stop a running browser_run_task, use browser_stop_task.

Inputs: tabId, windowId.

browser_stop_taskA

Stop a running browser_run_task, by the ID that browser_run_task returned. The task stops at the end of its current step and does not resume. Optionally closes the tab or the whole browser window it was using; other windows are left alone. This is not the same as cancelling the task at the protocol level: that is advisory and may be ignored, and it cannot tidy up the browser. To stop a page loading rather than a task, use browser_stop_loading.

Inputs: taskId (required), closeTab, closeBrowserWindow.

browser_take_snapshot

Look at a tab: returns one line per element, the page position, the tab's URL and title, any popups blocking it, and a snapshotId. Every actionable element carries a number (emsn) at the start of its line; a link inside a sentence stays in it as words, number 12 — act on the number, never on pixel coordinates. Take a fresh snapshot after anything that changes the page, to see what it became: elements that appear have no number until then. Says so when the page is a PDF, a browser error page or a crashed tab, each of which makes the obvious next move useless. Give tabIds to look at several tabs in one call; each comes back with its own snapshotId. Marks on a line: collapsed (in a closed section: open it first), modal (the page outside it takes no clicks), hover-only (may do nothing on a click), also dblclick / drag / ... (other listeners, perhaps only tracking; the list misses some: a list item without drag may still drag, a spreadsheet cell without right_click may still take one: try it and snapshot), options (a dropdown's choices), readonly (takes no typing; clicking it often opens the page's picker), aria-readonly (the page says not to type, typing still goes in).

Inputs: tabId, format, tabIds, windowId, +5 more.

browser_wait

Wait a set time (durationMs, 100–10000 ms), or until a text is on the page (forText) or gone from it (gone: true): every half second the screen and about 8000px around it are read, words, names and values alike, case and spacing aside. Fails when the time runs out (timeoutMs, default 5000, at most 30000).

Inputs: gone, tabId, forText, windowId, +2 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 31 tools

    Disambiguation4/5

    Most tools target distinct actions and the descriptions explicitly disambiguate close pairs (stop_loading vs stop_task, close_tab vs close_window, press_key vs input_text). A few tools overlap in intent — navigate vs new_tab vs read_pages all 'open a page', and batch vs the individual step tools — but descriptions keep them separable.

    Naming Consistency5/5

    Every tool uses the browser_ prefix with snake_case, and most follow browser_<verb>_<noun> (close_tab, take_snapshot, input_text). The verb-only variants (reload, wait, scroll, show, minimize) are still unambiguous and consistent within the scheme.

    Tool Count3/5

    31 tools is heavy for the 3-15 sweet spot, though browser automation genuinely has many distinct capabilities and batch consolidates some. Still, there are many niche gestures (drag, move, select_editable_text) that push the surface beyond comfortable scope.

    Completeness4/5

    The surface covers navigation, tabs/windows, snapshots, clicking, typing, keys, scrolling, history, popups, human handover and task orchestration — a near-complete automation lifecycle. Minor gaps exist (e.g. download/file handling, visual screenshots, cookie management) but core workflows are fully supported.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      MCP server that lets AI agents drive your real Chromium browser with your existing signed-in sessions, providing visible, local, and inspectable automation for tasks like navigation, clicking, typing, and form filling.
      25
      2
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Local browser MCP server that lets AI assistants control a real desktop browser via tools like navigate, snapshot, and search_web.
      MIT
    • A
      license
      A
      quality
      A
      maintenance
      MCP server for AgentGo, a real Chromium browser for AI agents: compact page outlines with stable refs, diff-only replies after each action, real mouse and keyboard input, the agent's own signed-in accounts, and human approval for payments. MIT.
      11
      1
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      A local Streamable HTTP MCP server that lets several AI agents drive your real, logged-in Chrome at once, each isolated in its own background tab group without stealing focus. It exposes browser tools for navigating, reading pages, filling forms, signing in via Bitwarden, and handing steps back to the user.
      MIT