Click on "Install 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., "@Playwright MCP Open github.com and search for 'playwright mcp'"
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.
A Model Context Protocol (MCP) server that provides browser automation capabilities using Playwright. This server enables LLMs to interact with web pages through structured accessibility snapshots, bypassing the need for screenshots or visually-tuned models.
This package provides MCP interface into Playwright. If you are using a coding agent, you might benefit from using the CLI+SKILLS instead.
CLI: Modern coding agents increasingly favor CLI–based workflows exposed as SKILLs over MCP because CLI invocations are more token-efficient: they avoid loading large tool schemas and verbose accessibility trees into the model context, allowing agents to act through concise, purpose-built commands. This makes CLI + SKILLs better suited for high-throughput coding agents that must balance browser automation with large codebases, tests, and reasoning within limited context windows.Learn more about Playwright CLI with SKILLS.
MCP: MCP remains relevant for specialized agentic loops that benefit from persistent state, rich introspection, and iterative reasoning over page structure, such as exploratory automation, self-healing tests, or long-running autonomous workflows where maintaining continuous browser context outweighs token cost concerns.
Fast and lightweight. Uses Playwright's accessibility tree, not pixel-based input.
LLM-friendly. No vision models needed, operates purely on structured data.
Deterministic tool application. Avoids ambiguity common with screenshot-based approaches.
Node.js 18 or newer
VS Code, Cursor, Windsurf, Claude Desktop, Goose, Grok, Junie or any other MCP client
First, install the Playwright MCP server with your client.
Standard config works in most of the tools:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}
}
Add via the Amp VS Code extension settings screen or by updating your settings.json file:
"amp.mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}Amp CLI Setup:
Add via the amp mcp add command below
amp mcp add playwright -- npx @playwright/mcp@latestAdd via the Antigravity settings or by updating your configuration file:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}
}Use the Claude Code CLI to add the Playwright MCP server:
claude mcp add playwright npx @playwright/mcp@latestFollow the MCP install guide, use the standard config above.
Follow the instruction in the section Configuring MCP Servers
Example: Local Setup
Add the following to your cline_mcp_settings.json file:
{
"mcpServers": {
"playwright": {
"type": "stdio",
"command": "npx",
"timeout": 30,
"args": [
"-y",
"@playwright/mcp@latest"
],
"disabled": false
}
}
}Use the Codex CLI to add the Playwright MCP server:
codex mcp add playwright npx "@playwright/mcp@latest"Alternatively, create or edit the configuration file ~/.codex/config.toml and add:
[mcp_servers.playwright]
command = "npx"
args = ["@playwright/mcp@latest"]For more information, see the Codex MCP documentation.
Use the Copilot CLI to interactively add the Playwright MCP server:
/mcp addAlternatively, create or edit the configuration file ~/.copilot/mcp-config.json and add:
{
"mcpServers": {
"playwright": {
"type": "local",
"command": "npx",
"tools": [
"*"
],
"args": [
"@playwright/mcp@latest"
]
}
}
}For more information, see the Copilot CLI documentation.
Go to Cursor Settings -> MCP -> Add new MCP Server. Name to your liking, use command type with the command npx @playwright/mcp@latest. You can also verify config or add command like arguments via clicking Edit.
Use the Factory CLI to add the Playwright MCP server:
droid mcp add playwright "npx @playwright/mcp@latest"Alternatively, type /mcp within Factory droid to open an interactive UI for managing MCP servers.
For more information, see the Factory MCP documentation.
Follow the MCP install guide, use the standard config above.
Go to Advanced settings -> Extensions -> Add custom extension. Name to your liking, use type STDIO, and set the command to npx @playwright/mcp. Click "Add Extension".
Use the Grok CLI to add the Playwright MCP server:
grok mcp add playwright -- npx @playwright/mcp@latestAlternatively, create or edit the configuration file ~/.grok/config.toml and add:
[mcp_servers.playwright]
command = "npx"
args = ["@playwright/mcp@latest"]For more information, see the Grok MCP documentation.
To add the Playwright MCP server in Junie CLI:
Type /mcp
Press Ctrl+A to add a new MCP server
Select Playwright from the list
Alternatively, add to .junie/mcp/mcp.json:
{
"mcpServers": {
"Playwright": {
"command": "npx",
"args": [
"-y",
"@playwright/mcp@latest"
]
}
}
}For more information, see the Junie MCP configuration documentation.
Follow the MCP Servers documentation. For example in .kiro/settings/mcp.json:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}
}
Go to Program in the right sidebar -> Install -> Edit mcp.json. Use the standard config above.
Follow the MCP Servers documentation. For example in ~/.config/opencode/opencode.json:
{
"$schema": "https://opencode.ai/config.json",
"mcp": {
"playwright": {
"type": "local",
"command": [
"npx",
"@playwright/mcp@latest"
],
"enabled": true
}
}
}
Open Qodo Gen chat panel in VSCode or IntelliJ → Connect more tools → + Add new MCP → Paste the standard config above.
Click Save.
Follow the MCP install guide, use the standard config above. You can also install the Playwright MCP server using the VS Code CLI:
# For VS Code
code --add-mcp '{"name":"playwright","command":"npx","args":["@playwright/mcp@latest"]}'After installation, the Playwright MCP server will be available for use with your GitHub Copilot agent in VS Code.
Go to Settings -> AI -> Manage MCP Servers -> + Add to add an MCP Server. Use the standard config above.
Alternatively, use the slash command /add-mcp in the Warp prompt and paste the standard config from above:
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest"
]
}
}
}Follow Windsurf MCP documentation. Use the standard config above.
Playwright MCP server supports following arguments. They can be provided in the JSON configuration above, as a part of the "args" list:
Option | Description |
--allowed-hosts <hosts...> | comma-separated list of hosts this server is allowed to serve from. Defaults to the host the server is bound to. Pass '*' to disable the host check.env |
--allowed-origins | semicolon-separated list of TRUSTED origins to allow the browser to request. Default is to allow all. Important: does not serve as a security boundary and does not affect redirects.env |
--allow-unrestricted-file-access | allow access to files outside of the workspace roots. Also allows unrestricted access to file:// URLs. By default access to file system is restricted to workspace root directories (or cwd if no roots are configured) only, and navigation to file:// URLs is blocked.env |
--blocked-origins | semicolon-separated list of origins to block the browser from requesting. Blocklist is evaluated before allowlist. If used without the allowlist, requests not matching the blocklist are still allowed. Important: does not serve as a security boundary and does not affect redirects.env |
--block-service-workers | block service workersenv |
--browser | browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge.env |
--caps | comma-separated list of additional capabilities to enable, possible values: vision, pdf, devtools.env |
--cdp-endpoint | CDP endpoint to connect to.env |
--cdp-header <headers...> | CDP headers to send with the connect request, multiple can be specified.env |
--cdp-timeout | timeout in milliseconds for connecting to CDP endpoint, defaults to 30000msenv |
--codegen | specify the language to use for code generation, possible values: "typescript", "python", "java", "csharp", "none". Default is "typescript".env |
--config | path to the configuration file.env |
--console-level | level of console messages to return: "error", "warning", "info", "debug". Each level includes the messages of more severe levels.env |
--device | device to emulate, for example: "iPhone 15"env |
--mobile | emulate a generic mobile device (Pixel 10 for Chromium, iPhone 17 for WebKit). Mobile pages are usually lighter, which saves tokens. Cannot be combined with --device.env |
--executable-path | path to the browser executable.env |
--extension | Connect to a running browser instance (Edge/Chrome only). Requires the "Playwright Extension" to be installed.env |
--endpoint | Bound browser endpoint to connect to.env |
--grant-permissions <permissions...> | List of permissions to grant to the browser context, for example "geolocation", "clipboard-read", "clipboard-write".env |
--headless | run browser in headless mode, headed by defaultenv |
--host | host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.env |
--ignore-https-errors | ignore https errorsenv |
--init-page <path...> | path to TypeScript file to evaluate on Playwright page objectenv |
--init-script <path...> | path to JavaScript file to add as an initialization script. The script will be evaluated in every page before any of the page's scripts. Can be specified multiple times.env |
--isolated | keep the browser profile in memory, do not save it to disk.env |
--image-responses | whether to send image responses to the client. Can be "allow" or "omit", Defaults to "allow".env |
--no-sandbox | disable the sandbox for all process types that are normally sandboxed.env |
--output-dir | path to the directory for output files.env |
--output-max-size | Threshold for evicting old output files, in bytes.env |
--port | port to listen on for SSE transport.env |
--proxy-bypass | comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"env |
--proxy-server | specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"env |
--sandbox | enable the sandbox for all process types that are normally not sandboxed.env |
--save-session | Whether to save the Playwright MCP session into the output directory.env |
--secrets | path to a file containing secrets in the dotenv formatenv |
--shared-browser-context | reuse the same browser context between all connected HTTP clients.env |
--snapshot-boxes | include each element's bounding box as [box=x,y,width,height] in snapshots. Coordinates are viewport-relative, in CSS pixels.env |
--snapshot-mode | when taking snapshots for responses, specifies the mode to use. Can be "full" or "none". Default is "full".env |
--storage-state | path to the storage state file for isolated sessions.env |
--test-id-attribute | specify the attribute to use for test ids, defaults to "data-testid"env |
--timeout-action | specify action timeout in milliseconds, defaults to 5000msenv |
--timeout-navigation | specify navigation timeout in milliseconds, defaults to 60000msenv |
--timeout-settle | how long to wait after each action for triggered work to settle, in milliseconds, defaults to 500msenv |
--user-agent | specify user agent stringenv |
--user-data-dir | path to the user data directory. If not specified, a temporary directory will be created.env |
--viewport-size | specify browser viewport size in pixels, for example "1280x720"env |
You can run Playwright MCP with persistent profile like a regular browser (default), in isolated contexts for testing sessions, or connect to your existing browser using the browser extension.
Persistent profile
All the logged in information will be stored in the persistent profile, you can delete it between sessions if you'd like to clear the offline state.
Persistent profile is located at the following locations and you can override it with the --user-data-dir argument.
# Windows
%USERPROFILE%\AppData\Local\ms-playwright\mcp-{channel}-{workspace-hash}
# macOS
- ~/Library/Caches/ms-playwright/mcp-{channel}-{workspace-hash}
# Linux
- ~/.cache/ms-playwright/mcp-{channel}-{workspace-hash}{workspace-hash} is derived from the MCP client's workspace root, so different projects get separate profiles automatically.
A persistent profile can only be used by one browser instance at a time, so concurrent MCP clients sharing the same workspace will conflict. To run several clients in parallel, start each additional client with--isolated or point it at a distinct --user-data-dir.
Isolated
In the isolated mode, each session is started in the isolated profile. Every time you ask MCP to close the browser,
the session is closed and all the storage state for this session is lost. You can provide initial storage state
to the browser via the config's contextOptions or via the --storage-state argument. Learn more about the storage
state here.
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": [
"@playwright/mcp@latest",
"--isolated",
"--storage-state={path/to/storage.json}"
]
}
}
}Browser Extension
The Playwright MCP Chrome Extension allows you to connect to existing browser tabs and leverage your logged-in sessions and browser state. See microsoft/playwright › packages/extension for installation and setup instructions.
There are multiple ways to provide the initial state to the browser context or a page.
For the storage state, you can either:
Start with a user data directory using the --user-data-dir argument. This will persist all browser data between the sessions.
Start with a storage state file using the --storage-state argument. This will load cookies and local storage from the file into an isolated browser context.
For the page state, you can use:
--init-page to point to a TypeScript file that will be evaluated on the Playwright page object. This allows you to run arbitrary code to set up the page.
// init-page.ts
export default async ({ page }) => {
await page.context().grantPermissions(['geolocation']);
await page.context().setGeolocation({ latitude: 37.7749, longitude: -122.4194 });
await page.setViewportSize({ width: 1280, height: 720 });
};--init-script to point to a JavaScript file that will be added as an initialization script. The script will be evaluated in every page before any of the page's scripts.
This is useful for overriding browser APIs or setting up the environment.
// init-script.js
window.isPlaywrightMCP = true;The Playwright MCP server can be configured using a JSON configuration file. You can specify the configuration file
using the --config command line option:
npx @playwright/mcp@latest --config path/to/config.json{
/**
* The browser to use.
*/
browser?: {
/**
* The type of browser to use.
*/
browserName?: 'chromium' | 'firefox' | 'webkit';
/**
* Keep the browser profile in memory, do not save it to disk.
*/
isolated?: boolean;
/**
* Path to a user data directory for browser profile persistence.
* Temporary directory is created by default.
*/
userDataDir?: string;
/**
* Launch options passed to
* @see https://playwright.dev/docs/api/class-browsertype#browser-type-launch-persistent-context
*
* This is useful for settings options like `channel`, `headless`, `executablePath`, etc.
*/
launchOptions?: playwright.LaunchOptions;
/**
* Context options for the browser context.
*
* This is useful for settings options like `viewport`.
*/
contextOptions?: playwright.BrowserContextOptions;
/**
* Chrome DevTools Protocol endpoint to connect to an existing browser instance in case of Chromium family browsers.
*/
cdpEndpoint?: string;
/**
* CDP headers to send with the connect request.
*/
cdpHeaders?: Record<string, string>;
/**
* Timeout in milliseconds for connecting to CDP endpoint. Defaults to 30000 (30 seconds). Pass 0 to disable timeout.
*/
cdpTimeout?: number;
/**
* Remote endpoint to connect to an existing Playwright server. May be a
* WebSocket URL string, or a [ConnectOptions] object that mirrors the
* `connectOptions` shape used by the test runner. When passed as an object,
* `exposeNetwork`, `headers`, `slowMo`, and `timeout` are forwarded to the
* underlying connect call.
*/
remoteEndpoint?: string | playwright.ConnectOptions & { endpoint: string };
/**
* Paths to TypeScript files to add as initialization scripts for Playwright page.
*/
initPage?: string[];
/**
* Paths to JavaScript files to add as initialization scripts.
* The scripts will be evaluated in every page before any of the page's scripts.
*/
initScript?: string[];
},
/**
* Connect to a running browser instance (Edge/Chrome only). If specified, `browser`
* config is ignored.
* Requires the "Playwright Extension" to be installed.
*/
extension?: boolean;
server?: {
/**
* The port to listen on for SSE or MCP transport.
*/
port?: number;
/**
* The host to bind the server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.
*/
host?: string;
/**
* The hosts this server is allowed to serve from. Defaults to the host server is bound to.
* This is not for CORS, but rather for the DNS rebinding protection.
*/
allowedHosts?: string[];
},
/**
* List of enabled tool capabilities. Possible values:
* - 'core': Core browser automation features.
* - 'pdf': PDF generation and manipulation.
* - 'vision': Coordinate-based interactions.
* - 'devtools': Developer tools features.
*/
capabilities?: ToolCapability[];
/**
* Whether to save the Playwright session into the output directory.
*/
saveSession?: boolean;
/**
* Reuse the same browser context between all connected HTTP clients.
*/
sharedBrowserContext?: boolean;
/**
* Secrets are used to replace matching plain text in the tool responses to prevent the LLM
* from accidentally getting sensitive data. It is a convenience and not a security feature,
* make sure to always examine information coming in and from the tool on the client.
*/
secrets?: Record<string, string>;
/**
* The directory to save output files.
*/
outputDir?: string;
/**
* Threshold for evicting old output files, in bytes.
*/
outputMaxSize?: number;
console?: {
/**
* The level of console messages to return. Each level includes the messages of more severe levels. Defaults to "info".
*/
level?: 'error' | 'warning' | 'info' | 'debug';
},
network?: {
/**
* List of origins to allow the browser to request. Default is to allow all. Origins matching both `allowedOrigins` and `blockedOrigins` will be blocked.
*
* Supported formats:
* - Full origin: `https://example.com:8080` - matches only that origin
* - Wildcard port: `http://localhost:*` - matches any port on localhost with http protocol
*/
allowedOrigins?: string[];
/**
* List of origins to block the browser to request. Origins matching both `allowedOrigins` and `blockedOrigins` will be blocked.
*
* Supported formats:
* - Full origin: `https://example.com:8080` - matches only that origin
* - Wildcard port: `http://localhost:*` - matches any port on localhost with http protocol
*/
blockedOrigins?: string[];
};
/**
* Specify the attribute to use for test ids, defaults to "data-testid".
*/
testIdAttribute?: string;
timeouts?: {
/*
* Configures default action timeout: https://playwright.dev/docs/api/class-page#page-set-default-timeout. Defaults to 5000ms.
*/
action?: number;
/*
* Configures default navigation timeout: https://playwright.dev/docs/api/class-page#page-set-default-navigation-timeout. Defaults to 60000ms.
*/
navigation?: number;
/**
* Configures default expect timeout: https://playwright.dev/docs/test-timeouts#expect-timeout. Defaults to 5000ms.
*/
expect?: number;
/**
* How long to wait after each action for triggered work (navigations, requests) to settle before responding. Defaults to 500ms.
*/
settle?: number;
};
/**
* Whether to send image responses to the client. Can be "allow", "omit", or "auto". Defaults to "auto", which sends images if the client can display them.
*/
imageResponses?: 'allow' | 'omit';
snapshot?: {
/**
* When taking snapshots for responses, specifies the mode to use.
*/
mode?: 'full' | 'none';
/**
* Whether to include each element's bounding box as [box=x,y,width,height] in snapshots.
* Coordinates are viewport-relative, in CSS pixels (Element.getBoundingClientRect).
*/
boxes?: boolean;
};
/**
* allowUnrestrictedFileAccess acts as a guardrail to prevent the LLM from accidentally
* wandering outside its intended workspace. It is a convenience defense to catch unintended
* file access, not a secure boundary; a deliberate attempt to reach other directories can be
* easily worked around, so always rely on client-level permissions for true security.
*/
allowUnrestrictedFileAccess?: boolean;
/**
* Specify the language to use for code generation.
*/
codegen?: 'typescript' | 'python' | 'java' | 'csharp' | 'none';
}When running headed browser on system w/o display or from worker processes of the IDEs,
run the MCP server from environment with the DISPLAY and pass the --port flag to enable HTTP transport.
npx @playwright/mcp@latest --port 8931And then in MCP client config, set the url to the HTTP endpoint:
{
"mcpServers": {
"playwright": {
"url": "http://localhost:8931/mcp"
}
}
}Related MCP server: Playwright MCP
Playwright MCP is not a security boundary. See MCP Security Best Practices for guidance on securing your deployment.
NOTE: The Docker implementation only supports headless chromium at the moment.
{
"mcpServers": {
"playwright": {
"command": "docker",
"args": ["run", "-i", "--rm", "--init", "--pull=always", "mcr.microsoft.com/playwright/mcp"]
}
}
}Or If you prefer to run the container as a long-lived service instead of letting the MCP client spawn it, use:
docker run -d -i --rm --init --pull=always \
--entrypoint node \
--name playwright \
-p 8931:8931 \
mcr.microsoft.com/playwright/mcp \
/app/cli.js --headless --browser chromium --no-sandbox --port 8931 --host 0.0.0.0The server will listen on host port 8931 and can be reached by any MCP client.
You can build the Docker image yourself.
docker build -t mcr.microsoft.com/playwright/mcp .import http from 'http';
import { createConnection } from '@playwright/mcp';
import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
http.createServer(async (req, res) => {
// ...
// Creates a headless Playwright MCP server with SSE transport
const connection = await createConnection({ browser: { launchOptions: { headless: true } } });
const transport = new SSEServerTransport('/messages', res);
await connection.connect(transport);
// ...
});browser_click
Title: Click
Description: Perform click on a web page
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
doubleClick (boolean, optional): Whether to perform a double click instead of a single click
button (string, optional): Button to click, defaults to left
modifiers (array, optional): Modifier keys to press
Read-only: false
browser_close
Title: Close browser
Description: Close the page
Parameters: None
Read-only: false
browser_console_messages
Title: Get console messages
Description: Returns all console messages
Parameters:
level (string): Level of the console messages to return. Each level includes the messages of more severe levels. Defaults to "info".
all (boolean, optional): Return all console messages since the beginning of the session, not just since the last navigation. Defaults to false.
filename (string, optional): Filename to save the console messages to. If not provided, messages are returned as text.
Read-only: true
browser_drag
Title: Drag mouse
Description: Perform drag and drop between two elements
Parameters:
startElement (string, optional): Human-readable source element description used to obtain the permission to interact with the element
startTarget (string): Exact target element reference from the page snapshot, or a unique element selector
endElement (string, optional): Human-readable target element description used to obtain the permission to interact with the element
endTarget (string): Exact target element reference from the page snapshot, or a unique element selector
Read-only: false
browser_drop
Title: Drop files or data onto an element
Description: Drop files or MIME-typed data onto an element, as if dragged from outside the page. At least one of "paths" or "data" must be provided.
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
paths (array, optional): Absolute paths to files to drop onto the element.
data (object, optional): Data to drop, as a map of MIME type to string value (e.g. {"text/plain": "hello", "text/uri-list": "https://example.com"}).
Read-only: false
browser_evaluate
Title: Evaluate JavaScript
Description: Evaluate JavaScript expression on page or element
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string, optional): Exact target element reference from the page snapshot, or a unique element selector
function (string): () => { /* code / } or (element) => { / code */ } when element is provided
filename (string, optional): Filename to save the result to. If not provided, result is returned as text.
Read-only: false
browser_file_upload
Title: Upload files
Description: Upload one or multiple files
Parameters:
paths (array, optional): The absolute paths to the files to upload. Can be single file or multiple files. If omitted, file chooser is cancelled.
Read-only: false
browser_fill_form
Title: Fill form
Description: Fill multiple form fields
Parameters:
fields (array): Fields to fill in
Read-only: false
browser_find
Title: Find in page snapshot
Description: Search the accessibility snapshot of the current page for text or a regular expression. Returns matching snapshot nodes with a few lines of surrounding context (like search snippets), each shown under its path from the root of the tree, which is cheaper than capturing the whole snapshot when you only need to locate an element and its ref.
Parameters:
text (string, optional): Plain text to search for in the page snapshot (case-insensitive substring match). Provide either text or regex, not both.
regex (string, optional): Regular expression to search for in the page snapshot. Matching is case-sensitive by default; wrap the pattern in slashes to add flags, e.g. "/error/i" for case-insensitive. Provide either text or regex, not both.
Read-only: true
browser_handle_dialog
Title: Handle a dialog
Description: Handle a dialog
Parameters:
accept (boolean): Whether to accept the dialog.
promptText (string, optional): The text of the prompt in case of a prompt dialog.
Read-only: false
browser_hover
Title: Hover mouse
Description: Hover over element on page
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
Read-only: false
browser_navigate
Title: Navigate to a URL
Description: Navigate to a URL
Parameters:
url (string): The URL to navigate to
Read-only: false
browser_navigate_back
Title: Go back
Description: Go back to the previous page in the history
Parameters: None
Read-only: false
browser_network_request
Title: Show network request details
Description: Returns full details (headers and body) of a single network request, or a single part if part is set. Use the number from browser_network_requests.
Parameters:
index (integer): 1-based index of the request, as printed by browser_network_requests.
part (string, optional): Return only this part of the request. Omit to return full details.
filename (string, optional): Filename to save the result to. If not provided, output is returned as text.
Read-only: true
browser_network_requests
Title: List network requests
Description: Returns a numbered list of network requests since loading the page. Use browser_network_request with the number to get full details.
Parameters:
static (boolean): Whether to include successful static resources like images, fonts, scripts, etc. Defaults to false.
filter (string, optional): Only return requests whose URL matches this regexp (e.g. "/api/.*user").
filename (string, optional): Filename to save the network requests to. If not provided, requests are returned as text.
Read-only: true
browser_press_key
Title: Press a key
Description: Press a key on the keyboard
Parameters:
key (string): Name of the key to press or a character to generate, such as ArrowLeft or a
Read-only: false
browser_resize
Title: Resize browser window
Description: Resize the browser window
Parameters:
width (number): Width of the browser window
height (number): Height of the browser window
Read-only: false
browser_run_code_unsafe
Title: Run Playwright code (unsafe)
Description: Run a Playwright code snippet. Unsafe: executes arbitrary JavaScript in the Playwright server process and is RCE-equivalent.
Parameters:
code (string, optional): A JavaScript function containing Playwright code to execute. It will be invoked with a single argument, page, which you can use for any page interaction. For example: async (page) => { await page.getByRole('button', { name: 'Submit' }).click(); return await page.title(); }
filename (string, optional): Load code from the specified file. If both code and filename are provided, code will be ignored.
Read-only: false
browser_select_option
Title: Select option
Description: Select an option in a dropdown
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
values (array): Array of values to select in the dropdown. This can be a single value or multiple values.
Read-only: false
browser_snapshot
Title: Page snapshot
Description: Capture accessibility snapshot of the current page, this is better than screenshot
Parameters:
target (string, optional): Exact target element reference from the page snapshot, or a unique element selector
filename (string, optional): Save snapshot to markdown file instead of returning it in the response.
depth (number, optional): Limit the depth of the snapshot tree
boxes (boolean, optional): Include each element's bounding box as [box=x,y,width,height] in the snapshot. Coordinates are viewport-relative, in CSS pixels (Element.getBoundingClientRect)
Read-only: true
browser_take_screenshot
Title: Take a screenshot
Description: Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string, optional): Exact target element reference from the page snapshot, or a unique element selector
type (string, optional): Image format for the screenshot. If unset, inferred from the filename extension, otherwise png.
filename (string, optional): File name to save the screenshot to. Defaults to page-{timestamp}.{png|jpeg|webp} if not specified. Prefer relative file names to stay within the output directory.
fullPage (boolean, optional): When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots.
scale (string): Image resolution scale. "css" produces a screenshot sized in CSS pixels (smaller, consistent across devices). "device" produces a high-resolution screenshot using device pixels (larger, accounts for the device pixel ratio). Default is css.
Read-only: true
browser_type
Title: Type text
Description: Type text into editable element
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
text (string): Text to type into the element
submit (boolean, optional): Whether to submit entered text (press Enter after)
slowly (boolean, optional): Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.
Read-only: false
browser_wait_for
Title: Wait for
Description: Wait for text to appear or disappear or a specified time to pass
Parameters:
time (number, optional): The time to wait in seconds
text (string, optional): The text to wait for
textGone (string, optional): The text to wait for to disappear
Read-only: false
browser_tabs
Title: Manage tabs
Description: List, create, close, or select a browser tab.
Parameters:
action (string): Operation to perform
index (number, optional): Tab index, used for close/select. If omitted for close, current tab is closed.
url (string, optional): URL to navigate to in the new tab, used for new.
Read-only: false
browser_get_config
Title: Get config
Description: Get the final resolved config after merging CLI options, environment variables and config file.
Parameters: None
Read-only: true
browser_network_state_set
Title: Set network state
Description: Sets the browser network state to online or offline. When offline, all network requests will fail.
Parameters:
state (string): Set to "offline" to simulate offline mode, "online" to restore network connectivity
Read-only: false
browser_route
Title: Mock network requests
Description: Set up a route to mock network requests matching a URL pattern
Parameters:
pattern (string): URL pattern to match (e.g., "/api/users", "/*.{png,jpg}")
status (number, optional): HTTP status code to return (default: 200)
body (string, optional): Response body (text or JSON string)
contentType (string, optional): Content-Type header (e.g., "application/json", "text/html")
headers (array, optional): Headers to add in "Name: Value" format
removeHeaders (string, optional): Comma-separated list of header names to remove from request
Read-only: false
browser_route_list
Title: List network routes
Description: List all active network routes
Parameters: None
Read-only: true
browser_unroute
Title: Remove network routes
Description: Remove network routes matching a pattern (or all routes if no pattern specified)
Parameters:
pattern (string, optional): URL pattern to unroute (omit to remove all routes)
Read-only: false
browser_cookie_clear
Title: Clear cookies
Description: Clear all cookies
Parameters: None
Read-only: false
browser_cookie_delete
Title: Delete cookie
Description: Delete a specific cookie
Parameters:
name (string): Cookie name to delete
Read-only: false
browser_cookie_get
Title: Get cookie
Description: Get a specific cookie by name
Parameters:
name (string): Cookie name to get
Read-only: true
browser_cookie_list
Title: List cookies
Description: List all cookies (optionally filtered by domain/path)
Parameters:
domain (string, optional): Filter cookies by domain
path (string, optional): Filter cookies by path
Read-only: true
browser_cookie_set
Title: Set cookie
Description: Set a cookie with optional flags (domain, path, expires, httpOnly, secure, sameSite)
Parameters:
name (string): Cookie name
value (string): Cookie value
domain (string, optional): Cookie domain
path (string, optional): Cookie path
expires (number, optional): Cookie expiration as Unix timestamp
httpOnly (boolean, optional): Whether the cookie is HTTP only
secure (boolean, optional): Whether the cookie is secure
sameSite (string, optional): Cookie SameSite attribute
Read-only: false
browser_localstorage_clear
Title: Clear localStorage
Description: Clear all localStorage
Parameters: None
Read-only: false
browser_localstorage_delete
Title: Delete localStorage item
Description: Delete a localStorage item
Parameters:
key (string): Key to delete
Read-only: false
browser_localstorage_get
Title: Get localStorage item
Description: Get a localStorage item by key
Parameters:
key (string): Key to get
Read-only: true
browser_localstorage_list
Title: List localStorage
Description: List all localStorage key-value pairs
Parameters: None
Read-only: true
browser_localstorage_set
Title: Set localStorage item
Description: Set a localStorage item
Parameters:
key (string): Key to set
value (string): Value to set
Read-only: false
browser_sessionstorage_clear
Title: Clear sessionStorage
Description: Clear all sessionStorage
Parameters: None
Read-only: false
browser_sessionstorage_delete
Title: Delete sessionStorage item
Description: Delete a sessionStorage item
Parameters:
key (string): Key to delete
Read-only: false
browser_sessionstorage_get
Title: Get sessionStorage item
Description: Get a sessionStorage item by key
Parameters:
key (string): Key to get
Read-only: true
browser_sessionstorage_list
Title: List sessionStorage
Description: List all sessionStorage key-value pairs
Parameters: None
Read-only: true
browser_sessionstorage_set
Title: Set sessionStorage item
Description: Set a sessionStorage item
Parameters:
key (string): Key to set
value (string): Value to set
Read-only: false
browser_set_storage_state
Title: Restore storage state
Description: Restore storage state (cookies, local storage) from a file. This clears existing cookies and local storage before restoring.
Parameters:
filename (string): Path to the storage state file to restore from
Read-only: false
browser_storage_state
Title: Save storage state
Description: Save storage state (cookies, local storage) to a file for later reuse
Parameters:
filename (string, optional): File name to save the storage state to. Defaults to storage-state-{timestamp}.json if not specified.
Read-only: true
browser_annotate
Title: Annotate the current page
Description: Open the Playwright Dashboard in annotation mode for the current page and wait for the user to draw annotations. Returns the annotated screenshot, ARIA snapshot, and the list of annotations.
Parameters: None
Read-only: true
browser_hide_highlight
Title: Hide element highlight
Description: Remove a highlight overlay previously added for the element.
Parameters:
element (string, optional): Human-readable element description used when adding the highlight; must match the value passed to browser_highlight.
target (string, optional): Exact target element reference from the page snapshot, or a unique element selector
Read-only: true
browser_highlight
Title: Highlight element
Description: Show a persistent highlight overlay around the element on the page.
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
style (string, optional): Additional inline CSS applied to the highlight overlay, e.g. "outline: 2px dashed red".
Read-only: true
browser_resume
Title: Resume paused script execution
Description: Resume script execution after it was paused. When called with step set to true, execution will pause again before the next action.
Parameters:
step (boolean, optional): When true, execution will pause again before the next action, allowing step-by-step debugging.
location (string, optional): Pause execution at a specific :, e.g. "example.spec.ts:42".
Read-only: false
browser_start_tracing
Title: Start tracing
Description: Start trace recording
Parameters: None
Read-only: true
browser_start_video
Title: Start video
Description: Start video recording
Parameters:
filename (string, optional): Filename to save the video.
size (object, optional): Video size
Read-only: true
browser_stop_tracing
Title: Stop tracing
Description: Stop trace recording
Parameters: None
Read-only: true
browser_stop_video
Title: Stop video
Description: Stop video recording
Parameters: None
Read-only: true
browser_video_chapter
Title: Video chapter
Description: Add a chapter marker to the video recording. Shows a full-screen chapter card with blurred backdrop.
Parameters:
title (string): Chapter title
description (string, optional): Chapter description
duration (number, optional): Duration in milliseconds to show the chapter card
Read-only: true
browser_video_hide_actions
Title: Hide action overlays
Description: Stop annotating actions performed on the page.
Parameters: None
Read-only: true
browser_video_show_actions
Title: Show action overlays
Description: Annotate subsequent actions performed on the page with a callout that names the action and highlights the target element. Useful while video recording or screencasting.
Parameters:
duration (number, optional): How long each action annotation stays on screen, in milliseconds. Defaults to 500.
position (string, optional): Where to place the action title relative to the page. Defaults to top-right.
cursor (string, optional): Cursor decoration for pointer actions. "pointer" (default) animates a mouse pointer from the previous action point to the next one; "none" disables the cursor decoration.
Read-only: true
browser_mouse_click_xy
Title: Click
Description: Click mouse button at a given position
Parameters:
x (number): X coordinate
y (number): Y coordinate
button (string, optional): Button to click, defaults to left
clickCount (number, optional): Number of clicks, defaults to 1
delay (number, optional): Time to wait between mouse down and mouse up in milliseconds, defaults to 0
Read-only: false
browser_mouse_down
Title: Press mouse down
Description: Press mouse down
Parameters:
button (string, optional): Button to press, defaults to left
Read-only: false
browser_mouse_drag_xy
Title: Drag mouse
Description: Drag left mouse button to a given position
Parameters:
startX (number): Start X coordinate
startY (number): Start Y coordinate
endX (number): End X coordinate
endY (number): End Y coordinate
Read-only: false
browser_mouse_move_xy
Title: Move mouse
Description: Move mouse to a given position
Parameters:
x (number): X coordinate
y (number): Y coordinate
Read-only: false
browser_mouse_up
Title: Press mouse up
Description: Press mouse up
Parameters:
button (string, optional): Button to press, defaults to left
Read-only: false
browser_mouse_wheel
Title: Scroll mouse wheel
Description: Scroll mouse wheel
Parameters:
deltaX (number): X delta
deltaY (number): Y delta
Read-only: false
browser_pdf_save
Title: Save as PDF
Description: Save page as PDF
Parameters:
filename (string, optional): File name to save the pdf to. Defaults to page-{timestamp}.pdf if not specified. Prefer relative file names to stay within the output directory.
Read-only: true
browser_generate_locator
Title: Create locator for element
Description: Generate locator for the given element to use in tests
Parameters:
element (string, optional): Human-readable element description used to obtain permission to interact with the element
target (string): Exact target element reference from the page snapshot, or a unique element selector
Read-only: true
browser_verify_element_visible
Title: Verify element visible
Description: Verify element is visible on the page
Parameters:
role (string): ROLE of the element. Can be found in the snapshot like this: - {ROLE} "Accessible Name":
accessibleName (string): ACCESSIBLE_NAME of the element. Can be found in the snapshot like this: - role "{ACCESSIBLE_NAME}"
Read-only: false
browser_verify_list_visible
Title: Verify list visible
Description: Verify list is visible on the page
Parameters:
element (string): Human-readable list description
target (string): Exact target element reference that points to the list
items (array): Items to verify
Read-only: false
browser_verify_text_visible
Title: Verify text visible
Description: Verify text is visible on the page. Prefer browser_verify_element_visible if possible.
Parameters:
text (string): TEXT to verify. Can be found in the snapshot like this: - role "Accessible Name": {TEXT} or like this: - text: {TEXT}
Read-only: false
browser_verify_value
Title: Verify value
Description: Verify element value
Parameters:
type (string): Type of the element
element (string): Human-readable element description
target (string): Exact target element reference from the page snapshot
value (string): Value to verify. For checkbox, use "true" or "false".
Read-only: false
Perform click on a web page
| Name | Required | Description | Default |
|---|---|---|---|
| button | No | Button to click, defaults to left | |
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element | |
| modifiers | No | Modifier keys to press | |
| doubleClick | No | Whether to perform a double click instead of a single click |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description is a basic action statement and adds no behavioral context beyond what the annotations already convey (readOnlyHint=false, destructiveHint=true). It does not disclose potential side effects, permission requirements, or what happens after the click, so it offers minimal additional transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no wordiness, which earns points for brevity. However, it is so minimal that it lacks useful structural elements like specifics on target or modifiers, making it only average in structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, no output schema, many sibling tools), the description is severely incomplete. It omits any context about target references, permission flows, or behavioral effects, relying entirely on the schema and annotations. This is insufficient for an agent to use the tool confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides full descriptions for all parameters (100% coverage), so the description does not need to explain them. The description itself adds little to parameter understanding, but the schema already carries the semantic load, resulting in a baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Perform click') and the resource ('a web page'), which is specific enough to understand the tool's basic purpose. However, it does not distinguish this tool from sibling tools like browser_hover or browser_press_key, so it lacks sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites such as obtaining a page snapshot or needing an exact target element reference. The description simply states the action without any context for appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close the page
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, so the agent knows this is a destructive operation. The description adds no further context about what is destroyed (e.g., current tab vs. entire browser session) or potential side effects, but given the simplicity, a baseline score of 3 is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, 'Close the page,' which is extremely concise and front-loaded. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with no parameters and no output schema, the description is minimal but leaves ambiguity about the scope (e.g., does it close the current tab or the whole browser?). Additional context about the extent of the action would improve completeness, though it is not severely lacking.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters, the baseline is 4 as per the rubric. There is no parameter information needed, and the description correctly omits any parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Close the page' clearly states a specific verb and resource, uniquely distinguishing this tool from all sibling browser tools. It is unambiguous and immediately conveys the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or typical use cases. It simply states the action without contextual direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns all console messages
| Name | Required | Description | Default |
|---|---|---|---|
| all | No | Return all console messages since the beginning of the session, not just since the last navigation. Defaults to false. | |
| level | Yes | Level of the console messages to return. Each level includes the messages of more severe levels. Defaults to "info". | info |
| filename | No | Filename to save the console messages to. If not provided, messages are returned as text. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral traits beyond what annotations already provide. Annotations indicate readOnlyHint=true and destructiveHint=false, but the description doesn't mention defaults, the 'all' parameter's effect, or that it can save to a file. It is essentially a restatement of the title.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one short sentence, efficient and front-loaded. However, it is under-specified, omitting important behavioral details, so it loses a point for being too terse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 3 parameters with meaningful options (level, all, filename) and no output schema, the description is incomplete. It fails to hint that messages can be filtered by severity, retrieved from session start, or saved to a file. The word 'all' conflicts with the default filtering behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning about the parameters (level, all, filename), relying entirely on the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb+resource ('Returns all console messages'), but the word 'all' is misleading because the tool supports filtering by level and scope (since last navigation vs. entire session). It doesn't differentiate from sibling tools like browser_network_requests, though the resource itself is unique.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool vs. alternatives, any prerequisites (e.g., browser must be open), or exclusions. It is a single statement with no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Perform drag and drop between two elements
| Name | Required | Description | Default |
|---|---|---|---|
| endTarget | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| endElement | No | Human-readable target element description used to obtain the permission to interact with the element | |
| startTarget | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| startElement | No | Human-readable source element description used to obtain the permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral detail beyond what annotations already convey (destructive, not read-only). It does not mention side effects, permission requirements, or that elements must be visible, leaving the agent to infer these from the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that is front-loaded with the key action. There is no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a drag-and-drop operation with four parameters and no output schema, the description is too minimal. It doesn't explain how targets are specified or what happens after the action, relying entirely on the schema. More context would be needed for reliable tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and each parameter (startTarget, endTarget, startElement, endElement) has a clear description. The tool description adds no additional parameter meaning, which is acceptable given full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Perform drag and drop between two elements' clearly states the action and resource (two elements). It uses a specific verb phrase, but does not distinguish itself from the sibling tool 'browser_drop'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like browser_drop, browser_click, or browser_hover. The description simply states what it does without explaining context or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Drop files or MIME-typed data onto an element, as if dragged from outside the page. At least one of "paths" or "data" must be provided.
| Name | Required | Description | Default |
|---|---|---|---|
| data | No | Data to drop, as a map of MIME type to string value (e.g. {"text/plain": "hello", "text/uri-list": "https://example.com"}). | |
| paths | No | Absolute paths to files to drop onto the element. | |
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint:true and readOnlyHint:false. The description adds the 'as if dragged from outside the page' mechanism and the required condition for paths/data, but does not disclose side effects, permission requirements, or what triggers, beyond what annotations imply.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, action front-loaded, no filler. The first sentence states the tool's purpose, and the second sentence provides a crucial constraint, making every word useful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a moderate-complexity mutation tool with no output schema, the description covers the core action, input constraint, and drop origin. It does not elaborate on element compatibility or return values, but the schema already details parameter formats.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, but the description adds the essential 'At least one of paths or data must be provided' constraint, which is not in the schema. It also clarifies that 'data' is a MIME-typed map, reinforcing the schema's examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Drop' and clearly identifies the resource: 'files or MIME-typed data onto an element'. It distinguishes from sibling tools like browser_drag by explicitly noting 'as if dragged from outside the page', which frames the unique behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives context (simulating an external drag) but does not explicitly state when to choose this over alternatives like browser_file_upload or browser_drag. The 'At least one of paths or data must be provided' is a parameter rule, not an usage guideline comparing to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Evaluate JavaScript expression on page or element
| Name | Required | Description | Default |
|---|---|---|---|
| target | No | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element | |
| filename | No | Filename to save the result to. If not provided, result is returned as text. | |
| function | Yes | () => { /* code */ } or (element) => { /* code */ } when element is provided |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare destructiveHint=true, openWorldHint=true, and readOnlyHint=false, covering the risk profile. The description adds the scope 'on page or element' but does not disclose additional behavioral details like potential DOM modifications, network requests, or permission prompts. Since annotations cover the main safety aspects, a midpoint score is appropriate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no unnecessary words. It is concise and to the point, earning its place by stating the core functionality without fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having a moderately complex execution tool, the description is overly terse. It does not mention how results are returned (text vs. file), the impact of providing target/element, or any caveats about running arbitrary JavaScript. The schema and annotations cover some details, but the description leaves significant gaps for an agent deciding how to invoke this tool safely and correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides descriptions for all four parameters (target, element, filename, function), achieving 100% coverage. The tool description does not add any extra meaning beyond the schema, so it meets the baseline but does not exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Evaluate' and the resource 'JavaScript expression on page or element', giving a specific action and scope. However, it does not differentiate this tool from the sibling 'browser_run_code_unsafe', which also executes code, so it loses one point.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like browser_run_code_unsafe or other browser interaction tools. It does not mention prerequisites such as needing a page snapshot for element targeting, nor does it explain when file saving vs. text return is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Upload one or multiple files
| Name | Required | Description | Default |
|---|---|---|---|
| paths | No | The absolute paths to the files to upload. Can be single file or multiple files. If omitted, file chooser is cancelled. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral context beyond what annotations already declare. Annotations indicate destructiveHint=true and readOnlyHint=false, but the description does not explain side effects (e.g., opening a dialog, replacing files) or any authorization requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, succinct sentence with no fluff or redundancy. It is front-loaded and easy to parse, though it could be marginally more informative without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too sparse to be complete for a mutation tool with no output schema. It does not mention return values, what happens after upload, or the file chooser interaction. The schema covers parameter details, but the overall tool behavior remains under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and thoroughly explains the 'paths' parameter, including the conditional behavior of omitting it. The description itself adds no extra semantic information, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool uploads one or multiple files, which is a specific verb and resource. It does not explicitly distinguish from sibling tools like browser_drop, but the action of uploading is distinct enough in the context of browser file operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as browser_drop. It neither mentions the file picker context nor advises on prerequisites or scenarios where upload is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fill multiple form fields
| Name | Required | Description | Default |
|---|---|---|---|
| fields | Yes | Fields to fill in |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true and readOnlyHint=false, so the tool is known to be a write operation. The description adds no behavioral context beyond the basic action, such as how fields are matched, whether the page must be snapshotted, or side effects. Since no additional context is provided, the score is low.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words, but it is arguably too terse. It is front-loaded, yet it lacks detail that would make it a 5. Similar to the 'update_drive' example, one efficient sentence earns a 4.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool handles a complex input schema with multiple field types and nested objects, yet the description gives no information about prerequisites (like needing a snapshot), return behavior, or how it interacts with the page. This is inadequate for a tool with this complexity. The lack of an output schema compounds the issue.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents each parameter (target, name, type, value, element). The description adds no extra semantics beyond the schema. Per the rubric, baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Fill multiple form fields' clearly states a specific action (fill) and a resource (form fields), but it does not explicitly distinguish this from sibling tools like browser_type or browser_select_option. The word 'multiple' hints at its scope, but a clearer differentiation would earn a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention that it is for filling multiple fields at once or that browser_type/browser_select_option are for single-field interactions. This leaves the agent without clear usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search the accessibility snapshot of the current page for text or a regular expression. Returns matching snapshot nodes with a few lines of surrounding context (like search snippets), each shown under its path from the root of the tree, which is cheaper than capturing the whole snapshot when you only need to locate an element and its ref.
| Name | Required | Description | Default |
|---|---|---|---|
| text | No | Plain text to search for in the page snapshot (case-insensitive substring match). Provide either text or regex, not both. | |
| regex | No | Regular expression to search for in the page snapshot. Matching is case-sensitive by default; wrap the pattern in slashes to add flags, e.g. "/error/i" for case-insensitive. Provide either text or regex, not both. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, establishing the safety profile. The description adds valuable behavioral details: it returns matching nodes with surrounding context, shows paths from the tree root, and notes the cost savings versus full snapshot. This goes beyond annotations and gives the agent a clear model of execution and output.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, information-dense sentence. It front-loads the core action, then efficiently packs in the return format, context snippets, path display, and cost comparison. Every clause earns its place with no fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (two optional parameters, no output schema, read-only). The description explains what it returns, how results are presented, and why you'd use it over a full snapshot. No major gaps remain for an agent to invoke or interpret the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%: both 'text' and 'regex' have detailed descriptions including case sensitivity, substring matching, flags, and mutual exclusivity. The description only reiterates the 'either/or' constraint, adding no new parameter-level insight. Baseline for high coverage is 3, and nothing here lifts it higher.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Search the accessibility snapshot of the current page for text or a regular expression.' This clearly states what the tool does and immediately distinguishes it from sibling tools like browser_snapshot (which captures the whole snapshot) by focusing on search within the snapshot.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to prefer this tool: 'cheaper than capturing the whole snapshot when you only need to locate an element and its ref.' This implies the alternative is browser_snapshot. It also provides a crucial usage constraint: 'Provide either text or regex, not both.' However, it does not explicitly state when not to use it or name other alternatives, so it's not a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Handle a dialog
| Name | Required | Description | Default |
|---|---|---|---|
| accept | Yes | Whether to accept the dialog. | |
| promptText | No | The text of the prompt in case of a prompt dialog. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral context beyond what annotations already declare (readOnlyHint=false, destructiveHint=true). It does not explain what happens on accept vs. dismiss, how promptText is used, or any side effects or failure modes. Without this, the agent must rely entirely on guesses.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is only three words, which is under-specification rather than concise effectiveness. It omits necessary information and fails to earn its place as a standalone description. The structure does not help the agent understand the tool's behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (dialog handling with accept boolean and optional promptText) and lack of output schema, the description is severely incomplete. It does not explain how to use the tool correctly, what happens in various scenarios, or the expected outcome, leaving the agent with insufficient information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides 100% coverage with clear descriptions for both accept and promptText. The description text adds nothing about parameters, but the baseline for full schema coverage is 3, so this is an appropriate score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Handle a dialog' is essentially a restatement of the tool name 'browser_handle_dialog' and provides no specifics about what handling entails (e.g., accept, dismiss, provide text). It fails to distinguish this tool from sibling browser actions or clarify its unique role in dialog management, making it nearly tautological.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool, such as how to detect a dialog, whether to accept or dismiss, or how it fits with other browser tools. No alternatives or exclusions are mentioned anywhere in the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Hover over element on page
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate destructiveHint: true and readOnlyHint: false, signaling potential side effects, but the description adds no additional behavioral context (e.g., that hovering may trigger JavaScript events or alter page state). No extra value beyond the annotations is provided, and no contradiction exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. 'Hover over element on page' is appropriately sized for a simple action, and every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the tool's apparent simplicity, the annotation destructiveHint: true suggests potential negative side effects that are not explained. The description omits any mention of prerequisites (e.g., needing a page snapshot), potential effects, or relationship to other tools, leaving the context incomplete for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully covers both parameters (target and element) with clear descriptions, so schema coverage is 100%. The tool description adds no parameter-specific insights, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Hover over element on page' clearly states the action (hover) and the target (element on page), which is specific and distinguishes it from siblings like browser_click or browser_drag. However, it does not explicitly contrast with alternatives, so it stops short of full differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus other browser interaction tools such as browser_click or browser_drag. The description simply states the action without providing context or exclusions, leaving the agent to infer appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns full details (headers and body) of a single network request, or a single part if part is set. Use the number from browser_network_requests.
| Name | Required | Description | Default |
|---|---|---|---|
| part | No | Return only this part of the request. Omit to return full details. | |
| index | Yes | 1-based index of the request, as printed by browser_network_requests. | |
| filename | No | Filename to save the result to. If not provided, output is returned as text. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, so the safety profile is covered. The description adds the behavioral detail that it can return either full details or a single part via the 'part' parameter, which is useful context beyond the annotations. However, it does not describe error behaviors or what happens when the index is invalid, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main purpose, and every word earns its place. It efficiently communicates the tool's function and the key usage hint.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only retrieval tool with strong annotations and full schema coverage, the description is largely complete. It explains the core behavior and the source of the index. It omits details like return format or error cases, but the annotations and schema compensate, so the overall context is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well documented. The description adds extra meaning by explaining that the 'index' comes from browser_network_requests and that 'part' can restrict the output to a single part. This goes beyond the schema's basic field descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns full details of a single network request, with a specific verb ('Returns') and resource ('details of a single network request'). It also distinguishes itself from the sibling tool browser_network_requests by emphasizing 'single' and referencing its index.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The instruction to 'Use the number from browser_network_requests' provides clear context for when to use this tool, linking it to the list tool. It does not explicitly mention alternatives or exclusions, but the usage context is clear enough for an agent to select it appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns a numbered list of network requests since loading the page. Use browser_network_request with the number to get full details.
| Name | Required | Description | Default |
|---|---|---|---|
| filter | No | Only return requests whose URL matches this regexp (e.g. "/api/.*user"). | |
| static | Yes | Whether to include successful static resources like images, fonts, scripts, etc. Defaults to false. | |
| filename | No | Filename to save the network requests to. If not provided, requests are returned as text. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by noting the temporal scope ('since loading the page') and the output format ('numbered list'), which are behavioral traits not present in annotations. No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary action and scope, followed by a precise cross-reference to the sibling tool. No redundant or filler content; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, and the schema covers parameters thoroughly. The description tells the agent what output to expect (numbered list) and how to get full details. It doesn't explain return structure in depth, but with no output schema and good annotations, this is mostly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all three parameters (filter, static, filename) are fully documented in the schema. The description does not add additional meaning beyond what the schema provides, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Returns a numbered list of network requests since loading the page.' It uses a specific verb ('Returns') and resource ('network requests'), and the scope 'since loading the page' distinguishes it from the sibling browser_network_request, which provides full details for a single request.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly guides usage to an alternative: 'Use browser_network_request with the number to get full details.' This tells the agent when to use this tool (to get a list) and when to switch to the sibling (for details). It clearly maps the workflow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Press a key on the keyboard
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | Name of the key to press or a character to generate, such as `ArrowLeft` or `a` |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutating action. However, the description adds no behavioral context beyond that, such as potential side effects like submitting forms or triggering navigation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, 'Press a key on the keyboard', which is front-loaded and free of unnecessary words. Every word earns its place, though it adds minimal information beyond the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one documented parameter and annotations, so the description is minimally sufficient. However, it lacks context about when to use this tool versus browser_type and does not mention potential side effects, leaving some gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully describes the 'key' parameter with examples like 'ArrowLeft' and 'a', giving 100% coverage. The description adds no additional parameter meaning, which is acceptable given the schema already documents it well.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool presses a keyboard key, which is a specific verb+resource action. It distinguishes from mouse actions like browser_click and browser_hover, but does not explicitly differentiate from browser_type, which is for typing text.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as browser_type or browser_click. There is no mention of scenarios where keyboard input is appropriate or when to avoid it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Resize the browser window
| Name | Required | Description | Default |
|---|---|---|---|
| width | Yes | Width of the browser window | |
| height | Yes | Height of the browser window |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description does not disclose any behavioral traits beyond what the annotations already state (destructiveHint=true, readOnlyHint=false). It adds no context about side effects, state changes, or implications, so the description fails to enrich the agent's understanding beyond the tool's title.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, short sentence, making it concise and front-loaded. However, it is extremely minimal, providing only the action without any elaboration, which slightly reduces usefulness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool and the presence of annotations (destructiveHint, openWorldHint) and full parameter descriptions in the schema, the description is adequate for basic understanding. However, it omits potential details like units or the distinction between viewport and outer window, leaving minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with both width and height having descriptions ('Width of the browser window' and 'Height of the browser window'). The tool description adds no extra parameter semantics, such as units or value ranges, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Resize the browser window' uses a specific verb and resource, clearly indicating the tool's action. It distinguishes itself from sibling tools like browser_navigate or browser_snapshot, though it lacks additional scope detail (e.g., whether it affects the viewport or the entire window).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, typical use cases, or exclusions, leaving the agent to infer usage solely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run a Playwright code snippet. Unsafe: executes arbitrary JavaScript in the Playwright server process and is RCE-equivalent.
| Name | Required | Description | Default |
|---|---|---|---|
| code | No | A JavaScript function containing Playwright code to execute. It will be invoked with a single argument, page, which you can use for any page interaction. For example: `async (page) => { await page.getByRole('button', { name: 'Submit' }).click(); return await page.title(); }` | |
| filename | No | Load code from the specified file. If both code and filename are provided, code will be ignored. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (destructiveHint, readOnlyHint), the description adds crucial context: it executes arbitrary JavaScript in the Playwright server process and is RCE-equivalent. This warns about the actual risk and execution environment, which is valuable transparency. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with zero waste. It leads with the core purpose, then immediately gives the critical safety warning. Perfectly sized and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With annotations covering safety and the schema covering parameters, the description adequately rounds out the tool by explaining the execution context and RCE risk. No output schema exists, so explaining return values is not required, but the lack of mention of return behavior is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides full descriptions for both parameters (code and filename), so schema coverage is 100%. The description does not add additional parameter semantics, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Run a Playwright code snippet.' This is a specific verb+resource combination, though it does not explicitly contrast with browser_evaluate or other siblings to highlight its uniqueness beyond the 'unsafe' warning.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives. The 'Unsafe' label implies caution but does not mention any exclusions or better-matched sibling tools, leaving the agent to infer appropriate usage without concrete direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Select an option in a dropdown
| Name | Required | Description | Default |
|---|---|---|---|
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| values | Yes | Array of values to select in the dropdown. This can be a single value or multiple values. | |
| element | No | Human-readable element description used to obtain permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral context beyond the basic action, such as side effects, permission requirements, or handling of multiple values. Annotations already indicate destructive and open-world behavior, but the description itself fails to disclose any additional traits about how the dropdown selection is performed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, with no redundant information. It is perfectly front-loaded and every word is purposeful, though it may be too brief to be fully helpful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity, the schema's thorough parameter descriptions, and annotations covering safety, the description is mostly complete. However, it omits any mention of how multiple values are handled on single-select dropdowns or how targets are acquired, which could be inferred from the schema but are not explicitly stated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides full descriptions for all three parameters (target, values, element), achieving 100% coverage. The description offers no additional guidance or clarification about parameter formats, relationships, or edge cases, so it adds no value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Select') and resource ('option in a dropdown'), distinguishing it from sibling browser interaction tools like browser_click or browser_type. It leaves no ambiguity about the tool's purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool over alternatives, such as browser_type or browser_click, nor does it mention prerequisites like obtaining target references from a snapshot. There are no exclusions or contextual hints, leaving the agent to infer usage from the name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Capture accessibility snapshot of the current page, this is better than screenshot
| Name | Required | Description | Default |
|---|---|---|---|
| boxes | No | Include each element's bounding box as [box=x,y,width,height] in the snapshot. Coordinates are viewport-relative, in CSS pixels (Element.getBoundingClientRect) | |
| depth | No | Limit the depth of the snapshot tree | |
| target | No | Exact target element reference from the page snapshot, or a unique element selector | |
| filename | No | Save snapshot to markdown file instead of returning it in the response. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the 'accessibility snapshot' concept and the comparison to screenshots, but does not disclose behavioral details like return structure, which is acceptable given the strong annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence that immediately states the action and resource, then adds a useful comparison. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with well-described parameters, but the description does not clarify what an 'accessibility snapshot' returns or how to use the snapshot tree, especially with no output schema. Some gaps remain in understanding the tool's response.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all four parameters are already well documented. The description adds no additional parameter semantics, but the baseline of 3 is appropriate since the schema carries the full burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Capture') and resource ('accessibility snapshot of the current page'), clearly distinguishing it from sibling browser_take_screenshot. The phrase 'better than screenshot' reinforces its specific purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear comparison to screenshots ('better than screenshot'), which implicitly directs when to use this tool over a major alternative. However, it does not mention other alternative tools like browser_find or browser_evaluate, so the guidance is limited but not misleading.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List, create, close, or select a browser tab.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | URL to navigate to in the new tab, used for new. | |
| index | No | Tab index, used for close/select. If omitted for close, current tab is closed. | |
| action | Yes | Operation to perform |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds no behavioral context beyond the operation list; it does not mention consequences of closing a tab or whether select changes the active tab. The annotations already indicate destructive potential, so the description carries no additional transparency value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler, front-loading the main actions. It is appropriately minimal for the tool's simple scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a multi-action tool, the description sufficiently names all operations, and the schema fills in parameter details. It is complete enough for basic tool selection, though additional context on side effects would improve usability.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers all three parameters with descriptions (100% coverage), so the tool description adds no parameter-level meaning. The description does not reference url, index, or action specifics beyond the operation names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description lists four specific operations (List, create, close, select) on the browser tab resource, clearly distinguishing it from siblings like browser_navigate or browser_close. The verb+resource structure makes the tool's purpose immediately apparent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as browser_navigate or browser_close. It simply enumerates actions without indicating priorities, prerequisites, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Image format for the screenshot. If unset, inferred from the filename extension, otherwise png. | |
| scale | Yes | Image resolution scale. "css" produces a screenshot sized in CSS pixels (smaller, consistent across devices). "device" produces a high-resolution screenshot using device pixels (larger, accounts for the device pixel ratio). Default is css. | css |
| target | No | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element | |
| filename | No | File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg|webp}` if not specified. Prefer relative file names to stay within the output directory. | |
| fullPage | No | When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds a key behavioral trait beyond this: screenshots are not actionable and should be used only for visual inspection. This is valuable context that annotations don't convey, although it doesn't detail other behavioral aspects like return values or file saving behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exactly two sentences, with the purpose front-loaded and the crucial usage caveat following immediately. Every sentence earns its place with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters and no output schema, the description provides enough context for selection: it states the purpose, gives an alternative, and the schema handles parameter semantics. However, it doesn't mention what the tool returns (e.g., an image file path), but the tool name and filename parameter imply this. It is reasonably complete but could be slightly more explicit about the output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all 6 parameters are already well-documented in the schema. The description adds no parameter-specific meaning beyond what the schema provides, thus it meets the baseline of 3 without adding extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states precisely what the tool does: 'Take a screenshot of the current page.' This is a specific verb + resource, and it clearly distinguishes from sibling tools like browser_snapshot by noting the screenshot cannot be used for actions, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage guidance: 'You can't perform actions based on the screenshot, use browser_snapshot for actions.' This directly tells the agent when NOT to use this tool and names the alternative (browser_snapshot), fulfilling the when-to-use vs alternatives criterion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Type text into editable element
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | Text to type into the element | |
| slowly | No | Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once. | |
| submit | No | Whether to submit entered text (press Enter after) | |
| target | Yes | Exact target element reference from the page snapshot, or a unique element selector | |
| element | No | Human-readable element description used to obtain permission to interact with the element |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false and destructiveHint=true, covering the safety profile. The description adds no additional behavioral context beyond restating the action, but it does not contradict the annotations. No extra disclosure like side effects or permission requirements is provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, succinct sentence that directly conveys the core action. Every word is purposeful and there is no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (5 parameters, destructive annotation, and many sibling tools), the description is under-specified. It does not explain when to use it, how it differs from similar tools, or any potential side effects. The schema covers parameter syntax but not usage context, leaving the agent without enough information for correct selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 100% of parameters with descriptions, so the baseline is 3. The description does not elaborate on parameters like 'slowly' or 'submit', but the schema already documents them adequately, so no additional semantics are necessary.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Type text into editable element' uses a specific verb and resource, clearly indicating the action. However, it does not distinguish from sibling tools like browser_fill_form or browser_press_key, which may also involve text input, lacking explicit scope differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There is no mention of suitable contexts, exclusions, or references to sibling tools, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Wait for text to appear or disappear or a specified time to pass
| Name | Required | Description | Default |
|---|---|---|---|
| text | No | The text to wait for | |
| time | No | The time to wait in seconds | |
| textGone | No | The text to wait for to disappear |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, covering the safety profile. The description adds the three waiting modes (appear, disappear, time), which are the core behavioral traits. It does not mention timeout behavior or error handling, but with annotations this is a minor gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys all essential information without any filler. It is appropriately concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, has no output schema, and annotations cover safety. The description covers the main usage modes. However, it does not specify default timeout behavior or what happens if the wait condition is not met, which could be useful but is not critical given the tool's simplicity and the presence of a 'time' parameter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for all three parameters. The description reinforces the schema by clearly mapping 'text' to appearance, 'textGone' to disappearance, and 'time' to a duration, adding semantic context beyond the raw schema properties.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Wait') and the target resources (text to appear, disappear, or a time to pass). It clearly distinguishes this tool from siblings like browser_find or browser_evaluate by focusing solely on waiting behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you need to wait for a condition, but it does not explicitly state when to use this tool versus alternatives, nor does it mention prerequisites or common scenarios. No exclusions are provided, so it is adequate but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.0.79browser_clickbrowser_closebrowser_console_messagesbrowser_dragbrowser_dropbrowser_evaluatebrowser_file_uploadbrowser_fill_formbrowser_findbrowser_handle_dialogbrowser_hoverbrowser_navigatebrowser_navigate_backbrowser_network_requestbrowser_network_requestsbrowser_press_keybrowser_resizebrowser_run_code_unsafebrowser_select_optionbrowser_snapshotbrowser_tabsbrowser_take_screenshotbrowser_typebrowser_wait_forEach tool targets a distinct browser action or resource: navigation, interaction, snapshotting, network inspection, dialog handling, etc. Even the paired tools like browser_network_requests/browser_network_request and browser_find/browser_snapshot are clearly separated by list/detail and search/full-snapshot purposes. No two tools overlap in functionality.
All tools share the 'browser_' prefix, which provides a strong visual grouping. However, the second part mixes verb forms (browser_navigate, browser_click) with noun forms (browser_console_messages, browser_tabs), and some tools use verb_noun while others use verb alone. This is mostly predictable but not perfectly uniform.
With 24 tools, the set is on the heavier side, but every tool addresses a common browser automation scenario—navigation, element interaction, input, screenshots, network, tabs, and dialogs. The count is justified for a comprehensive Playwright wrapper, and none of the tools feel redundant.
The tool surface covers the core browser lifecycle: navigation, interaction, input, snapshotting, console/network inspection, tab management, and dialog handling. Obvious gaps include dedicated scrolling, element attribute inspection, and download management, but these can be worked around via browser_evaluate. Overall, the set is complete enough for most automation workflows.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Provides cloud browser automation capabilities using Stagehand and Browserbase, enabling LLMs to i…
Hosted browser for AI agents: screenshots, post-JS DOM, console, WCAG. No install, no API key.
AI-powered web automation. Navigate websites using AI agents for one page or a thousand
AI-powered web automation. Navigate websites using AI agents for one page or a thousand
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/GORDIAN12/MCP_docs'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
