BrowserPilot MCP

by Sept-7-Qi

Overview Schema Related Servers Score Discussions

JavaScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.1.2
Disambiguation4/5
Most tools have clearly distinct purposes, but close_page and close_managed_tabs overlap in function, and new_page vs ensure_active_tab could cause selection ambiguity. Descriptions help mitigate confusion.
Naming Consistency4/5
The majority follow a clear verb_noun pattern (list_pages, navigate_page, type_text). However, a few single-word verbs (click, hover, drag) and health_check break the pattern, creating minor inconsistency.
Tool Count3/5
At 22 tools, the surface is on the heavy side and includes some redundancy (close_page vs close_managed_tabs). The browser automation domain is broad, so most tools are justified, but a few could be consolidated.
Completeness4/5
Core browser automation operations are covered: navigation, tab management, interaction, screenshots, network/console inspection, and dialog handling. Minor gaps like direct content extraction exist but can be addressed via evaluate_script.
Average 3.6/5 across 22 of 22 tools scored. Lowest: 2.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- Last stable release on June 9, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under GPL 3.0.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure. It only states the basic action without revealing side effects, such as whether it triggers mouseover events, waits for a response, or affects page state. This is a significant gap for a user-interaction tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no wordiness. It is direct and easy to read, though it could be slightly more informative without becoming verbose. Overall, it is appropriately concise for its simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is too minimal to provide adequate context. Given the lack of annotations and output schema, the description should compensate by explaining when to use the tool, potential side effects, or how it interacts with the page. None of this is present, making it incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides descriptions for all parameters (page and selector), giving 100% coverage. The tool description adds no additional meaning to these parameters, so it stays at the baseline for schema-covered tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action (hover) and the target (an element), which distinguishes it from sibling tools like click or type_text. However, it does not add additional scope such as 'in the current page' or 'using a CSS selector', so it falls short of a full 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 hover versus alternatives like click or drag. There are no stated prerequisites, exclusions, or context for when this tool is appropriate, leaving the agent without decision-making information.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosing behavior, but it only states the basic gesture. It does not mention whether the drag involves pressing and releasing, any dwell time, coordinates relative to viewport, or possible side effects such as scrolling or selecting.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely brief, consisting of a single phrase with no fluff, but it under-specifies key details. It is concise yet not sufficiently informative, balancing between efficiency and completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has three parameters, nested objects, and no output schema, the description is too thin to provide complete context. It omits information about coordinate systems, coordinate origin, and the effect of the drag, making it insufficient for an AI agent to use safely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already describes each parameter with 100% coverage, so the baseline is 3. The description adds no extra meaning beyond the schema, simply restating the start and end points.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action as 'drag' and specifies the target as moving from one point to another, distinguishing it from sibling actions like click and hover. However, it does not clarify whether this is a mouse drag, touch drag, or drag-and-drop, leaving some ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 click, hover, or key presses. There is no mention of prerequisites, use cases, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It merely restates the action and discloses nothing about side effects, return values, waits, or failure behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with no wasted words. However, it is arguably under-specified, which slightly reduces the score from a perfect 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has three optional parameters and no output schema, yet the description does not clarify whether at least one of 'selector' or 'coordinates' must be provided, nor what happens when neither is given. This ambiguity leaves the invocation unclear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, so the parameters are already documented. The description adds no additional meaning, but the schema itself includes descriptions for 'page', 'selector', and 'coordinates', providing baseline clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Click') performed on a resource ('an element on the page'). It is unambiguous but does not distinguish itself from sibling actions like 'hover' or 'drag'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 over alternatives, nor any exclusions such as requiring a selector versus coordinates. The description only states the action without context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses only the basic action of handling a dialog. It omits critical behavioral details such as what happens if no dialog is present, whether the tool waits for a dialog, how dismissal differs from acceptance, or any return values. With no annotations to provide safety or behavioral context, the description fails to convey these important traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that is front-loaded with the main purpose. No word is wasted, but the verb 'handle' could be more precise (e.g., 'accept or dismiss'). Overall, it is appropriately sized and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with three simple parameters and no output schema, the description is minimal but still incomplete. It lacks any context about dialog interaction flow, error conditions, or how the tool integrates with page navigation. An agent would have to infer behavior from the parameter names alone, which is inadequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 does not add any parameter semantics beyond what the schema already explains; the accept/promptText semantics are clearly documented in the schema. The description only adds a generic mention of dialog types, which is redundant.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it handles JavaScript dialogs (alert, confirm, prompt), which is a specific resource. Although the verb 'handle' is somewhat generic, the parenthetical list of dialog types makes the purpose unambiguous. It distinguishes from sibling tools by being the only dialog-handling tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. Usage is only implied by the dialog types, with no context about dialog blocking, timing, or fallback behavior. This is minimal guidance at best.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states the core action and fails to mention side effects like page state changes, loading behavior, or prerequisites (e.g., the page tab must exist).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no redundant words. It is efficiently written, though it is brief enough that some might consider it under-specified rather than appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has two parameters, no output schema, and no annotations, the description is too minimal to be complete. It does not clarify expected return values, whether it waits for page load, or how the optional page parameter affects behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both 'url' and 'page' already described in the schema. The description adds no additional meaning beyond the schema, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Navigate' and resource 'a URL', clearly indicating the action. However, it does not specify whether it navigates the current page or opens a new tab, leaving some ambiguity that could be clarified given sibling tools like new_page.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 such as new_page or ensure_active_tab. The description does not mention any context or exclusions, making it hard for an agent to decide between navigation-related tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the behavioral burden. It merely restates the tool name and offers no details about side effects, whether it requires an active page, how it handles focus, or what happens if 'page' is omitted. This is a tautological description that adds no behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no redundant words. It is front-loaded and directly communicates the core action, earning a high score for conciseness even though it lacks depth.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description is too thin. It does not explain key press behavior (e.g., whether it's a transient press or long press), how the optional 'page' parameter affects execution, or any return value. The schema describes parameters but not runtime context, leaving significant ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full coverage (100%) with descriptive parameter details: 'key' includes examples and 'page' is explained. The description adds no additional meaning beyond the schema, so a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('press') and the resource ('keyboard key'), making it easy to understand. It is distinct from sibling tools like 'click' and 'type_text', though it could be more specific about what kind of key (e.g., modifier keys, key combinations).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use press_key versus alternatives like 'click' or 'type_text'. The description does not mention suitable scenarios or exclusions, leaving the agent to infer that it is for simple key presses.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic action of typing text, but fails to mention important behavior such as whether it replaces existing content, fires events, or requires a focused element. This is insufficient for an agent to predict side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that conveys the core action without any filler. It is appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (3 parameters, no output schema), the description is still too sparse. It lacks any behavioral context, such as how the selector optional is handled or what happens if no selector is provided, and does not differentiate from sibling tools. This leaves the agent with uncertainty about correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, meaning every parameter has a meaningful description in the schema. The tool's description adds no extra parameter information, but the schema itself is sufficient, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Type text into an input field' clearly states the verb (type) and resource (input field), giving a specific action. However, it does not differentiate from sibling tools like fill_form or press_key, so it does not fully meet the top score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 such as fill_form or press_key. The description provides no context about prerequisites, selection of the target element, or when other tools would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Resize the browser window' without explaining side effects, whether it affects the current page or all pages, or if the resize is persistent. The optional 'page' parameter is not mentioned, leaving behavioral ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with zero waste. It is front-loaded with the key action and target, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple resize operation with a well-covered schema, the description is minimally viable. However, it lacks contextual details such as whether the resize applies to the viewport or the OS window, and what happens when the optional 'page' parameter is omitted. Given the tool's simplicity, this is a clear but not critical gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptive parameter names and units (pixels) already provided. The description adds no additional meaning beyond what the schema states, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Resize the browser window' clearly states the action (resize) and the target (browser window), with a specific verb and resource. It distinguishes itself from sibling tools, none of which perform resizing, though the tool name 'resize_page' vs 'browser window' creates minor ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, nor any prerequisites or exclusions. The description simply states the action without context such as 'use to adjust viewport before taking a screenshot.' Usage is only implied by the nature of the operation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It simply states 'Open a new browser tab' and does not disclose whether the new tab becomes the active tab, whether a page reference is returned, or any side effects such as focus changes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is concise and front-loaded with the core action. There is no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one optional parameter and no output schema, but the description lacks behavioral details like active-tab semantics. For a browser automation tool, this missing context is a notable gap, though the core purpose is adequately conveyed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides 100% coverage for the single optional 'url' parameter with a clear description. The tool description adds no 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.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Open a new browser tab' clearly states the tool's action and resource with a specific verb. It distinguishes itself from sibling tools like navigate_page (which navigates an existing tab) and close_page (which closes a tab).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 vs alternatives such as navigate_page or ensure_active_tab. The description does not mention whether the new tab becomes active or whether it should be used before other actions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description gives no behavioral details such as whether it simulates typing, sets values directly, clears existing content, triggers events, or handles errors. It simply restates the basic action without revealing important execution traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no redundant words. It efficiently conveys the core action, making it appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has two parameters, one being an array of nested objects, and no annotations or output schema, the description is insufficient. It does not explain selector syntax, behavior on invalid selectors, whether events are triggered, or any return value, leaving many gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already covers both parameters with descriptions (page and fields). The tool description adds no additional parameter semantics beyond the word 'fill', so it meets the baseline for high schema coverage without adding extra meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fills multiple form fields at once, using the verb 'fill' and scope 'multiple form fields at once'. This distinguishes it from sibling tools like type_text, which is for single fields, and click.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'at once' implies use when needing to fill several fields in a single operation, but the description does not explicitly state when to use this tool over alternatives like type_text, nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description must carry the full burden of behavioral disclosure. It mentions the action and sources but does not disclose whether messages are cleared, return order, pagination, or any side effects. This leaves the agent with an incomplete behavioral picture.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, precise sentence that front-loads the action and resource, followed by relevant source details. Every word contributes meaning, and there is no redundancy or wasted space.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core purpose and sources but does not explain the return format, default behavior, or filtering nuances. Since there is no output schema, the description should ideally describe what the returned messages look like, which is a notable gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Both parameters have full descriptions in the schema (100% coverage), so the schema provides the necessary semantic meaning. The description adds no additional parameter context, but this is acceptable given the schema's completeness.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and the resource ('captured console messages'), and specifies the exact data sources (CDP Runtime.consoleAPICalled, Log.entryAdded, content-script interception). This distinguishes it from sibling tools like list_network_requests or get_console_message.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving console messages but does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. Sibling tool names suggest context, but the description itself lacks explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only states the basic action. It does not mention side effects, return format, or how tabs/pages are identified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence of six words, perfectly front-loaded and free of unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple parameterless list operation, the description is mostly adequate, but it does not specify what information is returned for each tab/page (e.g., title, URL, ID), leaving a gap in expected output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has zero parameters, so the baseline is 4. The description adds the qualifier 'all', which clarifies the unconditional scope of the operation, but no further parameter semantics are needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and a clear resource ('all open browser tabs/pages'), making its function unambiguous and naturally distinct from sibling tools like 'list_network_requests' or 'take_screenshot'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives; there is no mention of prerequisites, exclusions, or complementary tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the capture sources but does not state whether the operation is read-only, what the return object looks like, or what happens when an ID is not found. The 'get' verb implies a safe read, but this is not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary action. The second sentence adds relevant context about the message sources without unnecessary verbosity. Every word contributes to understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple get-by-ID tool, the description is fairly complete. It explains what the tool does, how messages are captured, and has no output schema to worry about. However, without annotations or output schema, a bit more detail on the return value or error behavior would be beneficial, but it is not critical given the simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%—both 'id' and 'page' are described. The description text adds no extra meaning about the parameters beyond the capture source context, which is not directly param-specific. The baseline for high schema coverage is 3, and no additional value is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get'), the resource ('a captured console message'), and the method ('by ID'). It also specifies the sources of the messages (CDP Runtime.consoleAPICalled, Log.entryAdded, content-script interception), which helps distinguish it from sibling tools like list_console_messages or get_network_request.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied: you need a message ID, presumably from a previous list_console_messages call. However, there is no explicit statement about when to use this vs alternatives, no mention of prerequisites, and no exclusion like 'instead of listing all messages.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses important behaviors: runs with extension execution semantics, requires a JSON-serializable return value, and explains that returnByValue is accepted but ignored. This provides meaningful context beyond a simple operation statement.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with two sentences covering purpose, execution semantics, and return constraints. It is front-loaded with the primary action and contains no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate for a script execution tool: it explains the action, execution context, and return value expectations. While error handling isn't mentioned, the core behavior is covered, especially given the limited schema and no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the description does not add new parameter semantics. The note about returnByValue in the description duplicates the schema's text. No extra value is provided beyond the structured fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: 'Evaluate JavaScript on the page via chrome.scripting.executeScript.' It specifies the resource (page JavaScript) and the mechanism, making it distinct from sibling tools like click, type, or navigate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when needing to run custom JavaScript, but it does not explicitly state when to use this tool over alternatives or provide exclusions. With sibling tools like click and type_text, no direct comparison is offered.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the key limitation that response bodies are not included and lists the metadata fields returned. While it does not explicitly state read-only behavior, 'List' strongly implies it, and the description adds context about CDP Network events. It does not contradict structured data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with action and resource, no filler. The second sentence adds a meaningful limitation without wasting words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (4 optional filters, no output schema), the description provides essential purpose and return metadata. It doesn't detail ordering or pagination, but for a list operation with optional filters, it is adequately complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema covers 100% of parameters with descriptions, so baseline is 3. The description does not add meaning beyond the schema parameters themselves; it only mentions 'timing/status fields' and 'encoded data length' which are return fields, not parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and resource ('captured network request metadata from CDP Network events'). It clearly identifies what the tool does and distinguishes it from sibling tools like get_network_request, which retrieves a single request. The scope ('network request metadata') and exclusion of response bodies further clarify its role.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives like get_network_request, nor does it mention when not to use it. It implies context (used for listing metadata, not bodies) but provides no direct guidance or alternative references.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses the key limitation ('response bodies are not included') and clarifies the data source ('CDP Network request/response lifecycle metadata only'). It doesn't mention error behavior or require capture state, but the main limitation is transparently stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core action, and no unnecessary words. Every clause adds value, including the explicit limitation on response bodies.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is sufficient for a simple getter, but it leaves gaps: it doesn't specify what fields the metadata includes (e.g., status, headers, timings) or how to obtain the ID (e.g., via list_network_requests). Since there is no output schema, a bit more detail on the return shape would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers both parameters (id and page) with clear descriptions. The description adds little beyond 'by ID', which is already evident from the schema. Baseline 3 applies since schema_description_coverage is 100% and no extra nuance is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear and specific: 'Get captured network request metadata by ID.' Distinguishes from sibling list_network_requests by emphasizing retrieval by ID, and the scope is explicit (network request metadata).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides context: it retrieves previously captured metadata, and explicitly notes what it does not include (response bodies). This implies when to use it (when you need lifecycle metadata) and when not to (when you need response bodies), though it does not name alternative tools or explicitly state prerequisites like first listing requests to obtain an ID.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. It mentions the use of CDP Page.getLayoutMetrics and Page.captureScreenshot for full-page capture, and explains the default viewport behavior. It could also state the return format (e.g., base64) but the core behaviors are disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: two sentences, front-loaded with the primary purpose. It avoids redundancy and every clause adds value, explaining the default and full-page modes efficiently.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple screenshot tool, the description covers the main actions and behavioral nuances. It does not mention the return value format or whether the page must be active, but given the low complexity and helpful sibling context (e.g., ensure_active_tab), it is reasonably complete. A 4 reflects the minor gap around output specifics.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides complete descriptions for both parameters (page and fullPage), including the key distinction for fullPage. The description essentially repeats the fullPage behavior but adds no new meaning beyond what the schema already specifies, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Take a PNG screenshot of the current page.' It specifies the output format (PNG) and the resource (current page). It also distinguishes between default viewport capture and full-page capture, which differentiates it from any potential siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context by explaining the default behavior (visible viewport) and when to use fullPage=true. It does not explicitly mention alternatives or when not to use the tool, but the context is sufficient for straightforward usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the behavioral burden. It discloses that condition-based waiting is unsupported and rejects requests, but does not describe timeout behavior, return values, or side effects beyond waiting.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two focused sentences front-load the core action, immediately state the key restriction, and point to the alternative without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a wait tool with fully described parameters, the description covers the essential behavior and constraint. It lacks explicit timeout outcome details but is otherwise sufficient given schema richness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions already cover all parameters (100% coverage), including the condition constraint. The description reinforces the unsupported condition but adds little beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's action: waiting for a visible element matching a CSS selector. It also distinguishes itself from evaluate_script by stating JS conditions are not supported, which differentiates it from sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when not to use it (for JavaScript conditions) and provides the alternative (evaluate_script), giving clear guidance on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully discloses behavioral traits: it reuses, creates, or launches a browser; it explicitly states it will not close Chrome or terminate the browser process; and it lists platform-specific launch commands. This goes far beyond basic expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and front-loaded with the core purpose. While slightly long due to platform launch details, every sentence earns its place by conveying necessary behavioral guarantees and conditions without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a side-effect-oriented tool with two optional parameters, the description covers all relevant states (active tab, no tabs, no window) and side effects (browser launch, no termination). It lacks explicit return value details, but no output schema exists and the tool's success is largely implied by the conditional logic.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both 'url' and 'browser' parameters already well-documented. The description adds minimal extra meaning beyond the schema, so a baseline score of 3 is appropriate as the schema carries the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: ensure an active browser tab exists. It specifies the exact verb (ensure) and resource (active tab), and the conditional behavior (reuse existing tab, create new tab, launch browser) distinguishes it from siblings like new_page or navigate_page.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool by detailing the three scenarios (active tab present, no tabs but browser running, no window) and explicitly notes when the browser will be launched. It does not name alternatives explicitly, but the conditional logic implies when this is the appropriate fallback.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits, and it does so by stating 'refuses to close the last browser window.' This is a crucial safety/limitation behavior. However, it doesn't detail what happens if that occurs (e.g., error message) or mention other side effects, but the key behavioral constraint is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded, stating the core purpose in the first phrase ('Low-level tab close tool'), then providing a key behavioral note, and finally an alternative. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and no output schema, the description covers purpose, a critical behavioral limitation, and guidance on alternatives. It does not explicitly explain behavior when no page ID is provided (e.g., default current tab), but the overall context is sufficient for most cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage for the single parameter 'page' with description 'Optional page/tab ID to close'. The tool description does not add additional parameter semantics, so the baseline of 3 is appropriate since the schema already provides sufficient meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool is a 'low-level tab close tool' with a specific scope: closing tabs. It also distinguishes itself from the sibling tool close_managed_tabs by positioning itself as a low-level compatibility tool, which differentiates its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Prefer close_managed_tabs for BrowserPilot-managed lifecycle cleanup', providing clear guidance on when to use this tool versus an alternative. It also implies this tool is for direct, unmanaged closing, giving 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.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It richly discloses behaviors: only closes managed tabs, never the browser itself, the default vs allManaged behavior, and the crucial edge case where it avoids closing the last window by only removing from the managed set without calling chrome.tabs.remove. This goes far beyond a basic mutation description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: a single opening sentence states the core purpose, followed by a compact explanation of the two modes and the safety edge case. Every sentence adds value with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having no annotations and no output schema, the description is complete for this tool's complexity. It covers the two parameter behaviors, the safety guarantee, and the critical fallback behavior when closing all managed tabs would empty the last window. There are no significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the description largely restates what the schema already says (tabId must be managed, allManaged defaults to false, allManaged=true closes all). It does add the context of never closing the browser and the last-window edge case, but those are behavioral rather than parameter-semantic enhancements. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool closes tabs that BrowserPilot MCP itself opened/used, with a specific verb (close) and resource (managed tabs). It distinguishes from sibling close_page by limiting scope to managed tabs, and explicitly describes the default and allManaged behaviors.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context: only closes managed tabs, defaults to the specified tabId, and allManaged=true closes all managed tabs. It also states when not to use it (never closes the Chrome browser itself) and the edge case of the last window being emptied. However, it does not explicitly name an alternative tool like close_page for unmanaged tabs, so it stops short of full when/not-and-alternatives guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description details what the tool returns (diagnostic info and next steps), which informs the agent about the tool's non-destructive, read-only nature. It adds behavioral context beyond the name, though it could explicitly state it makes no changes to the environment.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with two sentences that each earn their place: the first details the returned content, the second provides usage guidance. No redundant or filler text is present.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter diagnostic tool with no output schema, the description provides complete context: what it checks, what it returns, and when to use it. It is fully sufficient for an agent to select and invoke this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the schema is empty, so there is no need for parameter explanation. The baseline score for zero-parameter tools is 4, and the description adequately covers the tool's purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns structured diagnostic information about specific components (MCP service, browser extension, native host, browser access status) and next steps. It uniquely identifies this as a health check tool, distinguishing it from sibling tools that perform actions like navigation or clicking.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use this tool to check whether the browser automation bridge is ready, providing clear usage context. It does not mention when not to use it or alternatives, but given the tool's unique diagnostic role, this is sufficient guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![BrowserPilot-MCP MCP server](https://glama.ai/mcp/servers/Sept-7-Qi/BrowserPilot-MCP/badges/card.svg)](https://glama.ai/mcp/servers/Sept-7-Qi/BrowserPilot-MCP)

Score Badge

Copy to your README.md:

[![BrowserPilot-MCP MCP server](https://glama.ai/mcp/servers/Sept-7-Qi/BrowserPilot-MCP/badges/score.svg)](https://glama.ai/mcp/servers/Sept-7-Qi/BrowserPilot-MCP)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Sept-7-Qi/BrowserPilot-MCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server