misha-browser
Provides a Slack transport and protocol support for allowlisted Slack Web API methods, including private file downloads and chunked file uploads with Slack file IDs.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@misha-browser open a new browser tab and navigate to example.com"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
misha-browser
Connect local AI agents to your signed-in browser. The Misha Browser extension and its native host, a small program that connects the extension to processes on your Mac, let a local agent read and act in the browser you already use, and carry Slack to the Misha app. The same package has browser and desktop tools that Claude Code, OpenCode or any other MCP client can use through a standalone server, without the Misha app.
Setting up the Misha app? Follow Get started in the docs. Misha's Set up page checks the extension and installs the native host, and you don't need the build steps below.
Using the tools in your own agent? Build this repository and register the MCP server. This route needs neither the private Misha app nor an invite.
Status: macOS only, in Chrome or Brave. You load the extension unpacked from a build of this repository; it has no Chrome Web Store listing yet. Apache-2.0.
How it connects
signed-in tab Slack, or any page an agent reads or acts on
| scripts the extension runs in the tab
service worker the extension's background process
| native messaging
native host on your Mac, with its relay
| ~/.misha/browser-bridge/bridge.sock, a socket only you can open
Misha app Slack messages in, replies out
or the MCP server the tab_* toolsThe desktop tools (macos_*) don't go through the browser: the MCP server moves the mouse, presses keys and captures the screen itself, through macOS. How Misha works explains how the Misha app uses this path for Slack.
Related MCP server: remote-tools
Security in short
The extension has access to all sites. When an agent asks, it reads pages and clicks and types in your tabs through your signed-in sessions, as you.
While it runs, it records every tab's fetch and XHR requests, not only during a tool call. It redacts credentials by name and pattern, which misses an opaque credential under an ordinary name. On Slack's pages it also reads the requests Slack's own client sends, keeping only listed transport fields, to check that the Slack transport's requests look like the client's.
Any program running as you on the Mac can connect to the native host's socket and drive the browser through it.
The tools that move the mouse, press keys or capture the screen need Accessibility and Screen Recording for the app that runs your agent. See macOS permissions.
Browser permissions explains each permission and its limits, and the privacy policy covers where the data goes. The full detail is under Security below.
What this repository holds
The repository holds:
the wire protocol, in
src/protocol/: how the extension, its native messaging host and relay, and the relay's clients talk to each other. It covers requests and replies, each request with its caller's deadline and a way to cancel it, events the extension keeps in durable storage and forwards again until the app acknowledges them, signed-in identity and capture health reported apart, an allowlist of Slack Web API methods, and private file downloads and uploads in chunks under Chrome's 1 MB limit, with an upload's Slack file id known before the file is sharedthe Manifest V3 extension, in
src/extension/andsrc/service-worker/. In a signed-in Slack tab it reads new messages from the page's own socket and makes allowlisted Web API calls, downloads and uploads with the session Slack's web client already has: with the query of the client's own latest Web API call in the page, one request at a time per workspace and a random 0.5 to 2 seconds apart, and none handed to the page once its caller gave up. It checks each kind of request against the client's own and reports differences by name in its status. The extension uses the session token only inside the page and does not return it; see Security for the network log, to which the browser exposes request credentials temporarily, for redactionthe native host and its relay, in
src/host/, which carry requests, cancels, replies, events and acks between the extension and processes on the same Mac through a socket only the user can opena Node client for that socket, in
src/client/the browser tools (
tab_*, insrc/tools/), which read and drive the user's own browser through the extension, and the desktop tools (macos_*, insrc/desktop/), which move the Mac's mouse, press its keys, capture its screen, and bring apps to the fronta standalone MCP server, in
src/mcp/, that serves both sets of tools over stdio
Misha's app imports the protocol as misha-browser/protocol and the client as misha-browser/client. Node processes also get the framing helpers from misha-browser/protocol/framing. A Misha extension serves the tools through misha-browser/modules, which exports browserModule and desktopModule: each has a create that builds the module's tools and a jsonSchema that converts a tool's input with this package's zod, so the descriptions the model reads survive.
The MCP server
dist/mcp/server.js (the package's misha-browser-mcp bin) serves 26 tools to any MCP client, for the folder it was started in:
browser:
tab_list,tab_switch,tab_open,tab_close,tab_read,tab_find,tab_wait,tab_screenshot,tab_network,tab_click,tab_drag,tab_type,tab_fill,tab_select_option,tab_press,tab_scrolldesktop:
macos_mouse_move,macos_mouse_click,macos_mouse_current_position,macos_mouse_drag,macos_mouse_scroll,macos_keyboard_type,macos_keyboard_press,macos_screen_capture,macos_list_apps,macos_focus_app
Each tool's description tells the model when to use it. A page reads as a compact outline (headings, visible text, and each control with a numbered ref, role, name and state) instead of HTML, and clicks, typing, key presses and scrolling are real input, so pages get the same events a person makes. After an action, the result lists what changed on the page. The tools run on macOS only; elsewhere they stay listed and each one says so when called.
Build first (pnpm install && pnpm run build), then register the server with the absolute path of this checkout.
Claude Code:
claude mcp add --scope user misha-browser -- node /absolute/path/to/misha-browser/dist/mcp/server.jsOpenCode 2, in opencode.json. codemode: false lists each tool by its own name instead of behind OpenCode's execute tool:
{
"mcp": {
"servers": {
"misha-browser": {
"type": "local",
"command": ["node", "/absolute/path/to/misha-browser/dist/mcp/server.js"],
"codemode": false
}
}
}
}The browser tools need the extension and its native host, as below. tab_network lists the fetch and XHR requests a tab sent, with credentials redacted by name and pattern (see Security); it never writes a session anywhere.
macOS permissions
The tools that move the mouse, press keys or capture the screen share one input session, which asks for two permissions when it starts: Accessibility, to post mouse and keyboard events, and Screen Recording (Screen & System Audio Recording on recent macOS), for the screen capture. Input fails without either. They are tab_click, tab_drag, tab_type, tab_fill, tab_press, tab_scroll, every macos_mouse_* and macos_keyboard_* tool, and macos_screen_capture. The Return that accepts a download's save dialog after a browser action goes through the same session.
Grant both to the app that runs Claude Code or OpenCode (the terminal, the editor whose terminal you use, or the desktop app) in System Settings > Privacy & Security: turn the app on in each list, or add it with + if it is missing, then quit it completely and open it again. A running app keeps failing until it restarts.
The browser tools that only read or work through the extension (tab_list, tab_read, tab_find, tab_wait, tab_screenshot, tab_network, tab_open, tab_switch, tab_close), macos_list_apps and macos_focus_app need no permission. tab_screenshot captures through the extension, not the screen. tab_select_option sets the option through the extension, but when the change starts a download that waits in the browser's save dialog, the Return that accepts it goes through the input session, so that call needs both permissions too.
Loading the extension and the native host
Both run on macOS, in Chrome or Brave.
Build:
pnpm install && pnpm run build. The unpacked extension lands indist/extension.Install the native host:
pnpm run install-host. It writes a launcher to~/.misha/browser-bridge/native-hostand registers the host asmisha.browser_bridgewith Chrome, Brave or both, wherever a profile folder exists, so that only this extension can start it. The launcher names the current Node binary by its absolute path, so run it again after a Node upgrade. The installer makes~/.misha/browser-bridgeaccessible only to you (mode 700), and stops with an error when that folder or~/.mishais a symlink, when either belongs to another user (root may own~/.misha), when anyone else can write to~/.misha, or when an ACL on either has an entry that allows access (ls -lelists them,chmod -Nremoves them; entries that deny are fine).Open
brave://extensionsorchrome://extensions, turn on Developer mode, click "Load unpacked" and pickdist/extension. Its id islkibgdfhoikfdbkhdlnoiajfelcmohjj, fixed by the public key in the manifest. After a rebuild, reload it there. A Slack tab whose page loaded with this version's observer keeps capturing without a reload: the service worker gives the page a new relay, which takes a channel from the observer, along with any new message that came while no relay ran. Sending is different: a Slack call borrows the query of the latest Web API call Slack's own client made in the page, and the reloaded extension has seen none yet, so calls from that tab fail until the client makes one. Using Slack in the tab, such as opening a channel, or reloading the tab restores them.Reload any Slack tab that was already open when you first loaded the extension. The extension reads Slack's socket from a script that has to run before Slack's own, so a tab opened earlier shows as signed in but not capturing until it reloads. The same holds once when you upgrade from a build whose observer predates sequenced frames (any build before commit
51b179f): reload the extension, then reload each open Slack tab once, since its page still runs the old observer, which the new relay cannot read. From then on, reloading the extension needs no tab reload.
Once the browser has started the host, clients connect to ~/.misha/browser-bridge/bridge.sock.
The extension's permissions, which an unpacked extension gets when it is loaded, are summarized under Security.
Security
The extension asks for nativeMessaging, scripting, tabs, webRequest, downloads, alarms and unlimitedStorage, and for access to all sites. Browser permissions explains what each one lets the extension do, when data flows and its limits, and the privacy policy covers what happens to the data. Both draw on docs/store-disclosures.json, from which pnpm run disclosures generates the Chrome Web Store text in docs/store-permissions.md.
What that access means:
The browser tools act through the user's signed-in sessions on every site the browser has open, by design: they read pages, take screenshots, and click and type into the user's tabs for the model.
The service worker records every tab's fetch and XHR requests for as long as it runs, not only during a tool call. The browser exposes each request's credentials, Slack's token and cookie included, to the service worker temporarily, for redaction: it redacts them by name and pattern before recording, so an opaque credential under an ordinary name, such as the key in a share link, passes unchanged. The rest of a body is recorded as sent, including any personal, health, financial or location data in it. The log stays in memory, and the same redaction applies to every structured URL a tab command returns. Page text, field values and screenshots come back as the page shows them, a credential it displays included.
On Slack's pages the service worker also reads the requests Slack's own client sends, headers and bodies included, for the Slack transport: to borrow the client's query and to check the transport's requests against the client's. Inside the listener it keeps only field names and the values of listed transport fields in their expected forms; the token, the cookie, a call's arguments and an upload's address are dropped there, and a name shaped like a secret is never kept. The check compares the request envelope: header names and listed header values, query field names, the client's own
_x_body fields and the encoding. It leaves out_x_idand_x_reason, which belong to one request and to the action behind one client call, and every other body field, which is the call's arguments, so a reported difference means the envelope drifted. A body Chrome hands over as raw bytes is not read, so a comparison with it never reports a match. Its status leaves the extension with names only.Page reads skip hidden elements while they walk the page, but a visible label lists the state of the hidden control it stands for, a hidden text field's value included, and a ref they handed out keeps reading its element after the page hides it. A password field comes back only as filled, empty or its length, while the extension keeps the last raw value it read from each one in the page's isolated world until a later read or the document unloads. Once a tool locates a target on a page (a click, drag, scroll, typing into a referenced field or a screenshot), the extension keeps the latest pointer position there until the document unloads.
The service worker keeps some data in memory across requests: each tab's page outline from before its last click, drag, key press, option pick, or submitting or focused typing, until another of those replaces it (navigating and scrolling do not), the tab closing or the worker stopping, and a Slack file transfer until it completes or the worker stops. An open native host connection keeps the worker running, so that can last as long as the browser runs.
The Slack transport reads the session token only in the page and sends it only to the workspace's https address on Slack's domain. It returns the signed-in account, Slack's answers and file bytes, whether Slack's socket is open, and new messages cut down to the fields the app reads. It does not return the token it reads from Slack's saved client state, though a credential someone wrote into a message or a file comes back like any other content. Downloads come only from
files.slack.comwith redirects refused, but an upload goes to whatever upload URL Slack's answer names: the extension does not check its host, though the bytes refuse redirects, and the service worker holds the URL between the upload's two stages without sending it to the app. Requests go out one at a time per workspace, a random 0.5 to 2 seconds after the previous one handed to the page ended, unless the page's answer showed that one sent nothing (it was signed in as another account, or failed before its fetch); one whose answer was lost or did not read counts as sent and is not sent again. The send boundary is the moment a command is handed to the page: the extension checks right before it that the caller has not cancelled and its deadline has not passed, and the page checks the deadline once more right before its fetch. A cancel that arrives after the hand-off is too late, as one after a fetch started would be.New messages wait in an IndexedDB queue of at most 2000 events until the app acknowledges them. While writes to it fail, up to another 2000 are held in memory and forwarded from there, and a restart before a write succeeds loses those the app has not acknowledged, with no record of the loss.
Slack message content, which is remote data and never runs as script, can't trigger a command, an API call or an ack. A new message only ever becomes an event, keyed by the account its tab was signed in as when it came, and dropped if the tab has switched accounts since. Commands reach the extension only from the native host, and the relay passes an ack on only from the client that listens for events.
On the Mac, the socket that carries commands sits in a folder only the user can open (see the native host step above), and when two browsers start their hosts at once, the hosts take the socket over one at a time.
Scripts already running in the Slack page are out of scope: Slack's own code, or another extension's script in the page's world. Such a script already holds the user's session and token and can send them anywhere itself. The private channel between the observer and the relay, and the check that sends the token only to the workspace's address on Slack's domain, run on built-ins a page script could replace, and they are not hardened against that. The relay first takes its channel before any of the page's scripts run; a relay the service worker injects after the extension reloaded takes one while they run, so a page script could hand it a port of its own, whose messages the relay checks like any other and passes on only as events and status. The service worker injects that relay only into the top document it checked to be a Slack page, and the relay takes a channel only in the top frame of a page on https://app.slack.com.
Development
Node 24 and pnpm 11:
pnpm install
pnpm run typecheck && pnpm run lint && pnpm run format:check && pnpm testRelated repositories
dumdummisha/docs: the documentation site at docs.dumdummisha.ai, including the Misha app's setup, privacy policy and architecture.
dumdummisha/desktop-downloads: reserved for signed Misha desktop builds and the update feed. No signed build is available yet.
Available Tools
26 toolsmacos_focus_appA
macOS only. Bring a running app to the front, switching to the Space its window is on (a full-screen window has a Space of its own), and wait until it is the frontmost app. Omit app to return to the terminal this agent runs in: do that when a stretch of work that brought another app forward (the tab_* browser tools, another macos_focus_app) is done, and before asking the user anything, so the conversation is back on their screen. Reports the app that was frontmost before, to pass back later. Needs no macOS permission.
Inputs: app.
macos_keyboard_pressA
macOS only. Press a single named key, optionally as a shortcut chord with modifiers. Use for keys that are not text (Enter, Tab, Escape, arrows, function keys) and for shortcuts like Cmd+S or Cmd+Shift+P. To type words or symbols, use macos_keyboard_type instead. Requires Accessibility permission.
Inputs: key (required), modifiers.
macos_keyboard_typeA
macOS only. Type arbitrary text into the focused element. Injects Unicode directly, so it is layout-independent and correctly produces capitals, symbols, accented letters, and emoji. Use this for entering text; use macos_keyboard_press for named keys (Enter, Tab) and shortcuts. Requires Accessibility permission.
Inputs: text (required).
macos_list_appsA
macOS only. List the running apps that have windows (name, bundle id, process id), marking the frontmost one and the host, the terminal or app this agent runs in, when macOS reports it. Use it to find the name or bundle id macos_focus_app takes. Needs no macOS permission.
Inputs: no named parameters.
macos_mouse_clickA
macOS only. Click the mouse at its current position. Covers left/right/middle click and double-click via arguments (button, doubleClick, modifiers), so this one tool handles regular click, right-click, double-click and modifier clicks. Move the cursor first with macos_mouse_move. Requires Accessibility permission.
Inputs: button, modifiers, doubleClick.
macos_mouse_current_positionA
macOS only. Read the mouse cursor's current absolute position in logical coordinates (macOS points, top-left origin) without moving it. Use this to confirm a prior macos_mouse_move landed where expected before clicking or dragging. Requires Accessibility permission because it reuses the shared input session.
Inputs: no named parameters.
macos_mouse_dragA
macOS only. Press the mouse button at the current cursor position, drag to an absolute target in logical coordinates, and release. Use for sliders, selections, resizing, drawing and drag-and-drop, optionally through waypoints, with modifiers held, and with pauses after the press and before the release. Position the cursor at the drag start first (macos_mouse_move). Inside a browser tab, tab_drag targets page elements exactly instead. Requires Accessibility permission.
Inputs: x (required), y (required), path, button, +3 more.
macos_mouse_moveA
macOS only. Move the mouse cursor to an absolute position in logical coordinates (macOS points, top-left origin), read off macos_screen_capture or macos_mouse_current_position. Inside the browser, tab_click targets page elements exactly instead. Requires Accessibility permission.
Inputs: x (required), y (required), smooth.
macos_mouse_scrollA
macOS only. Scroll at the current cursor position. Vertical amount is required (positive up, negative down); horizontal is optional. Defaults to line units. Requires Accessibility permission.
Inputs: amount (required), unit, horizontal.
macos_screen_captureA
macOS only. Capture the primary monitor and return the screenshot as an image attachment so you can see the current screen and decide what to do. This is your eyes: call it to inspect the UI before acting with macos_mouse_move/macos_mouse_click, dividing the pixel coordinates you read off it by the reported scale to get logical points. Inside the browser, prefer the tab_* tools, which target page elements exactly. Requires Screen Recording and Accessibility permissions (the shared input session grants both up front).
Inputs: no named parameters.
tab_clickA
Click an element of a page in the user's browser with the real mouse. The tab is brought to the front, the element is scrolled into view if needed, and the pointer moves onto it and clicks once the page confirms the pointer is over it, so the browser window may sit anywhere on screen. Fails without clicking when something covers the element. Take the ref from tab_read. On a canvas page, click a point instead with x and y, read off tab_screenshot: the page confirms the pointer reached that point before the click. Returns what changed on the page (lines that appeared with +, went with -), or the new screen after a navigation, so a menu or dialog the click opened needs no tab_read; take a tab_screenshot when that leaves you unsure what happened. A download the click starts is saved where the browser's save dialog proposes, and the result names the file.
Inputs: x, y, ref, tabId, +4 more.
tab_closeA
Close a tab in the user's browser by its id from tab_list. Close only tabs you opened or were asked to.
Inputs: tabId (required).
tab_dragA
Drag in a page of the user's browser with the real mouse: from an element or a point to an element or a point, for drag and drop, sortable lists, sliders, and moving or resizing on a canvas. The tab is brought to the front and the page confirms the pointer is on the start before the button goes down. Both ends must be on screen together. Returns what changed on the page. Take refs from tab_read, points from tab_screenshot.
Inputs: toX, toY, fromX, fromY, +7 more.
tab_fillA
Fill several fields of a form in the user's browser in one call, the way tab_type and tab_select_option do one each: text fields are clicked, cleared and typed into with the real keyboard, native selects are set. Then, with submitRef, the submit button is clicked with the real mouse. Returns what each field holds and what changed on screen after the submit. Stops at the first field that fails.
Inputs: fields (required), tabId, submitRef.
tab_findA
Find controls and text on a page in the user's browser without reading all of it: returns the lines of the whole page's outline that contain the text, controls with their refs, for example [80] button "Create" for "create". A matching heading comes with the start of the section it titles, indented, so searching for a row or section title gives its controls. Cheaper than tab_read on long pages when you know what you are looking for.
Inputs: text (required), tabId.
tab_listA
List every open tab in the user's own browser, grouped by window: tab id, title and URL, with the active tab of each window and the focused window marked. Use it to find a tab before tab_switch or tab_read.
Inputs: no named parameters.
tab_networkA
List the fetch and XHR requests a tab in the user's browser sent, oldest first: method, URL, status and request body, and with includeHeaders the request headers. The response body is not recorded. Use it to learn the API a web app calls: act on the page with tab_click, tab_fill or tab_type, then read what that sent. Credentials are redacted in the browser before a request leaves it: a body field (form, JSON or multipart), query parameter or header named like a token, password, secret, API key or authorization, and any value shaped like a known token, key or Bearer value, shows as [redacted] with its name kept. The extension keeps the latest 200 requests of each tab since it started; a request sent before that, or by a page load rather than a script, is not listed.
Inputs: last, tabId, urlContains, includeHeaders.
tab_openA
Open a URL in the user's own browser, in a new tab by default, wait up to 10 seconds for it to load and a moment more for the page to finish rendering, and return the tab id with the outline of what is on screen, as tab_read gives it, so no read is needed before acting on the page.
Inputs: url (required), newTab.
tab_pressA
Press a key or shortcut in the user's browser with the real keyboard, after bringing the tab to the front. It goes to whatever has focus there: Escape to close a dialog, Tab to move between fields, Enter to submit, arrows in a list. Returns what changed on screen, or the new screen after a navigation.
Inputs: key (required), tabId, modifiers.
tab_readA
Read a page in the user's own browser as a compact outline instead of HTML: headings, visible text, and every visible control on its own line with a ref, role, name and state, e.g. [12] textbox "Email" value="" required or [13] button "Sign in". Open dialogs come first. Pass those refs to tab_click, tab_type, tab_fill, tab_select_option and tab_scroll; to find one control on a long page, tab_find is cheaper. Reading does not move the mouse or switch tabs. Defaults to what is on screen in the active tab; use scope "page" for the whole page, and tab_screenshot when the look of the page matters, or when the outline leaves you unsure what the user sees (a dialog, a canvas, a page that changed unexpectedly).
Inputs: ref, scope, tabId.
tab_screenshotA
Take a screenshot of the visible part of a tab in the user's browser, returned as an image attachment. The tab is made active in its window first. Use it when the visual layout matters (charts, images, styling, canvas apps); for text and controls, tab_read is cheaper and gives refs to act on. On a canvas page, click what it shows with tab_click x and y: the result gives the viewport size in CSS pixels to scale image pixels by.
Inputs: tabId.
tab_scrollA
Scroll a page in the user's browser with the real mouse wheel, over the middle of the page or over an element, and return what is on screen afterwards, in the tab_read format.
Inputs: direction (required), ref, pages, tabId.
tab_select_optionA
Choose an option in a native dropdown of a page in the user's browser; tab_read lists its options. The macOS popup of a native select cannot be driven reliably by the mouse, so this sets the option the way the page would and fires its input and change events. Custom dropdowns built from other elements are not native selects: open them with tab_click and click the option. Returns what changed on screen.
Inputs: ref (required), option (required), tabId.
tab_switchA
Show a tab in the user's browser: make it the active tab of its window and bring that window to the front. Take the tab id from tab_list.
Inputs: tabId (required).
tab_typeA
Type into a text field of a page in the user's browser with the real mouse and keyboard, or without a ref into whatever has the focus (a canvas app editing text). With a ref the field is clicked to focus it, its content is replaced (or appended to with clear=false), and the text is typed, so the page reacts as it would to the user. With a ref it returns the value the field holds afterwards (hidden for passwords), or with submit what changed on screen; without one it always returns what changed on screen. Take the field's ref from tab_read. For several fields at once use tab_fill; for a native select dropdown use tab_select_option.
Inputs: text (required), ref, clear, tabId, +1 more.
tab_waitA
Wait until a text shows on a page in the user's browser, or with gone until it no longer does: a result that loads after a delay, a loading message going away, or the user finishing a step you asked them to do, such as logging in. Returns the lines that mention the text, with refs, as tab_find does. Does not touch the page.
Inputs: text (required), gone, tabId, timeoutSeconds.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 26 tools
Nearly every tool targets a distinct action, and the descriptions actively steer between the risky pairs (tab_click vs macos_mouse_click, tab_drag vs macos_mouse_drag, tab_type vs tab_fill vs macos_keyboard_type) by telling the agent to prefer the tab_* tools inside a page. The remaining overlap is structural rather than confusing: a broad browser layer and a generic macOS layer necessarily duplicate input primitives. A couple of fine-grained distinctions (tab_press vs tab_type without a ref, tab_find vs tab_wait) still need the description text to sort out.
Names are uniformly snake_case with two clean namespaces, tab_* and macos_*, which is easy to scan and predict. The ordering convention differs slightly between them (tab_ verbs lead, e.g. tab_read/tab_click, while macos_ tools put the object first, e.g. macos_mouse_move, macos_keyboard_press), but each namespace is internally consistent. tab_screenshot and tab_network are noun-style outliers inside an otherwise verb-led prefix.
Twenty-six tools is above the comfortable band, but the server spans two genuinely large surfaces (browser tab automation plus macOS desktop input), so most tools earn their place. Only a few look like thin helpers, notably macos_mouse_current_position, which exists mainly to verify a prior move. It is slightly over-scoped rather than bloated.
The browser surface covers the full perceive-act loop (list/read/find/wait/screenshot plus click, type, fill, select, press, scroll, drag) and the macOS surface covers app focus, mouse, keyboard and screen capture, so core workflows have no dead ends. Gaps are real but workable: no back/forward/reload navigation, no file upload, no clipboard access, and network responses cannot be read, only requests. Those are minor omissions an agent can route around rather than blocking failures.
Maintenance
Related MCP Connectors
Enable interaction with Slack workspaces. Supports subscribing to Slack events through Resources.
Securely control computers you explicitly pair through files, terminals, processes, screenshots, desktop UI/input, clipboard, browser automation, diagnostics, and document tools.
Control your authorized Windows computers via OAuth: files, shell, apps, and task status.
Launch, inspect, control, and share isolated cloud browsers for your agents.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables remote AI agents to control a local, authenticated desktop browser over MCP through an outbound WebSocket bridge and Chrome extension, supporting tab management, navigation, page reading, clicking, typing, scrolling, screenshots, and JavaScript evaluation.1MIT
- AlicenseNot gradedqualityBmaintenanceEnables Claude Agent SDK agents to safely operate a remote user machine via a WebSocket tunnel, providing six client__* MCP tools with path fencing and phase-switch adjudication.MIT
- AlicenseNot gradedqualityCmaintenanceEnables authorized remote MCP clients to securely reach local Mac or Windows tools over OAuth, including shell commands, file read/write, background jobs, screenshots, UI control, and clipboard access. It can also expose configured Desktop MCP servers and optional Claude Code task delegation.MIT
- AlicenseNot gradedqualityBmaintenanceEnables agents to observe and act on live browser pages through screenshots, bounded actions, responsive captures, console and network inspection, tab operations, and session management over local stdio or authenticated HTTP.Apache 2.0