agent-in-browser
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| BROWSER | No | Selects the browser to drive, e.g. --browser firefox (works anywhere on the command line). | |
| ENDPOINT | No | Attaches to a browser you started yourself, e.g. --endpoint http://127.0.0.1:9222. | |
| HEADLESS | No | Runs the browser headless via --headless. | |
| INSTANCE | No | Uses a second, independent browser instance, e.g. --instance work. | |
| VIEWPORT | No | Sets the viewport size, e.g. --viewport 390x844. |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": false
} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| browser_closeA | Shut down the browser agent-in-browser is driving, closing all its tabs and discarding in-memory page state; the profile on disk (cookies, logins) is kept. This also closes a browser you attached to with an endpoint. The next tool call starts a fresh browser automatically. Use it to finish a session or recover from a stuck browser; to close one page use tab_close. |
| browser_statusA | Read-only health check: report which browser is connected (name, protocol CDP or BiDi, endpoint, and for launched browsers the PID, headless flag and profile directory) and list the open tabs with the current one marked. Starts the browser first if none is running, so it is a good first call in a session. Use tabs_list when you only need the tabs, browsers_installed to see what could be launched. |
| browsers_installedA | Read-only: list the browsers installed on this machine (Chrome, Edge, Brave, Chromium, Vivaldi, Opera, Firefox, Safari), one per line with name, protocol, executable path and whether agent-in-browser can drive it (Safari is detected but not yet supported). Does not launch anything. Use the listed name as the browser option when starting the server; browser_status shows the one in use. |
| clickA | Click an element, chosen by ref, CSS selector or visible text, or a viewport point x,y, using real trusted mouse events (so it works on links, buttons, custom widgets and checkboxes). The element is scrolled into view first. Returns what was clicked (and warns if another element covers it); if the click navigated, it waits for the new page and reports its title and URL. Refs may be stale after navigation, so snapshot again. Use hover to move without clicking, fill_form for form fields. |
| console_messagesA | Read-only: list browser console output (console.log/warn/error and uncaught exceptions) captured since agent-in-browser attached to the tab, one line per entry as |
| evaluateA | Run JavaScript inside the page and return the result as JSON text. A bare expression is returned as is (document.title); code with several statements needs an explicit |
| fill_formA | Set the values of several form fields in one call: text inputs and textareas (string), selects (option value or visible label), checkboxes and radios (true/false). Each field is located by ref, selector or visible label and scrolled into view; input and change events are fired so React, Vue and Angular see the update. Returns one line per field with the value set, and stops with an error naming the failing fields[i]. It does not submit the form: click the submit button afterwards. For typing key by key use type. |
| findA | Read-only: search the page for visible elements whose text, accessible label, placeholder, id or name contains the query (case-insensitive) and return each with its role, name and a ref you can pass to click, type, hover or fill_form. Use it to locate one element on a large page without a full snapshot. Returns nothing when no visible element matches; try a shorter query or call snapshot. |
| get_textA | Read-only: return the visible text of the page, or of the first element matching a CSS selector, as plain text. Best for reading articles, search results, table contents and status messages; the text is prefixed with the page title and URL. It carries no element refs: use snapshot when you need to click or type, and screenshot for visual layout. Hidden text is excluded. Output is cut at max_chars; narrow with a selector for long pages. |
| hoverA | Move the real mouse pointer over an element or a viewport point without clicking, to open hover menus, tooltips or lazy content. The element is scrolled into view and its centre is used. Returns what is being hovered (and warns if another element covers it). Take a snapshot or screenshot afterwards to see what appeared. Give one of ref, selector, match or x+y; use click to press instead. |
| navigateA | Load a URL in a tab, or go back, forward or reload its history, then wait until the page has loaded (or timeout_ms passes, reported as "still loading"). Returns the final title, URL and tab id. Give either url or action. Loading a URL clears the tab's captured network requests. Element refs from earlier snapshots become invalid, so call snapshot next. Use tab_new to open a page in a new tab and click on links to follow them. |
| network_requestsA | Read-only: list network requests made by the tab since agent-in-browser attached, one line per request with method, HTTP status (or FAILED reason / pending), resource type and URL. Use it to check that an API call fired, find 4xx/5xx errors or see what a page loads. Request and response bodies are not included. Requests made before attaching are missed, so navigate with action=reload first. For script errors use console_messages. |
| press_keyA | Send a real key press (or combination) to whatever element currently has focus: submit with Enter, close dialogs with Escape, move with Tab or the arrow keys, or use shortcuts such as Control+a, Control+c, Control+v. Focus first with click or type if needed. To enter text use type instead; to set form fields use fill_form. Returns the key and repeat count; page changes are not reported, so snapshot afterwards. An unrecognised key name returns an error. |
| resizeA | Set the tab's viewport to a given size in CSS pixels, to test responsive layouts (e.g. 390x844 phone, 768x1024 tablet, 1440x900 desktop). It emulates the size inside the page and does not move or resize the browser window. Applies to this tab until the browser is closed or you resize again; reload may be needed for layouts that read the size on load. Returns the size set; width and height must be positive. Screenshots afterwards use the new size. |
| screenshotA | Read-only: capture the visible viewport of a tab as a PNG image returned to you (full-page capture is not supported: scroll and capture again). Use it to check visual layout, colours or images, since snapshot and get_text only describe structure and text. Pass path to also save the file, creating folders as needed; the result then includes the saved path. Size follows the viewport set by resize. |
| scrollA | Scroll the page, or a scrollable container, by an amount in a direction; or scroll a given element (ref, selector or match) into the centre of the view. Returns the new scroll position and the maximum scroll, so you can tell when you reached the end. Use it for lazy-loaded or long pages; click and hover already scroll their target into view, so you rarely need it for those. |
| snapshotA | Read-only: return a compact text outline of the page: headings, landmarks and every visible interactive element (links, buttons, inputs, selects) with its role, accessible name, state and a ref such as [ref=e12]. It sees through shadow DOM and same-origin iframes. Use the refs with click, hover, type, fill_form and scroll. Call it first on any page, and again after navigation or large page changes, because refs go stale. Far cheaper than screenshot for understanding structure. mode=all also includes text blocks; use get_text to just read content. |
| tab_closeA | Close one tab and discard its page state; the browser itself keeps running. Defaults to the current tab; pass |
| tab_newA | Open a new browser tab, optionally at a URL, and make it the current tab so later page tools act on it. Waits for the page to load when a URL is given. Returns the new tab id, title and URL; use that id with tab_select, tab_close or the |
| tab_selectA | Switch to an existing tab: brings it to the front and makes it the default target of all page tools. Returns the tab's title and URL. Get ids from tabs_list or tab_new; an unknown id returns an error. Does not reload or change the page. To act on a tab once without switching, pass |
| tabs_listA | Read-only: list the open tabs of the connected browser, one per line as tab id, title and URL, where * marks the current tab (the default target of page tools). Use the ids with tab_select, tab_close or any tool's |
| typeA | Type text into an input, textarea or contenteditable using real keyboard input events. If an element is given (ref, selector or match) it is focused and, by default, cleared first; otherwise the text goes to the element that already has focus. submit=true presses Enter afterwards and, if that navigates, reports the new page. Returns the number of characters typed. To set several fields, selects or checkboxes in one call use fill_form; for non-text keys such as Tab or Escape use press_key. |
| wait_forA | Read-only: pause until a condition holds, polling every 200 ms: given text appears in the page, a CSS selector becomes visible, or the URL contains a substring; gone=true waits for the opposite. Returns how long it waited, or an error on timeout. Use it after clicks that load content asynchronously instead of guessing delays. With only ms it just sleeps (up to 60000). Give exactly one of text, selector or url. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 23 tools
Tools split cleanly along interaction vs. inspection lines, and descriptions actively cross-reference each other (get_text vs snapshot vs screenshot, click vs hover, type vs fill_form vs press_key, browser_status vs tabs_list vs browsers_installed). The only soft spot is the read-inspection cluster (snapshot, find, get_text, evaluate), which could occasionally be confused, but each is scoped to a different need.
Everything is snake_case, which is good, but the ordering pattern mixes verb-first (get_text, fill_form, press_key, wait_for) with noun-first (browser_close, tabs_list, tab_new, console_messages, network_requests). Prefixes also drift between singular `tab_*` and plural `tabs_*`, and `browser_*` vs `browsers_*`, making the scheme only loosely predictable.
23 tools is heavy for the stated scope and pushes into the crowded band; a browser agent genuinely needs much of this surface, but some tools (browsers_installed, resize, scroll, find) are arguably niche relative to core navigate/snapshot/click/type. It is defensible but not tightly scoped.
Coverage is broad: navigation and history, tab lifecycle, trusted input, form filling, keyboard, scrolling, screenshots, viewport emulation, console/network diagnostics, JS evaluation and waiting. Gaps exist around file upload/download, dialog handling, cross-origin iframe targeting and full-page capture, but most are workable via evaluate or press_key.