Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations, so the description carries the full burden. It states the tool checks availability and gets the version, but it does not disclose whether it starts an ADB server, requires a connected device, or has any side effects. The description is too minimal to provide meaningful behavioral transparency beyond the obvious.

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, clear sentence with no redundancy. It is front-loaded with the action ('Check') and the resource ('ADB') and efficiently conveys the scope, earning full marks for 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 tool is simple, but the description is minimal. With no output schema, the description should clarify what 'get version' returns (e.g., a version string) and what 'available' means. It lacks return-value details or edge-case behavior, leaving some gaps for the 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 tool has zero parameters, and the input schema is empty. The description adds no parameter details, but none are needed. Per the rubric, a baseline of 4 applies for tools with no parameters, and this tool fits that case.

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: checking ADB availability and retrieving its version. It uses a specific verb ('check') and resource ('ADB'), and it is distinct from sibling tools like adb_get_connected_devices or adb_list_devices, which focus on device listing rather than environment verification.

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 other ADB-related tools. The description does not mention alternatives, prerequisites, or exclusions. Users must infer that it is a preliminary check, but the description leaves this implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 adds the key detail 'check first, then set up if needed,' revealing idempotent behavior. However, it does not disclose what happens if forwarding already exists with different parameters, error conditions, or the return 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 that front-loads the action ('Ensure') and adds a concise behavioral clarification. Every word contributes meaning, with 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?

For a simple tool with two optional parameters and no output schema, the description adequately covers the main behavioral contract (idempotent setup). It does not discuss edge cases like conflicting existing forwardings, but given the tool's simplicity and the presence of sibling tools for other operations, the description is reasonably 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?

The input schema already provides descriptions for both parameters (localPort and remoteAbstract), achieving 100% coverage. The tool description adds nothing beyond what the schema states, so it sticks to the baseline for adequate schema documentation.

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: ensuring port forwarding is set up. The parenthetical 'check first, then set up if needed' specifies the tool's behavior and distinguishes it from sibling tools like adb_forward_port (which unconditionally forwards) and adb_list_forwardings (which only lists).

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 when to use the tool (when you need to guarantee forwarding) but does not explicitly mention alternatives or when not to use it. There is no direct comparison to adb_forward_port or adb_list_forwardings, leaving the choice to the agent's inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states 'Set up' and the default mapping, but does not mention side effects (e.g., whether existing forwards are overwritten), prerequisites (e.g., a connected device), or whether the operation is idempotent. This is a significant transparency gap for a mutating tool.

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 filler. It efficiently conveys the tool's purpose and default configuration, making it ideal for quick scanning.

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 (2 params, full schema coverage, no output schema), the description covers the core purpose and defaults. However, the absence of annotations means the description should also disclose behavioral traits like idempotency or prerequisites, which it does not. It is minimally viable but leaves 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 already covers both parameters with descriptions at 100% coverage. The description adds value by showing the relationship between localPort and remoteAbstract through the default mapping, which clarifies that localPort is the TCP port and remoteAbstract is the abstract socket in the forwarding rule.

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 ('Set up') and resource ('ADB port forwarding'), and it provides the default mapping, which clearly distinguishes this from sibling tools like adb_list_forwardings and adb_remove_forwarding. The default tcp:9222 -> localabstract:chrome_devtools_remote makes the intent 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 clearly indicates the common use case via the default mapping, implying when to use it (e.g., for Chrome DevTools remote debugging). However, it does not explicitly mention exclusions or alternatives like adb_ensure_forwarding, so it lacks explicit when-not guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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. 'Get' suggests a read-only operation, but it does not clarify what 'connected' means (e.g., excludes offline/unauthorized states), whether an adb server must be running, or what the return format is. This is a minimal transparency gap for a simple getter.

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 directly states the tool's purpose with no filler or redundant information. It is appropriately sized for a zero-parameter, simple getter.

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 adequate for a zero-parameter tool with no output schema, but it lacks context about the sibling adb_list_devices tool and does not mention the expected return value (e.g., list of device IDs). Since this is a simple read operation, the gap is moderate, not severe.

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 tool has zero parameters, so the schema fully covers parameter semantics (100% coverage). No additional parameter explanation is needed in the description, and the baseline for no parameters is 4.

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 'Get only connected ADB devices' uses a specific verb ('get') and identifies the resource ('connected ADB devices') with a clear scoping modifier ('only connected'). This distinguishes it from a generic device listing tool like adb_list_devices, though it does not explicitly name the alternative.

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 the sibling adb_list_devices. It does not state whether to use this for only connected devices and the other for all devices, leaving the decision to the agent without explicit context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the burden. It adds context that all devices, including disconnected, are listed, but it does not disclose potential side effects or output format. List implies read-only, so a neutral 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, concise sentence that states the purpose and scope with no unnecessary words. It is well-structured 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?

Given the tool's simplicity (no parameters, no output schema), the description covers the main purpose and scope. It could add more explicit guidance on usage versus the sibling, but it is adequate for a basic listing operation.

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 tool has zero parameters and the input schema is empty. The description does not need to explain parameters, and with no params, the baseline is 4.

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 lists ADB devices, with a specific verb and resource. It distinguishes from sibling adb_get_connected_devices by explicitly noting the inclusion of disconnected devices.

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 when to use this tool (when all devices including disconnected are needed) based on the parenthetical scope. It does not explicitly name alternatives or exclusions, but the sibling context makes the usage clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It states the action as "List", which implies a read-only operation, and the target is specific. However, it does not disclose potential requirements (e.g., adb server, connected device) or return format, leaving some behavioral aspects unaddressed.

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 directly states the tool's purpose. There is no wasted wording or filler, earning the maximum score for 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?

For a simple tool with no parameters and a clear action, the description is mostly complete. It adequately conveys that the tool lists active forwardings. It omits details like prerequisites or output format, but given the simplicity and sibling context, this 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 tool has zero parameters, so there is nothing to describe. According to the rubric, a zero-parameter tool gets a baseline score of 4. The description does not need to add 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 uses a specific verb ("List") and a specific resource ("active ADB port forwardings"), making the tool's purpose unambiguous. It clearly distinguishes from sibling tools like adb_forward_port (creates), adb_remove_forwarding (removes), and adb_list_devices (lists devices, not forwardings).

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 clearly implies when to use this tool: to view current port forwardings. However, it does not explicitly mention alternatives or exclusions, though the sibling set makes the context obvious. For a simple list operation, this is sufficient but not exhaustive.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full responsibility for behavioral disclosure. It states the action (remove) but does not clarify side effects like whether existing connections are disrupted, what happens if the port is not currently forwarded, or if the operation is idempotent. This is a significant gap for a destructive operation.

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 filler or redundant information. It is appropriately sized for a tool with one parameter and a simple action.

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 utility, the description is minimally viable but incomplete. It lacks usage guidelines and behavioral transparency that would help an AI agent decide when to use it and what to expect. The presence of sibling tools like adb_ensure_forwarding makes the lack of contextual guidance more noticeable.

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 100% coverage for the single parameter 'localPort', including a default value, so the description does not need to add parameter details. The baseline of 3 applies because the schema already documents the parameter 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 'Remove ADB port forwarding' uses a specific verb and resource, clearly distinguishing it from siblings like adb_forward_port (which adds forwarding) and adb_list_forwardings (which lists them). It leaves no ambiguity about 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?

No guidance is provided on when to use this tool versus alternatives such as adb_ensure_forwarding or adb_forward_port. There is no mention of prerequisites, typical scenarios, or cases where removal might be unsafe.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only states the action but does not mention side effects, persistence across sessions, whether the script replaces existing init scripts, or how to remove it, leaving the agent uncertain about the consequences.

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 redundant information, ideal for quick scanning.

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 (one param, no output schema), the description covers the core action, but it omits lifecycle and side-effect information that would be valuable for a tool that mutates browser 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 coverage is 100%, so the schema already describes the script parameter. The description adds no extra semantic detail about the parameter beyond its existence.

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 provides a specific verb ('Add') and resource ('initialization script') with a clear scope ('run on every page load'), distinguishing it from one-time execution tools like browser_evaluate and from browser_initialize which likely initializes the connection.

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 context ('every page load') but does not explicitly distinguish when to use this tool versus alternatives like browser_evaluate for one-time scripts, and gives no exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 does not state whether the action triggers change/input events, what happens if the element is disabled or already checked, or whether any scrolling/visibility handling occurs. This leaves significant room for unexpected 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 a single, concise sentence that communicates the core purpose without any waste. It is appropriately sized for the tool's simplicity.

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 one-parameter tool with no output schema, this description is functional but minimal. It fails to provide context such as typical usage scenarios, interaction with radio button groups, or behavioral expectations, which an agent might need to choose correctly among sibling tools.

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 for the single parameter (selector) with a clear description: 'CSS selector of the checkbox/radio element'. The tool description adds no additional semantics, but the schema is sufficient, 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.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (check) and the target resource (checkbox or radio button). It distinguishes itself from sibling tools like browser_uncheck and browser_click by specifying the exact element types it applies to.

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. It does not mention that it should be used specifically for checkboxes/radios while browser_click might be for other elements, nor does it discuss prerequisites or limitations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It does not disclose error behavior (e.g., selector not found), waiting, or side effects such as 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?

One sentence, clear and direct, with zero unnecessary 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 simple one-parameter operation, the description is functional but omits behavior on failure and return value. Given no annotations and no output schema, it is adequate but not fully 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?

The schema covers the only parameter with a clear description. The description reiterates 'by CSS selector' without adding extra semantics, meeting the baseline for high 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?

States the specific action 'click' on an element using a CSS selector. Clearly distinguishes from sibling tools like browser_hover or browser_type.

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?

Provides no information on when to use this tool, prerequisites, or alternatives. For example, it doesn't mention that the element should be visible or that clicking may cause navigation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Without annotations, the description must disclose behavioral traits. 'Close the browser connection' is vague and fails to mention side effects such as losing open pages, terminating the browser process, or whether the action is reversible. This is insufficient for an operation that implies disruption.

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 that is front-loaded and contains no wasted words. It is appropriately concise for a tool with no parameters.

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 description still lacks essential context about the behavior of closing the connection. It doesn't clarify whether it affects other browser tools, whether the connection can be reopened, or what the exact consequences are. The empty schema and lack of annotations leave significant 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 tool has zero parameters, so the schema is already complete. The description adds no parameter-specific meaning, but none is needed, so the baseline score of 4 applies.

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 clear verb ('Close') and resource ('browser connection'), distinguishing it from sibling tools like browser_connect and browser_initialize. However, it lacks specificity about what 'connection' entails, such as whether it closes all pages or just disconnects.

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 about when to use this tool or how it relates to browser_connect, browser_initialize, or browser_reload. The description gives no context, alternatives, or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the default index, omitting side effects (e.g., changing the active page), error handling for invalid indices, or whether the connection persists.

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 filler. It communicates the action, target, and default parameter efficiently.

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 one optional parameter and no output schema, the description provides basic information. However, it lacks operational context, such as how this relates to listing or getting the current page, and what happens on invalid input. It is adequate but not 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?

The schema already documents pageIndex with a description and default value, achieving 100% coverage. The description adds no extra meaning beyond echoing 'by index' and 'default 0'.

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 identifies a connect action targeting a specific page by index, with a default of 0. It partially distinguishes itself from siblings like browser_list_pages and browser_get_current_page by implying selection/activation, though the verb 'connect' remains somewhat ambiguous.

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 such as browser_list_pages, browser_get_current_page, or browser_navigate. No prerequisites, exclusions, or use-case context are provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 states it gets console messages, which implies a read-only operation, but it does not clarify whether messages are returned all at once, whether they are cleared after retrieval, or how the messages are structured. For a simple getter, this minimal transparency is acceptable but not rich.

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 filler. It is front-loaded and every word contributes to the meaning, making it optimally concise.

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, this one-sentence description is largely sufficient to convey its core purpose. However, it could be slightly improved by noting the expected output format or typical use case, but this is not a significant gap given the tool's simplicity.

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 tool has zero parameters, so the input schema is empty. The description adds no parameter-specific details, but the baseline for zero-parameter tools is 4, and there is no gap to compensate for.

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 ('Get') and resource ('console messages from the page'), clearly distinguishing it from sibling tools like browser_get_network_logs (network logs) and browser_get_content (page content). It is unambiguous and action-oriented.

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 scenarios where console messages are needed or contrast with network logs or other browser inspection tools. The agent must infer usage from the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 simply states the action without detailing side effects, event dispatch, waiting behavior, or whether the element must be visible/enabled. This leaves significant ambiguity for a mutation-like interaction.

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 short and free of fluff, but it is under-specified. It conveys the core action but omits useful context that could be included in a single additional sentence (e.g., usage nuance, return behavior). It is concise but not optimally informative.

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 (one parameter, no output schema), the description is somewhat minimal but still lacks essential context for an agent: when to prefer it over siblings, what to expect after double-clicking, and any side effects. More detail would improve completeness.

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 100% coverage for the single 'selector' parameter with a clear description ('CSS selector of the element'). The description adds no extra semantic meaning beyond what the schema already provides, 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 action ('Double click') and the resource ('an element'), making the tool's purpose unambiguous. It differentiates from siblings like browser_click and browser_right_click through the specific verb, though it does not elaborate on scope or use case.

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_click or browser_hover. There is no mention of typical double-click scenarios (e.g., selecting text, opening files) or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 restates the action and does not mention how the drag-and-drop is simulated, whether events are dispatched, or what happens on failure.

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, but it is under-specified and does not provide useful structural information beyond the tool name. It is not expansive enough to be considered well-structured for an effective tool description.

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 two-parameter browser action with no output schema and no annotations, the description gives only the basic action. It lacks behavioral details and usage context, leaving the agent to infer when and how to use 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?

The input schema already documents both parameters with clear descriptions (CSS selectors for source and target). The description adds no additional meaning, so the baseline of 3 is appropriate given high 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 'Drag and drop an element' states the action clearly enough, but it is vague about the relationship between source and target selectors. It distinguishes from siblings only by the action name, not by describing the specific drag-and-drop workflow.

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 given about when to use this tool versus alternatives like browser_click, browser_hover, or browser_double_click. The description provides no context, prerequisites, or exclusion criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden for behavioral disclosure. It only says 'evaluate' without explaining side effects, return value semantics, promise handling, or error behavior. A powerful tool like this needs more transparency about what executing arbitrary JS entails.

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 communicates the tool's purpose. No wasted words, making it highly concise and scannable.

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 simple parameter schema, the absence of annotations and output schema means the description must explain return values and behavioral nuances. It fails to mention serialization, promise resolution, or execution context, leaving significant gaps for an evaluate tool.

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 fully documents the single parameter 'expression' as a JavaScript expression. The description adds no additional meaning beyond the schema, 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 evaluates a JavaScript expression within the page context. It uses a specific verb ('evaluate') and resource ('JavaScript expression in the page context'), distinguishing it from sibling tools that read specific values or perform UI actions.

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 no guidance on when to use this tool versus alternatives like browser_get_text or browser_query_selector. It does not mention scenarios where evaluate is preferred, nor does it exclude cases where simpler getters would suffice.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 states the core action but does not mention potential side effects, required file accessibility, or behavior when the selector does not match a file input. It adds little beyond the schema's parameter descriptions.

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, well-structured sentence that immediately states the action. It contains no fluff or redundant information, making it highly concise.

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 and full schema coverage, the description is minimally adequate. However, it does not mention return behavior, error conditions, or file constraints, which could be relevant in a browser automation context. Without an output schema or annotations, a slightly more detailed description would improve completeness.

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 complete descriptions for both parameters (selector and filePath), covering 100% of parameters. The description adds no additional parameter-level details, 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.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool uploads a file to a file input element, using a specific verb and resource. It distinguishes from sibling tools like browser_type or browser_fill, which handle text input, and browser_click, which clicks elements. The purpose is 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?

No guidance is provided on when to use this tool versus alternatives. The description is a single sentence with no context about prerequisites, when not to use, or alternative tools. The agent is left to infer usage from the name and schema alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description does not disclose behavioral details such as whether it clears existing values, triggers input/change events, works on contenteditable elements, or handles special characters. 'More robust' is vague and leaves significant 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with zero filler words. Every word earns its place, and the comparative clause adds value without bloating the 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?

For a simple two-parameter tool, the description is minimally sufficient, but it lacks key context such as behavior with existing values, event triggering, or differences from browser_type that are not covered elsewhere. The absence of annotations and output schema increases the burden on the description, which is not fully met.

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 parameters (value and selector) have descriptions. The tool description does not add any additional semantic meaning beyond what the schema already provides, so the baseline of 3 applies.

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 is concise and specific: 'Fill form field with value' clearly identifies the action (fill) and resource (form field). It also distinguishes itself from sibling tool 'browser_type' by adding 'more robust than type', which differentiates its purpose without ambiguity.

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 phrase 'more robust than type' provides a comparative guideline, implying use this tool when a more reliable fill is needed over browser_type. However, it does not explicitly state when NOT to use it or mention other alternatives, so it falls short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 action without revealing side effects (e.g., whether it replaces existing values, triggers input events, or waits for fields to be visible). This is a significant gap for a mutation tool.

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 wasted words. It is perfectly concise for the tool's simple nature.

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 one parameter and no output schema, the description is minimally adequate. It clearly states what the tool does, but lacks caveats such as whether the form is submitted or whether existing field values are cleared. It is not entirely deficient, but could be more 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?

The input schema already provides full coverage (100%) with the description 'Object mapping selectors to values.' The tool description adds no extra parameter semantics beyond the schema, 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.

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses a specific verb ('fill'), names the resource ('form fields'), and clarifies the scope ('multiple at once'). This distinguishes it clearly from sibling tools like browser_fill, which is for single-field filling.

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?

Usage is implied: the tool is for filling multiple fields simultaneously. However, no explicit alternatives or when-not-to-use guidance is provided, even though browser_fill exists for single fields. No exclusions are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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. It only states the action without explaining the nature of the snapshot (e.g., whether it includes hidden elements, whether it waits for the tree to be ready, potential side effects or failure modes).

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, front-loaded with the core action, and contains no fluff. It is appropriately concise for a tool with no parameters.

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 provides the essential intent, but lacks details about the return format or behavioral characteristics. It is minimally adequate but leaves a gap for the agent to fully understand what a snapshot entails.

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 tool has zero parameters, so the schema already fully covers parameter semantics. The description adds no parameter information, but the baseline for 0 params is 4, and there is nothing more to explain.

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 ('Get accessibility tree snapshot') with a clear resource (accessibility tree), which is a distinct browser inspection capability. However, it doesn't differentiate from sibling tools like browser_snapshot or browser_get_content, and the phrase 'Playwright MCP specific' adds little clarity.

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 given on when to use this tool versus alternatives (e.g., browser_snapshot, browser_get_content). The description does not mention any exclusions or context for selecting this tool over others.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry full behavioral transparency. It only states the core action and omits any edge-case behavior (e.g., what happens if the element is not found, if the attribute is missing, or the return format). This is minimal disclosure.

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 redundant wording and the primary verb is front-loaded. It is appropriately concise for a simple getter operation.

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?

Although the tool is simple, there is no output schema and the description is too sparse to fully describe behavior. It does not mention return values, failure modes, or usage context, leaving the agent without critical information for a production environment.

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?

Both parameters have full descriptions in the schema (100% coverage), so the description adds no extra meaning. The baseline of 3 applies: the schema already documents selector and attribute, while the description does not elaborate further.

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 (get) and the resource (attribute value of an element), distinguishing it from sibling tools like browser_get_text or browser_get_inner_html. It is specific and 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 offers no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It does not indicate scenarios where another browser_get_* tool 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden for behavioral disclosure. It clearly implies a read-only operation and indicates the output (full HTML), but it does not specify whether the content is raw source or rendered DOM, whether it requires a loaded page, or any performance implications. This is acceptable for a simple getter but leaves some ambiguity about the exact return format.

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 immediately communicates the tool's action and object. There is no unnecessary elaboration, making it efficient 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?

For a tool with zero parameters and no output schema, the description adequately covers the core purpose. However, it does not explicitly state what the returned HTML looks like (e.g., string of the entire document) or whether any page state is required. For such a simple tool, this is mostly sufficient, but some context on the return value would improve completeness.

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 tool has zero parameters, so there are no parameter semantics to clarify. The description adds no parameter information, but the empty input schema presents no gaps. Per the rubric, a 0-parameter tool earns a baseline score of 4.

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 ('get') and a clear resource ('the full HTML content of the page'), distinguishing it from sibling tools like `browser_get_inner_html` or `browser_get_text` by emphasizing 'full' and 'page'. It unambiguously states the tool's function as retrieving the entire page HTML.

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_get_inner_html`, `browser_get_outer_html`, or `browser_snapshot`. It does not mention any exclusions or best-case contexts, leaving the agent to infer usage from the name and sibling list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 says 'Get information', which implies a read operation, but does not describe the nature of the information, whether it includes a snapshot, or any side effects. This is minimal disclosure beyond the tool name.

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 redundant words. It is front-loaded with the action, though it sacrifices detail that could be added 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?

Given the absence of an output schema and annotations, the description is the only source of information, but it is insufficient. It fails to clarify what 'information' is returned or when this tool is useful, making it incomplete for a tool with such generic siblings.

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 tool has zero parameters, so the description does not need to explain parameter behavior. The input schema is empty and coverage is 100%, so the baseline of 4 applies; the description adds nothing about parameters because none exist.

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 the verb 'Get' and the resource 'currently connected page', but 'information' is vague and does not specify what is returned. It does not distinguish itself from sibling tools like browser_get_url, browser_get_title, or browser_get_content, which are more specific.

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 about when to use this tool versus alternatives. There is no mention of exclusions, prerequisites, or contrast with sibling tools, leaving the agent to guess the intended use case.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the full burden of behavioral disclosure, but it only states the action. It does not mention return type, behavior when the element is not found, or whether it waits for the element, which are important operational details.

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 words. It is perfectly concise and front-loaded, communicating the core purpose immediately.

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 one-parameter getter, the description is minimally acceptable, but since there is no output schema, it would benefit from specifying that it returns the inner HTML as a string and what happens if the selector matches no element. The lack of these details leaves some ambiguity.

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 describes the 'selector' parameter as 'CSS selector of the element', providing 100% coverage. The description adds no additional meaning beyond the action itself, 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 specifies the exact action ('Get') and the resource ('inner HTML of an element'), making it clear and distinct from sibling tools like browser_get_outer_html. The term 'inner HTML' inherently differentiates from outer HTML even without an explicit comparison.

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 no guidance on when to use this tool versus alternatives such as browser_get_text or browser_get_outer_html. It lacks any context about use cases, conditions, or exclusions, leaving the selection entirely to the name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 that the tool 'gets' logs, implying a read operation, but provides no details about the log format, scope, filtering, or any side effects. This is insufficient for an agent to understand what to expect.

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 wasted words. It is appropriately short for a no-parameter tool, though it could have been slightly 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?

Given the tool's simplicity (no parameters) and lack of an output schema, the description is nearly minimal but leaves uncertainty about the exact return format and how it differs from similar sibling tools. It is adequate but not fully 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?

The tool has zero parameters, and the schema is empty, so there is nothing for the description to add about parameter semantics. The baseline of 4 applies, and the description does not need to compensate.

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 gets network activity logs with a specific verb and resource. However, it does not distinguish itself from the sibling tool 'browser_network_requests', which likely performs a similar 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?

No guidance is provided on when to use this tool versus alternatives. The description gives no context about when to choose browser_get_network_logs over browser_network_requests or any other sibling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description is the sole source of behavioral disclosure. It implies a read-only operation (getting HTML) but does not explicitly state that it will not modify the page, nor does it mention any side effects, permissions, or error conditions. For a simple getter, this is minimally adequate but lacks rich context.

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 conveys the core purpose without extra words. It is appropriately brief for a simple getter, though it could arguably be slightly more descriptive without becoming verbose.

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 straightforward with one parameter, and the schema covers that parameter. However, there is no output schema and no mention of what the tool returns (e.g., the HTML string), nor any guidance relative to sibling tools. The description is minimally complete for a simple getter but lacks explicit detail about return 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?

The schema fully describes the only parameter, 'selector', as a CSS selector of the element. The description does not add any extra meaning beyond what the schema provides, 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.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get') and the resource ('outer HTML of an element'), making the tool's purpose immediately understandable. It does not explicitly distinguish from sibling tools like browser_get_inner_html, but the term 'outer HTML' is specific enough to convey the distinction.

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 given on when to use this tool versus alternatives such as browser_get_inner_html or browser_get_text. The description provides no context about appropriate scenarios or exclusions, 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description does not disclose important behavioral details such as whether it returns the first matching element, how it handles missing elements, or whether it waits for the element to appear. This leaves significant ambiguity for an AI agent invoking the tool.

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 filler. It is short and to the point, earning a high score for efficiency.

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 simple nature of the tool, the description lacks critical context like whether it retrieves text from the first matching element, whether hidden text is included, and what happens if no match is found. Given the large set of similar browser tools, this ambiguity could lead to incorrect tool 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 description covers 100% of the parameter, and the tool description adds no additional meaning beyond the selector field. The baseline of 3 applies because the schema adequately documents the parameter.

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 retrieves text content from an element, using a specific verb and resource. It implicitly distinguishes from sibling tools like browser_get_inner_html and browser_get_outer_html, but does not explicitly mention when it should be preferred over them.

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 such as browser_get_content, browser_get_inner_html, or browser_get_attribute. The description implies general use for extracting text but lacks any specifics about prerequisites, exclusions, or alternative conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 action without detailing return format, timing (e.g., whether it waits for page load), edge cases (empty title, error behavior), or any side effects. This is minimal transparency for a tool.

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, direct sentence with no filler. Every word earns its place, and it is appropriately sized for such a simple tool.

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 (no parameters, no output schema, trivial read operation), the description is almost complete. It states the core function. However, it could optionally note the return value (e.g., string or null) since no output schema exists, but for a title getter this is largely implied.

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 tool has zero parameters, so the description does not need to explain parameter semantics. The schema already covers everything. The baseline for zero parameters is 4, and the description adds no confusion.

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 'Get the page title' uses a specific verb (get) and resource (page title), clearly distinguishing it from sibling tools like browser_get_url or browser_get_content. The purpose is unambiguous and direct.

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: call this tool when you need the current page's title. However, it provides no explicit guidance on when to use this tool versus alternatives or any exclusion criteria. The implied usage is clear but not elaborated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 implies a read-only operation by using 'get', but it does not mention return format, potential errors (e.g., when no page is loaded), or whether it waits for the page to be ready. This is a significant gap for a tool with zero annotation support.

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 states the exact action. Every word earns its place, and there is no extraneous information 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?

For a simple getter with no parameters and no output schema, the description is mostly sufficient—it clearly indicates the return is the URL. However, it omits edge-case behavior (e.g., if the current page is unavailable), which could be useful for a fully complete description.

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 tool has zero parameters, so the schema trivially covers 100% of parameter semantics. The description adds no parameter information, but none is needed. Baseline for zero parameters is 4.

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 'get' and a clear resource 'current page URL', making the tool's action unambiguous. However, it does not differentiate from sibling tools like browser_get_current_page or browser_get_title, which could overlap in 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 versus alternatives. There is no context about prerequisites, typical use cases, or exclusions, leaving the agent to infer usage solely from the tool name and description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description is the sole source of behavioral information. It states the action but does not disclose potential side effects, such as behavior when there is no history to go back to, or whether it waits for page load. However, for a simple navigation action, this minimal transparency is adequate.

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 wasteful words. It is front-loaded and immediately clear, making it highly 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?

Given the tool's simplicity (zero parameters, no output schema, no annotations), the description fully covers what the tool does. No additional context is necessary for an agent to invoke this 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?

The tool has zero parameters, and the schema coverage is 100% (empty properties). Per the guidelines, a baseline of 4 applies for 0-parameter tools, as there is no parameter information to convey.

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 action: 'Navigate back in browser history'. It uses a specific verb ('navigate') and resource ('browser history'), and is distinct from sibling tools like browser_go_forward and browser_navigate.

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 context by stating what it does, but does not provide explicit guidance on when to use this tool versus alternatives (e.g., when not to use it, or that browser_go_forward is the opposite). Usage is implied rather than explicitly contrasted with sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full responsibility for behavioral disclosure, but it only restates the core action without mentioning edge cases (e.g., behavior when no forward history exists), whether navigation waits for page load, or any side effects. Minimal behavioral context 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, front-loaded sentence with no filler or redundant information. It efficiently communicates the tool's purpose without wasting 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 simple zero-parameter action, the description is adequate but thin. It doesn't state return values or edge-case behavior, but the tool's simplicity partially compensates. An agent might still need to know what happens if forward history is unavailable or whether a navigation wait is required.

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 tool has no parameters and the schema is empty, so the description correctly avoids inventing parameters. Since there are none to document, a baseline of 4 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 action ('navigate forward') and the resource ('browser history'), distinguishing it from sibling tools like browser_go_back and browser_navigate. It is specific and uses a verb+resource structure.

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 when to use the tool (to move forward in history) but does not explicitly discuss alternatives or exclusions, such as the need for prior backward navigation or that browser_navigate is for loading specific URLs. Guidance is implied rather than stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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. It only repeats the generic action 'Handle' without revealing important behavioral traits such as whether it blocks until a dialog appears, what happens if no dialog exists, or that accepting vs dismissing has side effects. The schema provides accept/promptText details, but the description adds no extra context beyond the name.

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, front-loaded with the verb and resource, and contains no superfluous text. It is appropriately concise for a simple tool.

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 no output schema and two well-documented parameters, the description is adequate but incomplete. It lacks context on when dialogs occur, whether the tool waits or times out, and any prerequisites. This results in clear gaps given the lack of annotations.

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 the parameter descriptions are clear: accept is a boolean for accept/dismiss, promptText is for prompt dialogs. The description itself does not add meaning beyond the schema, which already explains the parameters. Baseline 3 applies because 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 uses a specific verb ('Handle') with a clear resource ('JavaScript dialog') and explicitly lists the dialog types (alert, confirm, prompt). It distinguishes itself from sibling browser tools, none of which handle dialogs.

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 for JavaScript dialogs but does not explicitly state when to use this tool versus alternatives or provide conditions (e.g., when a dialog appears, or that it should not be used for other UI elements). There is no exclusionary guidance, but the tool's purpose inherently differentiates it from siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, but it only states 'Hover over an element.' It does not disclose whether this simulates a real mouse move, whether it dispatches events like mouseover/mouseenter, or whether it waits for the element to be visible. The behavior is under-specified.

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 extremely concise, consisting of a single sentence with no filler. However, it is so brief that it borders on under-specification, which slightly reduces the score from 5.

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 large number of sibling tools and the lack of output schema, the description leaves significant gaps. It does not explain what the tool returns (if anything), how it interacts with the page state, or how it differs from other mouse-related actions. The minimal description is insufficient for a tool in such a complex context.

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 parameter 'selector' is fully documented in the schema (CSS selector), so the description adds no additional semantic value. This matches the baseline for 100% schema coverage, as the schema already clarifies the parameter format.

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 an element' clearly identifies the action (hovering) and the resource (an element), distinguishing it from siblings like click or type. It is specific but could be slightly more explicit about the target being a DOM element in the browser context.

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 such as browser_click or browser_double_click. There is no mention of hover being used to trigger tooltips or dropdown menus, nor any exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must fully disclose behavioral traits, but it only restates the tool's name and purpose. It does not explain what 'initialize' entails, whether the operation is idempotent, or if it has side effects like opening a new browser window, making the behavior opaque for an AI agent.

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 fluff, making it easy to parse. It is concise, but the dual-action structure could be clearer; still, it earns points for brevity and front-loading the core action.

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 zero parameters and no output schema, the description provides the minimum viable information: it says what it does and what it returns. However, it leaves unclear how this differs from browser_connect or list_pages, and it does not mention any prerequisites or side effects, making it incomplete in the context of the sibling toolset.

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 tool has no parameters, so per the rubric baseline is 4 even if the description offers no additional parameter details. The phrase 'get available pages' subtly hints at the return value, which somewhat compensates for the absence of an output schema, though it is not explicit.

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 initializes a browser connection and retrieves available pages, using specific verbs and a resource. It distinguishes itself somewhat from sibling tools like browser_connect and browser_list_pages by combining these actions, though the dual purpose is slightly ambiguous about whether 'get available pages' is a separate action or part of initialization.

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_connect or browser_list_pages. There is no mention of it being a prerequisite or a preferred way to start a browser session, leaving the agent to infer usage from the name and context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 does not state whether the operation is read-only, whether a browser must be initialized or connected, or what the return value contains. The behavior beyond 'list all' is entirely unspecified.

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 extremely concise, using four words to communicate the tool's action and target. There is no filler or redundant content; 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 simple zero-parameter interface, the description lacks essential context about the output format and what 'available pages' means. Since there is no output schema and no annotations, the agent has no way to know what to expect from invoking this tool.

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 zero properties, so there are no parameter details to disclose. Per the zero-parameter baseline, the description does not need to add 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 uses a specific verb ('List') and resource ('all available pages'), making the core purpose clear. It is distinct from sibling tools like browser_get_current_page or browser_connect, but the term 'available pages' is somewhat vague and could be more explicit about what constitutes a page.

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_get_current_page or browser_connect. It does not mention any prerequisites, exclusions, or preferred scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 states the action without revealing side effects, whether it waits for page load, error handling for invalid URLs, or what the tool returns. This is a significant gap for a navigation action.

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, 'Navigate to a URL', with no wasted words. It is concise and front-loaded with the essential information.

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?

Although the tool is simple (one parameter, no output schema), the description lacks important contextual details like waiting behavior, return value, or prerequisites. It is adequate for a basic navigation command but leaves ambiguity about its behavior in the broader browser automation context.

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 100% coverage for the single 'url' parameter with a description. The tool description adds no additional semantic value beyond the schema, 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.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Navigate to a URL' uses a specific verb and resource, clearly indicating the core action. However, it does not differentiate from sibling navigation tools like browser_go_back or browser_go_forward, so it lacks explicit sibling distinction.

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, such as an active browser session, or scenarios where this tool is preferred over related navigation commands.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'Get list of network requests' and provides no information about return format, data scope, side effects, or whether it captures ongoing requests or just historical logs. This is a significant gap for a network-related tool.

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 and is front-loaded. However, it is under-specified rather than appropriately concise; it provides only the bare purpose without any context. It is not as minimal as a tautology, but it does not pack enough useful information to merit a higher score.

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 no output schema and no annotations, the description should explain what the returned data looks like or at least clarify its relationship to the sibling tool browser_get_network_logs. It does neither, making the tool ambiguous and incomplete for an agent trying to decide whether to invoke it.

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 tool has zero parameters, and the schema is empty. Per the rubric, 0 parameters gets a baseline of 4. The description does not need to add parameter details since there are none to document.

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: 'Get list of network requests' uses a specific verb and resource. However, it does not distinguish from the closely related sibling tool browser_get_network_logs, which likely serves a similar purpose, so it falls short of 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?

No guidance is provided on when to use this tool versus alternatives like browser_get_network_logs. The description lacks any context about use cases, prerequisites, or when to prefer another tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden for behavioral disclosure. It only states the raw action ('press a keyboard key') without revealing how modifiers, key combinations, or focus are handled, or whether the action is immediate and synchronous.

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?

A single, concise sentence captures the core functionality without unnecessary filler. While more detail could be added, the brevity is appropriate for a simple tool.

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 fully described parameter and no output schema. The description covers the fundamental action, but omits potential use cases like key combinations or interaction with focused elements, leaving moderate 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% and the 'key' parameter includes examples (Enter, Escape, Tab) which is sufficient for basic usage. The description adds no extra semantic value, so the baseline of 3 applies.

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 distinguishes it from mouse-based actions like browser_click and text entry like browser_type. However, it could more explicitly mention keyboard shortcuts or focus requirements to fully differentiate from siblings.

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 usage guidance is provided. The description does not specify when to use this tool versus alternatives like browser_type for text input or browser_evaluate for programmatic events, nor does it mention prerequisites such as element focus.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 only states the action without explaining failure modes, return values, or whether the tool waits for the element. This leaves the agent uncertain about important behaviors.

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 concise but under-specified. While it is a single short sentence, it omits crucial context, making it more minimal than appropriately sized. It earns its place but does not provide enough substance.

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 no output schema and no annotations, the description is incomplete. It does not mention return value, error behavior, or how it differs from similar selector tools, leaving significant gaps for correct 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?

The schema already fully describes the selector parameter as 'CSS selector', and the description merely repeats this. With 100% schema coverage, the baseline is 3, and the description adds no additional semantic meaning.

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 queries a single element using a CSS selector, which distinguishes it from browser_query_selector_all. However, it does not specify what the tool returns (e.g., element handle vs. content), so it is not fully specific.

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_wait_for_selector or browser_query_selector_all. There is no context about expected usage or exclusions, so the agent gets no decision support.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It only states 'query multiple elements' without revealing return format (e.g., array of element handles, text content), behavior on no matches (empty list vs error), or any side effects (likely none, but not explicitly stated). This lack of detail limits 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 redundant filler. It is front-loaded with the action and resource, making it easily scannable. However, it is a bit too terse for a tool without annotations, so it misses a little on completeness while maintaining 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?

Given the tool's simplicity (one parameter, no annotations, no output schema), the description covers the basic purpose but omits crucial context about the return value. The agent cannot know what 'query' returns (element references, text, etc.) or how to use the result, which is a significant gap for a tool without an output schema.

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 a description for the selector parameter ('CSS selector'). The tool description adds no additional meaning beyond the schema; it simply repeats 'by CSS selector'. Baseline of 3 is appropriate since 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 uses a specific verb 'query' with a specific resource 'multiple elements' and method 'by CSS selector', clearly distinguishing it from sibling tools like browser_query_selector (single element). The name reinforces this purpose, making it 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 implies usage when multiple elements are needed, but it does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or alternatives. There is no guidance on when to prefer this over browser_query_selector, though the 'multiple' wording hints at it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 'reload the current page' without mentioning side effects like discarding unsaved form input, aborting pending requests, or whether the reload is a hard refresh. This is minimal behavioral information.

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 phrase, 'Reload the current page', which is perfectly sized for a parameterless, straightforward action. Every word earns its place and there is 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?

Given the tool's simplicity (no parameters, no annotations, no output schema), the description is mostly sufficient. It clearly identifies the action and resource. However, it doesn't address potential edge cases or when to prefer this over related navigation tools, leaving a minor gap for agent decision-making.

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 tool has zero parameters, and the schema description coverage is 100% (vacuously). The description correctly implies there are no arguments to configure, so it earns a baseline of 4 per the rubric for tools with no parameters.

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 ('reload') and resource ('the current page'). It is distinct from sibling navigation tools like browser_navigate, browser_go_back, and browser_go_forward, as reload refreshes the same page rather than changing location.

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 usage guidance is provided. The description does not mention when to use this tool over alternatives, such as browser_navigate to revisit a URL or browser_wait_for_load to ensure the page has finished loading after an action.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It only states the action without detailing potential side effects, persistence, or impact on the current page, which is insufficient for a mutation-like tool.

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 is appropriately sized with no unnecessary words. It efficiently conveys the core intent.

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 two-parameter tool, the description covers the basic action and schema covers the parameters. However, the existence of a similarly named sibling tool and the lack of any usage context make it incomplete for an agent to fully understand the tool's role.

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 for both parameters (width and height in pixels), so the description adds no extra meaning. Per the rubric, this is the baseline score when schema coverage is high.

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 'Resize the browser viewport' with a specific verb and resource. However, there is a sibling tool 'browser_set_viewport_size' that appears to serve the same purpose, and the description does not differentiate between them, preventing a score of 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?

No guidance is provided on when to use this tool versus alternatives. The sibling 'browser_set_viewport_size' likely does the same thing, but the description offers no context or exclusion criteria, leaving the agent without clear selection guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 only states the action ('right click') without revealing expected outcomes like opening a context menu, triggering contextmenu events, or possible failures if the element is not found or not visible.

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 directly states the tool's action. It contains no filler or redundant information, making it exceptionally concise and easy to parse for an agent.

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 interaction tool, the description is adequate but incomplete. It fails to mention the primary behavior of right-clicking (e.g., opening a context menu) or any side effects, which would help an agent anticipate the tool's impact. Given no output schema and sparse annotations, the description leaves gaps in expected 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?

The schema already provides a clear description for the single parameter 'selector' as 'CSS selector of the element' (100% coverage). The tool description adds no additional meaning or usage detail beyond what the schema already communicates, 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 'Right click an element' clearly specifies the action (right click) and the target (an element), distinguishing it from sibling tools like browser_click, browser_double_click, and browser_hover. The verb+resource structure is specific and 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 provides no guidance on when to use this tool versus alternatives like browser_click or browser_hover. It does not mention that right-click is typically used to open context menus or any prerequisites such as element visibility or interactability.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

There are no annotations to rely on, so the description must disclose behavioral details such as whether the screenshot captures the full page or just the viewport, what the return format is, or whether the action is destructive. The description provides none of this, leaving the agent with only the basic action.

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, clear sentence with no redundant or irrelevant words. It front-loads the action and is appropriately concise for the tool's simplicity.

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 that there is no output schema and no annotations, the description is insufficiently complete. It does not explain what the tool returns (e.g., a file path or binary data), how it handles optional parameters, or any side effects, leaving the agent without essential context for correct use.

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 fully describes both parameters (format and quality) with defaults, covering 100% of the parameter semantics. The description adds no additional meaning beyond the schema, 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.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (take a screenshot) and the target (current page), using a specific verb and resource. It distinguishes itself from sibling tools like browser_snapshot, which captures accessibility snapshots, by explicitly focusing on a visual screenshot.

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_snapshot or browser_get_content, nor any prerequisites or conditions for use. The description simply states what it does without contextualizing its appropriate use.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 action without detailing side effects, support for multi-select, event triggering, error conditions, or response format. This adds little beyond what the tool name already implies.

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, tight sentence with zero redundant words. It is appropriately concise for a simple tool, and every word adds value by specifying the action and target.

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, but the description omits important contextual details such as whether selecting an option triggers change events, whether it works with custom dropdowns, and what the return value is. Without an output schema, more explanation is needed for reliable real-world usage.

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% for both parameters, each with a clear description. The tool description adds no extra meaning about value formats, selector context, or how multiple selections are handled, so the baseline of 3 is appropriate given the schema's completeness.

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 ('Select') and target ('option(s) in a dropdown'), clearly conveying the tool's function. It does not explicitly differentiate from sibling tools like browser_click or browser_fill, but the specificity of dropdown selection makes the purpose sufficiently clear.

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 vs alternatives. There is no mention of prerequisites, scenarios where it should be avoided, or alternative tools for similar interactions. The agent must infer usage solely from the tool name and minimal description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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 action ('set geolocation') without explaining effects on the browser, whether settings are persistent, or any side effects. This is a significant gap for a mutation-like tool.

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 extremely short, but this is under-specification rather than effective conciseness. The two-word sentence is redundant with the tool name and fails to deliver any valuable information, so it does not 'earn 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?

For a tool with no annotations and no output schema, the description is insufficient. It does not explain units, expected range, or behavioral context, leaving the agent with only the schema to understand the tool's purpose.

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 itself adds no parameter information beyond the schema, but the schema already documents latitude and longitude, albeit minimally.

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 'Set geolocation' directly restates the tool name 'browser_set_geolocation' with no additional context or differentiation from sibling tools. It is a tautology, providing no new information about what the tool specifically does.

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 no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, situational context, or exclusions, leaving the agent without direction on appropriate usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full responsibility for disclosing side effects, but it only states a generic action. It does not mention whether permissions persist, whether they apply to the current session, or any security implications.

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 extremely brief but under-specified. It is not merely concise; it omits essential context, making it an under-specification rather than efficient communication.

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 simple parameter set and the schema coverage, the description is insufficient to understand the tool's role. It lacks any explanation of valid permission values or the effect of setting them, leaving an agent without adequate context for 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?

The input schema already provides 100% description coverage for both parameters (origin and permissions). The description adds no additional semantic meaning beyond what the schema offers, so baseline 3 applies.

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 'Set browser permissions' is essentially a restatement of the tool name, providing no additional specificity about what permissions are affected or what setting them entails. It fails to distinguish by scope or context.

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, prerequisites, or alternatives. The description does not mention any context such as needing to set permissions before certain browser actions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description only states the action without disclosing any side effects, such as whether it triggers a resize event, reloads the page, or persists across navigations. With no annotations provided, the description should carry this burden but doesn't.

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 three words and contains zero redundant information. It is appropriately sized for a simple setter action.

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 viewport setter, the basic action is clear, but the description lacks context about its effect on the current page, relation to browser_resize, or whether navigation is needed. It's minimally complete but misses behavioral context.

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 comprehensively describes both width and height parameters with units (pixels), and the description adds no additional parameter semantics. Baseline of 3 is appropriate given 100% 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 clearly states the action 'Set viewport size' with a specific verb and resource. It is unambiguous but doesn't explicitly distinguish from the sibling tool browser_resize, so it's not a perfect 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?

No guidance is provided on when to use this tool versus alternatives like browser_resize, nor any context such as before/after navigation. The description gives no usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the action ('get accessibility snapshot') without mentioning side effects, permissions, or that it is a read-only operation. This lack of context is a gap for safe invocation.

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 directly states the purpose and the alias. It wastes no words and is appropriately sized for the tool's simplicity.

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 no output schema, the description should explain what the accessibility snapshot contains or how it is returned. It does not, and instead only provides a terse directive. While the alias reference helps, the description is not fully complete for an agent needing to interpret the result.

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 tool has zero parameters, which earns a baseline of 4. The description correctly implies that no inputs are needed and does not need to add parameter details because the schema is empty and fully covered.

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 gets an accessibility snapshot of the page, using a specific verb and resource. It also identifies itself as an alias for browser_get_accessibility_tree, which explicitly distinguishes it from other browser tools by showing it is equivalent to a known sibling.

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 via the alias statement, indicating it can be used interchangeably with browser_get_accessibility_tree. However, it does not explicitly state when this snapshot is needed versus other browser inspection tools, nor does it provide exclusions or alternative recommendations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral disclosure burden but only states the basic action. It omits behavioral details such as whether the element must be visible, whether existing text is cleared, whether keystrokes are fired individually, or what happens on failure, so the agent cannot anticipate 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no filler, making it maximally concise and easy to parse. It earns its place by stating the core action efficiently.

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 low parameter complexity and full schema coverage, the basic action is understandable, but the description lacks the usage and behavioral context needed to disambiguate from browser_fill. With no output schema and many sibling typing-related tools, it is minimally viable but not fully 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%: both 'selector' and 'text' include descriptive text. The description adds no parameter semantics beyond that, so it earns the baseline score for schema-covered params.

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 clear verb+resource ('Type text into an element') and matches the browser_type name. However, it does not distinguish this from sibling tools like browser_fill or browser_press_key, both of which could plausibly type 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?

No usage guidance is provided; the description never states when to prefer this over browser_fill or browser_press_key. There are no exclusions, prerequisites, or alternative recommendations, so the agent receives no decision support.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full responsibility for disclosing behavior. It only states the action 'uncheck a checkbox' without mentioning side effects, error behavior (e.g., if the element is not found or already unchecked), waiting semantics, or any mutating consequences.

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 wasted words. While efficient, it is somewhat under-specified, lacking supportive context that would make it more useful, but it is not verbose.

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 one parameter, no annotations, and no output schema, the description is minimal. It does not mention when to apply this action, how it interacts with the page state, or alternative behaviors. The lack of usage guidance makes it incomplete for an agent deciding between this and browser_check.

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 a clear description for the sole parameter 'selector' at 100% coverage. The tool description adds no further meaning about how the selector is used or formatted, so it does not exceed the schema baseline.

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 'Uncheck a checkbox' clearly states the action and target resource. It distinguishes from the sibling browser_check by using the inverse verb, though it does not explicitly name the alternative. The purpose is unambiguous and specific.

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_check. It does not state whether this should be used only on already-checked checkboxes, nor does it mention any prerequisites or context for use. No usage context is given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the high-level wait action without covering important behavioral traits such as timeout handling, return values, error behavior, or what 'finished loading' means (e.g., network idle vs. DOMContentLoaded). This is insufficient for a tool that may block or fail.

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, direct sentence with no unnecessary words. It is front-loaded and efficient. While it is terse to the point of being under-specified, it is still well-structured for what it includes, so it earns a high score on conciseness alone.

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 (one optional parameter, no output schema) and lack of annotations, the description still needed to explain when to use it relative to sibling wait tools and what it returns or throws on timeout. It does neither, leaving it incomplete for an agent to invoke 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 already fully documents the single timeout parameter with a type, description, and default value (schema coverage 100%). The description adds no additional parameter semantics, so it meets the baseline expected when the schema handles parameter documentation.

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 'Wait for page to finish loading' clearly identifies the action (wait) and the target resource (page load), which is specific enough to convey the basic purpose. However, it does not distinguish it from sibling wait tools like browser_wait_for_navigation or browser_wait_for_url, so it misses full 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. With several wait-related sibling tools (browser_wait_for_selector, browser_wait_for_navigation, browser_wait_for_timeout, etc.), the description provides no contextual cues or exclusions, leaving the agent without clear selection criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It only restates the basic action and does not disclose behavior such as timeout handling, what counts as navigation complete, or error conditions.

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 words or filler. It is front-loaded and efficient, though it could include more useful detail.

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 large number of sibling wait tools (wait_for_load, wait_for_url, wait_for_response, etc.) and no annotations, the description is insufficiently complete. It does not clarify the difference between navigation and other wait conditions.

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 timeout parameter is fully documented. The description adds no parameter information, but given the schema coverage, a 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 action and resource ('Wait for navigation to complete'), but it does not distinguish this tool from siblings like browser_wait_for_load or browser_wait_for_url. It is clear on its own but lacks 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. The description does not mention similar wait tools or provide any context for selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states the high-level action, omitting critical behavioral details such as timeout semantics (throws or resolves?), matching criteria (regex against status code, headers, or body?), and what happens if no matching response occurs. The description adds nothing beyond the basic action, leaving users to guess at the tool's inner workings.

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 of six words. It is front-loaded with the primary action, contains no filler, and every word contributes to the core purpose. This is exemplary conciseness with zero waste.

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 no annotations, no output schema, and two parameters including a regex pattern and timeout, the description is too sparse. It fails to explain return behavior, error conditions, or how the URL pattern is applied (e.g., exact match vs substring). The tool is moderately simple, but the lack of behavioral and output context leaves significant gaps for an agent attempting to use it 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%, so both parameters (urlPattern as a regex string, timeout with default of 30000 ms) are already documented. The description's phrase 'matching URL pattern' essentially restates the urlPattern parameter without adding new semantics. This meets the baseline of 3 for high schema coverage but does not elevate the meaning.

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 'Wait for network response matching URL pattern' has a specific verb ('wait for') and resource ('network response'), with a clear qualifier ('matching URL pattern'). It distinguishes itself from sibling tools like browser_wait_for_load, browser_wait_for_selector, and browser_wait_for_navigation by targeting network responses rather than page loads, DOM elements, or navigation events.

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 explicit guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or alternative tools such as browser_wait_for_navigation or browser_wait_for_selector. The only usage context is implied by the purpose statement itself, which is too weak to count as meaningful guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does not explain what happens on timeout (e.g., error vs. boolean), whether it polls, whether it checks visibility or mere presence, or whether the element must already be present. The one-line description leaves critical behavior unspecified.

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 extraneous words. It is front-loaded and efficient, conveying the core action in minimal length. All words contribute to meaning, earning a perfect score for 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?

Given no annotations and no output schema, the description must provide enough context for an agent to use the tool correctly. It lacks critical information about return values, timeout behavior, error handling, and the meaning of 'appear' (e.g., exists vs. visible). The description is insufficient for a wait tool with several behavioral unknowns.

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% for both 'selector' and 'timeout', including a default for timeout. The description adds no additional meaning beyond the schema, so the baseline score of 3 applies. It does not supplement parameter semantics with additional context or 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 ('Wait') and resource ('an element'), clearly indicating the tool waits for a selector to appear. It distinguishes itself from sibling wait tools like browser_wait_for_load, browser_wait_for_navigation, browser_wait_for_url, and browser_wait_for_response by focusing specifically on the presence of an element.

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 no explicit guidance on when to use this tool versus alternatives. It implies usage for waiting on an element, but does not mention conditions, prerequisites, or exclusions, especially when several sibling wait tools exist. No alternative tools are referenced.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It only restates what the tool does without revealing behavioral details like blocking behavior, return value, or error conditions. The description adds no context beyond the name and 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, short sentence with zero wasted words. It is appropriately sized for such a simple tool and front-loads the core action.

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 one-parameter tool, the description plus schema is adequate for basic invocation. However, it lacks any usage context or differentiation from conditional wait tools, which may cause confusion in tool 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?

Schema description coverage is 100% for the single parameter, so the baseline is 3. The description does not add any additional semantics beyond referencing 'specified time' which aligns with the schema's 'Milliseconds to wait.'

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 performs a wait for a specified duration, which is a specific verb+resource. It is distinct from sibling wait tools that wait for conditions (e.g., browser_wait_for_load, browser_wait_for_selector) because this one waits for a timeout duration.

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 the many conditional wait tools in the sibling list. There is no mention of alternatives, exclusions, or use cases such as 'use this to add a fixed delay.'

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of disclosing behavior. It does not explain how URL matching is performed (e.g., regex full match vs partial, case sensitivity), what happens on timeout, or whether this waits for navigation or just polls the current URL. This is minimal beyond the literal name.

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 fluff. It is appropriately sized for a simple wait operation, though it sacrifices detail for brevity.

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 (2 params, no output schema), the description is still incomplete. It fails to distinguish itself from browser_wait_for_navigation or browser_wait_for_load, does not mention polling behavior or timeout handling, and provides no examples or edge cases. The description would leave an agent guessing about exact semantics.

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 `urlPattern` (regex string) and `timeout` (default 30000) are documented in the schema. The description adds no additional meaning beyond the schema, so the baseline of 3 applies.

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: waiting for a URL to match a pattern. It uses a specific verb ('wait') and resource ('URL'), and the pattern-matching aspect distinguishes it from other wait tools like browser_wait_for_load and browser_wait_for_navigation, though it does not explicitly name alternatives.

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 sibling tools like browser_wait_for_navigation (waiting for navigation) or browser_wait_for_selector (waiting for a DOM element). The description does not mention typical scenarios or exclusions, leaving the user 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.