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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the basic action but doesn't disclose critical traits like error handling (what happens if selector fails), side effects (page navigation after click), or performance considerations (timeout behavior). This leaves significant gaps 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 extremely concise at just four words, front-loading the core action without any wasted text. Every word earns its place by communicating the essential purpose 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 mutation tool with 6 parameters, no annotations, and no output schema, the description is inadequate. It lacks information about behavioral outcomes, error conditions, and relationship to the browser instance lifecycle, leaving too much undefined for reliable agent 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?

Schema description coverage is 100%, providing complete parameter documentation. The description adds no additional parameter semantics beyond implying a 'click' action, which aligns with but doesn't enhance the schema. This meets 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?

The description 'Click on a page element' clearly states the action (click) and target (page element), which is specific and unambiguous. However, it doesn't differentiate from potential sibling actions like 'right-click' or 'double-click' that might be implied by parameters but aren't explicitly mentioned in the description itself.

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's no mention of prerequisites (e.g., needing an active browser instance), when not to use it, or how it relates to sibling tools like browser_wait_for_element or browser_select_option for similar interactive 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 provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose whether this closes tabs, windows, or processes; whether it's reversible; what happens to unsaved data; or if it requires specific permissions. 'Close all' suggests a destructive operation, but this isn't explicitly stated.

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 wasted words. It's front-loaded with the core action and target, making it immediately scannable and efficient. 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?

For a destructive tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'browser instances' means, what gets closed, whether there are confirmation prompts, what the return value is, or error conditions. Given the potential impact, more context is needed.

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 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description correctly doesn't discuss parameters, maintaining focus on the tool's purpose. Baseline 4 is appropriate for zero-parameter tools.

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 ('Close') and target ('all browser instances'), making the purpose immediately understandable. It distinguishes from sibling 'browser_close_instance' by specifying 'all' instances. However, it doesn't specify what 'browser instances' refers to in this context (e.g., tabs, windows, processes).

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 like 'browser_close_instance' for individual instances or 'browser_list_instances' to check what's open. The description implies a destructive cleanup operation but doesn't specify prerequisites or consequences.

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 states the action ('Close') but doesn't explain what closing entails (e.g., whether it terminates processes, frees resources, or if it's reversible). It also omits potential side effects, error conditions, or permissions needed, which 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, direct sentence with zero wasted words. It front-loads the core action and target, making it immediately scannable and efficient. Every word earns its place, and there's no unnecessary elaboration or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover what happens after closing (e.g., success/failure indicators, cleanup effects) or how it integrates with sibling tools (e.g., 'browser_list_instances'). The agent lacks context on behavioral outcomes and error handling, which is critical for safe 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 schema description coverage is 100%, with the single parameter 'instanceId' documented as 'Instance ID'. The description adds no additional meaning beyond this, such as how to obtain the ID or format requirements. Given the high schema coverage, a baseline score of 3 is appropriate as the schema handles the parameter documentation adequately.

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 ('Close') and target ('the specified browser instance'), making the purpose immediately understandable. It distinguishes from siblings like 'browser_close_all_instances' by specifying a single instance, though it doesn't explicitly name this distinction. The description avoids tautology by not just restating the tool name.

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_close_all_instances' or 'browser_list_instances'. It doesn't mention prerequisites (e.g., needing an existing instance) or typical workflows (e.g., cleanup after operations). This leaves the agent to infer usage from context 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 states 'Create' which implies a write/mutation operation, but doesn't disclose any behavioral traits: no mention of permissions required, whether instances persist across sessions, rate limits, what happens on failure, or what the return value might be (e.g., instance ID). The description is minimal and lacks crucial operational 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, efficient sentence with zero waste—it states the core purpose without unnecessary words. It's appropriately sized for a tool with a clear primary function and well-documented schema. Every word earns its place, making it easy to parse quickly.

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 complexity (5 parameters with nested objects, no output schema, and no annotations), the description is incomplete. It doesn't explain what a browser instance is in this system, how it's used with sibling tools, what happens after creation, or any error conditions. For a mutation tool with significant parameter structure, more context is needed to guide effective 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?

Schema description coverage is 100%, with all parameters well-documented in the schema itself (e.g., browserType with enum values, headless default, viewport structure). The description adds no parameter semantics beyond what's already in the schema—it doesn't explain why you'd choose different browser types, when to use headless mode, or how metadata is used. Baseline 3 is appropriate since 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 clearly states the action ('Create') and resource ('new browser instance'), making the purpose immediately understandable. It distinguishes this from sibling tools like browser_list_instances or browser_close_instance by focusing on creation rather than listing or closing. However, it doesn't specify what a 'browser instance' entails in this context (e.g., a controlled browser session for automation).

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 doesn't mention prerequisites (e.g., needing to create an instance before using browser_navigate), when not to use it (e.g., if an instance already exists), or how it relates to sibling tools like browser_list_instances for checking existing instances. Usage is implied but not explicitly 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions execution but doesn't specify whether this is read-only or has side effects, what permissions are needed, how errors are handled, or what the return format might be. For a tool that executes arbitrary JavaScript, this lack of safety and behavioral context is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core action and context, making it highly efficient and easy to parse.

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 complexity of executing JavaScript in a browser context, the lack of annotations, and no output schema, the description is insufficient. It doesn't address critical aspects like security implications, error handling, return values, or dependencies on other tools (e.g., requiring browser_create_instance first). This leaves too many unknowns for safe and effective 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 schema description coverage is 100%, so the schema already documents both parameters (instanceId and script) adequately. The description doesn't add any additional meaning beyond what the schema provides, such as examples of valid scripts or instanceId formats, but it doesn't need to given the 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 clearly states the action ('Execute JavaScript code') and the context ('in the page context'), which distinguishes it from general JavaScript execution tools. However, it doesn't explicitly differentiate from potential sibling tools that might also execute code in different contexts, though the 'page context' specification is helpful.

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_element_text or browser_wait_for_element, nor does it mention prerequisites such as requiring an existing browser instance. It simply states what the tool does without contextual usage information.

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 but offers minimal behavioral context. It implies a mutation action ('fill') but doesn't disclose error conditions (e.g., if selector fails), side effects, or performance aspects like the timeout parameter's role. It mentions no authentication needs or rate limits, leaving critical operational details unclear.

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 at three words, with no wasted language. It front-loads the core purpose immediately, making it easy to parse. Every word earns its place by directly conveying the tool's function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (interacting with browser instances and DOM elements), no annotations, and no output schema, the description is insufficient. It lacks details on return values, error handling, prerequisites like instanceId usage, and how it integrates with sibling tools. For a browser automation tool with multiple parameters, this leaves too many 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 description coverage is 100%, so the schema already documents all parameters (instanceId, selector, value, timeout). The description adds no additional meaning beyond implying 'value' is for filling form fields, but doesn't clarify parameter interactions or usage nuances. Baseline 3 is appropriate as the schema handles most 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 'Fill a form field' clearly states the action (fill) and target (form field), which is specific and unambiguous. It distinguishes this from siblings like browser_click or browser_type by focusing on form field population, though it doesn't explicitly differentiate from browser_select_option which also interacts with form elements.

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 doesn't mention prerequisites (e.g., needing an active browser instance), contrast with similar tools like browser_type (for typing) or browser_select_option (for dropdowns), or specify when not to use it (e.g., for non-form elements).

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. 'Get element attribute value' implies a read-only operation, but it doesn't disclose critical behaviors: that it requires a valid browser instance (instanceId), may fail if the element isn't found or times out, or returns a string/null value. For a tool with 4 parameters and no annotation coverage, this leaves significant gaps in understanding how it behaves in practice.

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, efficient phrase ('Get element attribute value') that front-loads the core purpose with zero wasted words. Every term earns its place: 'Get' specifies the action, 'element attribute' identifies the target, and 'value' clarifies the output. It's appropriately sized for a straightforward 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 complexity (4 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the return value (e.g., string or null), error conditions (e.g., if element not found), or dependencies (requires an active browser instance). For a browser interaction tool with multiple parameters, this minimal description leaves too much unspecified for reliable agent 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?

Schema description coverage is 100%, with all parameters clearly documented in the schema (instanceId, selector, attribute, timeout). The description adds no additional meaning beyond what the schema provides—it doesn't explain what an 'element attribute' is, provide examples of selectors or attribute names, or clarify the timeout behavior. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't enhance parameter understanding.

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 element attribute value' clearly states the verb ('Get') and resource ('element attribute value'), making the purpose immediately understandable. It distinguishes itself from siblings like browser_get_element_text (which gets text content) and browser_wait_for_element (which waits for existence). However, it doesn't specify that this operates on a browser instance, which is implied but not explicit.

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 doesn't mention prerequisites (like needing an existing browser instance), when not to use it (e.g., for text content vs. attributes), or refer to sibling tools like browser_get_element_text for different element properties. The agent must infer usage from the tool name and context 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 full burden but offers minimal behavioral context. It doesn't disclose that this is a read-only operation (implied by 'Get'), doesn't mention potential failures (e.g., if element isn't found or isn't visible), and doesn't describe return format or error handling. The timeout parameter suggests it might wait for elements, but this isn't explicitly explained.

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 maximally concise with just four words that directly state the tool's function. There's zero waste or redundancy, and the information is front-loaded appropriately for such a simple 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?

For a browser automation tool with 3 parameters and no output schema, the description is inadequate. It doesn't explain what 'text content' means (innerText vs textContent), doesn't mention the tool's relationship to other browser tools, and provides no information about return values or error conditions despite the complexity of browser interactions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters adequately. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain selector syntax, instanceId format, or timeout behavior. Baseline 3 is appropriate when 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 clearly states the verb ('Get') and resource ('element text content'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its sibling 'browser_get_element_attribute', which also retrieves element properties but for attributes rather than text content.

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_element_attribute' or 'browser_get_markdown'. It also doesn't mention prerequisites such as needing an existing browser instance or when text extraction is appropriate versus other retrieval methods.

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 mentions optimization for large language models, which adds some context about output format, but fails to describe key behaviors: whether it's read-only, if it requires specific permissions, rate limits, or what happens on errors. For a tool with no annotation coverage, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and includes a useful optimization note. Every word earns its place, 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 complexity (4 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits, error handling, and output specifics. While it states the format and optimization, it doesn't cover enough context for safe and effective use, especially for a tool that interacts with browser instances.

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 description adds no parameter-specific information beyond what the input schema provides. Schema description coverage is 100%, so all parameters are documented in the schema. The description implies content extraction but doesn't elaborate on parameter usage or interactions. Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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: 'Get page content in Markdown format, optimized for large language models.' It specifies the verb ('Get'), resource ('page content'), and format ('Markdown'), distinguishing it from siblings like browser_get_element_text or browser_get_page_info. However, it doesn't explicitly differentiate from all siblings (e.g., browser_evaluate might also retrieve content).

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 mentions optimization 'for large language models,' which hints at a context but doesn't specify scenarios or exclusions. No explicit alternatives or prerequisites are stated, leaving usage unclear relative to siblings like browser_get_element_text or browser_get_page_info.

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 mentions what information is retrieved but lacks details on performance (e.g., speed, potential delays), side effects (e.g., whether it triggers page loads or network requests), error handling, or output format. For a tool that retrieves 'detailed' data without annotations, this is a significant gap in 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, efficient sentence that front-loads the core purpose ('Get detailed page information') and specifies key components (HTML content, statistics, metadata). There is no wasted verbiage, and every word contributes to understanding the tool's function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (retrieving multiple types of page data), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like how the data is structured, potential limitations (e.g., size constraints), or dependencies on other tools (e.g., requiring a browser instance). For a tool with no structured support, more context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the single parameter 'instanceId' documented as 'Instance ID'. The description adds no additional parameter semantics beyond what the schema provides, such as explaining what an instance ID represents or how to obtain it. Baseline score of 3 is appropriate since 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 clearly states the tool's purpose with a specific verb ('Get') and resource ('detailed page information'), including what information is retrieved (HTML content, statistics, metadata). It distinguishes itself from siblings like browser_get_element_attribute or browser_get_markdown by focusing on comprehensive page-level data rather than specific elements or formats. However, it doesn't explicitly differentiate from all siblings in the browser tool family.

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 doesn't mention prerequisites (e.g., needing an active browser instance), exclusions, or comparisons to siblings like browser_get_markdown (which might provide formatted content) or browser_list_instances (which manages instances). Usage is implied but not explicitly 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but doesn't describe what happens on failure (e.g., if no previous page exists), whether it waits for navigation to complete, or any side effects. For a mutation tool with zero annotation coverage, this is a significant gap in 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, efficient sentence that directly states the tool's function without any unnecessary words. It is front-loaded and perfectly concise, earning its place 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?

Given the complexity of a browser navigation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavior (e.g., success/failure conditions, waiting), prerequisites, and return values. For a tool that likely involves state changes and potential errors, more context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the single parameter 'instanceId' documented as 'Instance ID'. The description doesn't add any meaning beyond this, such as explaining what an instance represents or how to obtain it. With high schema coverage, 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 ('Go back') and the target ('to the previous page'), which is specific and unambiguous. However, it doesn't explicitly differentiate from its sibling 'browser_go_forward', though the distinction is obvious from the names. The purpose is clear but lacks explicit 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., requires an existing browser instance with navigation history), exclusions (e.g., not applicable if no previous page exists), or comparisons with siblings like 'browser_navigate' or 'browser_go_forward'. Usage is implied but not 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the action but doesn't explain what happens if there's no forward page available (e.g., error behavior), whether it waits for navigation to complete, or what the expected outcome is. This leaves significant behavioral gaps for a navigation 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, efficient sentence with zero wasted words. It's appropriately sized for a simple navigation tool and front-loads the core functionality 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?

Given the tool's navigation purpose and lack of both annotations and output schema, the description is insufficient. It doesn't explain what constitutes 'success' (e.g., page loaded), error conditions, or behavioral expectations, leaving the agent with incomplete context for proper 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 description coverage is 100%, so the schema already documents the single 'instanceId' parameter. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score of 3 where 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 clearly states the action ('Go forward') and target ('to the next page'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish this tool from its sibling 'browser_go_back' (which presumably goes backward), leaving some room for 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?

The description provides no guidance on when to use this tool versus alternatives like 'browser_navigate' or 'browser_go_back', nor does it mention prerequisites (e.g., requiring a browser instance with forward navigation available). It simply states what the tool does without contextual usage information.

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. 'List all browser instances' implies a read-only operation, but it doesn't specify what information is returned (e.g., instance IDs, URLs, status), whether the list is real-time or cached, or if there are any side effects like refreshing instances. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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, clear sentence with zero waste. It's front-loaded with the core action ('List all browser instances') and doesn't include any redundant or verbose language. Every word earns its place, making it highly efficient.

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 (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on return values, behavior, or usage context. For a list operation with no structured output documentation, the description should ideally specify what information is returned to 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 tool has 0 parameters, and schema description coverage is 100% (though empty). The description doesn't need to explain parameters, but it implicitly confirms there are none by not mentioning any. This is appropriate for a parameterless tool, earning a baseline 4 as it adds no unnecessary information.

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 'List all browser instances' clearly states the verb ('List') and resource ('browser instances'), making the purpose immediately understandable. It distinguishes this tool from siblings that perform actions on browser instances (like click, navigate, close) rather than listing them. However, it doesn't specify what constitutes a 'browser instance' or the scope of 'all' (e.g., all currently active instances).

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 doesn't mention prerequisites (e.g., whether browser instances must be created first), nor does it differentiate from potential sibling tools like 'browser_get_page_info' which might provide overlapping information. Usage is implied by the name but not explicitly 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Navigate') but doesn't explain what this entails—e.g., whether it opens a new page, reloads an existing one, handles errors, or requires specific permissions. This is a significant gap for a tool with potential side effects like navigation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and target, making it easy to parse quickly without unnecessary details.

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 complexity of browser navigation (involving instance management, timing, and state changes), no annotations, and no output schema, the description is incomplete. It lacks details on behavior, error handling, or what happens post-navigation, leaving gaps for the agent to operate effectively.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters (instanceId, url, timeout, waitUntil) with descriptions. The description adds no additional meaning beyond implying a 'url' parameter, which is already covered. Baseline 3 is appropriate as 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 clearly states the action ('Navigate') and target ('to a specified URL'), which is specific and unambiguous. However, it doesn't distinguish this tool from sibling navigation tools like 'browser_go_back' or 'browser_go_forward', which are also navigation-related but for different directions.

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 doesn't mention prerequisites (e.g., needing an existing browser instance), exclusions, or comparisons to siblings like 'browser_refresh' or 'browser_wait_for_navigation', leaving the agent to infer 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 carries full burden for behavioral disclosure. 'Refresh the current page' implies a mutation (reloading), but it doesn't specify side effects (e.g., losing unsaved form data), authentication needs, rate limits, or what happens on failure. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding the tool's behavior and risks.

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, efficient sentence with zero waste. It is front-loaded with the core action ('Refresh') and immediately specifies the target ('the current page'), making it easy to parse. Every word earns its place, and there is no unnecessary elaboration or 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 complexity (a mutation with no annotations) and lack of output schema, the description is incomplete. It doesn't explain what 'refresh' entails (e.g., reloading, clearing cache), potential side effects, error conditions, or return values. For a browser interaction tool that could disrupt user state, this minimal description fails to provide adequate context for safe and effective 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?

Schema description coverage is 100%, with the single parameter 'instanceId' documented as 'Instance ID' in the schema. The description adds no additional parameter information beyond what the schema provides. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description, which applies here.

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 ('Refresh') and target ('the current page'), making the purpose immediately understandable. It doesn't explicitly differentiate from siblings like browser_navigate or browser_go_back/forward, but the verb 'refresh' is specific enough to imply reloading the current page rather than navigation. This is better than vague or tautological descriptions.

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 doesn't mention prerequisites (e.g., needing an active browser instance), when not to use it (e.g., during form submission), or how it differs from siblings like browser_navigate (which loads a new URL) or browser_go_back/forward (which navigate history). Without such context, 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?

No annotations are provided, so the description carries full burden. It states the action but lacks details on behavioral traits: it doesn't specify output format (e.g., base64 string, file path), error conditions, permissions needed, or side effects. This is a significant gap for a tool with no annotation coverage.

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 zero waste. It's front-loaded and efficiently conveys the core purpose without 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?

Given no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., image data, success status) or address potential complexities like handling missing elements or instance errors. For a 5-parameter tool with behavioral implications, this is inadequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds minimal value beyond schema, only implying 'page or element' maps to fullPage and selector parameters. Baseline 3 is appropriate as schema does 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 clearly states the action ('Take a screenshot') and target ('page or element'), which is specific and distinguishes it from siblings like browser_click or browser_type. However, it doesn't explicitly differentiate from other screenshot-related tools (none exist in siblings), 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. It doesn't mention prerequisites (e.g., needing an active browser instance), exclusions, or comparisons with other tools. The description is standalone without 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 full burden of behavioral disclosure. It states the action but doesn't cover critical aspects like error handling (e.g., what happens if the dropdown isn't found), side effects (e.g., page changes), or performance traits (e.g., timeout behavior beyond the schema). This is inadequate for a mutation tool with zero annotation coverage.

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, efficient sentence with zero waste—it directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.

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 complexity of a browser interaction tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits, error cases, and output expectations, which are crucial for safe and effective tool invocation in this 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?

Schema description coverage is 100%, so the schema already documents all parameters (instanceId, selector, value, timeout). The description implies the 'value' parameter is used to select an option but doesn't add meaning beyond the schema, such as format examples or interaction details. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

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

The description clearly states the action ('Select an option') and the target ('from a dropdown'), which is specific and distinguishes it from siblings like browser_click or browser_fill that perform different browser interactions. However, it doesn't explicitly differentiate from potential similar tools like browser_fill for dropdowns, keeping it at 4 rather than 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an active browser instance), exclusions, or compare it to siblings like browser_click for non-dropdown elements or browser_fill for text inputs, leaving the agent to infer 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't mention what happens if the element isn't found (timeout behavior), whether it simulates keystrokes or sets value, or any side effects. The description is minimal and lacks critical 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, clear sentence with zero wasted words. It's front-loaded with the core action and efficiently communicates the essential purpose without unnecessary elaboration.

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 5 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain return values, error conditions, or behavioral nuances like how delays work or what happens on timeout. The agent would need to guess critical aspects of tool behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no additional meaning beyond implying that 'text' is typed into an element identified by 'selector'. This meets the baseline for high schema coverage but doesn't enhance understanding.

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 ('Type text') and target ('into an element'), making the purpose immediately understandable. It distinguishes itself from siblings like browser_click (clicking) and browser_fill (filling forms), though it doesn't explicitly differentiate from browser_fill which might have overlapping functionality.

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_fill or browser_select_option. It doesn't mention prerequisites (e.g., needing an existing browser instance) or typical use cases, leaving the agent to infer usage from context 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, so the description carries full burden. It mentions waiting behavior but lacks critical details: what happens on timeout (error, return null?), whether it polls continuously, if it waits for visibility vs. existence, or any side effects. This is a significant gap for a tool that could block execution.

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, efficient sentence with zero waste. It's front-loaded and appropriately sized for a simple tool, though this conciseness comes at the cost of detail in other dimensions.

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 is incomplete. It doesn't explain what the tool returns (e.g., success boolean, element reference), timeout behavior, or error conditions. For a waiting tool with potential blocking effects, this leaves the agent guessing about critical operational aspects.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters (instanceId, selector, timeout). The description adds no additional meaning beyond implying the selector targets the element to wait for. Baseline 3 is appropriate as 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 'Wait for an element to appear' clearly states the action (waiting) and target (an element), but it's vague about what constitutes 'appearing' (e.g., visibility, existence in DOM) and doesn't differentiate from siblings like browser_wait_for_navigation. It's functional but lacks specificity for a browser automation 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. It doesn't mention prerequisites (e.g., needing an active browser instance via instanceId), nor does it compare to other waiting tools like browser_wait_for_navigation. The agent must infer usage from the tool name and parameters 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, so the description carries the full burden. It mentions waiting for navigation completion but lacks details on behavioral traits: it doesn't specify what happens on timeout (e.g., error thrown, return status), whether it blocks until navigation finishes or times out, or if it handles redirects or multiple navigations. This is a significant gap for a tool with potential 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, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and every part of the sentence contributes to understanding the tool's function, 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 complexity of navigation waiting (which involves asynchronous behavior and potential errors), the description is incomplete. No output schema exists, so return values are undocumented. With no annotations and minimal description, it fails to cover critical aspects like error handling, success criteria, or interaction with other browser tools, leaving gaps for an AI 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?

Schema description coverage is 100%, so the schema already documents both parameters (instanceId and timeout) with descriptions. The description adds no additional meaning beyond what the schema provides, such as explaining how timeout interacts with navigation events or why instanceId is required. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

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

The description clearly states the action ('wait for page navigation to complete'), which is a specific verb+resource combination. It distinguishes itself from siblings like browser_navigate (which initiates navigation) and browser_wait_for_element (which waits for elements rather than navigation events). However, it doesn't explicitly mention what constitutes 'complete' navigation (e.g., network idle, DOM ready), leaving some ambiguity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage after initiating navigation (e.g., with browser_navigate) but doesn't explicitly state when to use it versus alternatives. It doesn't mention prerequisites like needing an active browser instance or specify scenarios where this tool is necessary versus relying on implicit waits. No exclusions or clear alternatives are provided.

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