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 the method ('mss') and a use case, but lacks details on permissions needed, file format, error handling, or whether it overwrites existing files. This is inadequate for a tool that captures screenshots, which may involve system access and file operations.

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 no wasted words. It is front-loaded with the core action and includes necessary context without 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 (screenshot capture with system interaction), no annotations, and an output schema present, the description is minimal. It covers purpose and method but lacks behavioral details and parameter guidance. The output schema may help, but the description itself is incomplete 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 0%, with one parameter 'save_path' undocumented. The description does not mention parameters at all, failing to compensate for the coverage gap. However, with only one optional parameter, the baseline is slightly higher, but it adds no value beyond the schema.

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

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

The description clearly states the action ('Take a desktop screenshot') and resource ('whole screen'), specifying the method ('using mss') and a use case ('physical-input verification'). It distinguishes from sibling 'capture_page_screenshot' by focusing on desktop rather than web page, though not explicitly named.

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 'physical-input verification,' suggesting a context, but does not explicitly state when to use this tool versus alternatives like 'capture_page_screenshot' or other input methods. No exclusions or prerequisites 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 provided, the description carries full burden for behavioral disclosure. It mentions the optional file save but lacks details on permissions needed, whether it's read-only or destructive, error handling, or output format beyond the schema. This leaves significant gaps for a tool that interacts with browser pages.

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. However, it could be more structured by separating the capture action from the optional save feature, and it lacks critical details that would justify additional length.

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 4 parameters with 0% schema coverage, no annotations, and an output schema present, the description is incomplete. It hints at CDP usage and file saving but omits parameter semantics, behavioral traits, and differentiation from siblings. The output schema reduces the need to describe return values, but other gaps remain significant.

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 0%, so the description must compensate. It only mentions the 'save_path' parameter explicitly and implies CDP context via 'session_id' and 'tab_id', but doesn't explain parameter meanings, defaults, or interactions. This provides minimal value beyond the schema's property names, meeting the baseline for inadequate 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 ('capture a screenshot') and the target ('current page/tab via CDP'), distinguishing it from sibling tools like 'capture_desktop_screenshot'. However, it doesn't explicitly differentiate from other CDP-based tools like 'cdp_command' or 'scan_page', which prevents a perfect score.

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 'capture_desktop_screenshot' for desktop screenshots or 'cdp_command' for other CDP operations. It mentions the optional file save feature but doesn't clarify prerequisites or context for effective 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says the tool 'runs' a command but does not mention side effects, safety risks, session requirements, or what happens on execution. For a raw CDP command execution tool, this is a significant transparency 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 sentence with no filler, and the core instruction is front-loaded. It earns its place, though it is terse to the point of under-specification.

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 that executes CDP bridge commands, the description is incomplete. It lacks usage context, behavioral caveats, and parameter detail. The output schema reduces the need to document return values, but the remaining gaps are material, especially with no 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 0%, so the description must compensate. It does clarify that batch_json is a full JSON command object passed as text, but it gives no structure or example, and it entirely ignores session_id. This is only minimal compensation for a required parameter with no other 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 verb 'Run' and resource 'CDP bridge batch command' identify the basic action, and the word 'batch' loosely distinguishes it from the sibling cdp_command. However, 'CDP bridge batch command' is jargon and is not explained, so an agent cannot reliably infer what a batch command actually contains or how it differs from the single-command 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 gives no guidance on when to use this tool versus cdp_command or any other sibling. The phrase 'CDP bridge batch command' vaguely implies a batch context, but there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives.

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. While it mentions the tool calls CDP commands, it doesn't describe what happens on failure, whether it requires specific browser states, what permissions are needed, or what the response format looks like. For a tool that interacts with browser debugging protocols, this leaves significant behavioral unknowns.

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 immediately communicates the core functionality. Every word earns its place, with no redundant information or unnecessary elaboration. It's appropriately sized for a tool with this level of complexity.

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 (CDP interaction with 4 parameters), complete lack of annotations, and 0% schema coverage, the description is insufficiently complete. While an output schema exists (which helps with return values), the description doesn't provide enough context about when to use this tool, parameter meanings, or behavioral characteristics 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?

With 0% schema description coverage and 4 parameters (1 required), the description provides no parameter information beyond what's implied by the tool name. It doesn't explain what 'method' should contain (specific CDP method names), how 'params_json' should be formatted, what 'session_id' refers to, or when to use 'tab_id'. The description fails to compensate for the complete lack of 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 action ('Call a single Chrome DevTools Protocol command') and target ('on the current or specified tab'), providing a specific verb+resource combination. However, it doesn't explicitly distinguish this from sibling tools like 'cdp_batch' (which handles multiple commands) or 'execute_js' (which is JavaScript-specific rather than general CDP).

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 minimal guidance - it mentions 'current or specified tab' which gives some context about tab targeting, but offers no explicit when-to-use advice, no comparison to alternatives like 'cdp_batch' for multiple commands, and no prerequisites or limitations. The agent must infer usage from the tool name and description 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 mentions the actions but lacks critical details: it doesn't specify if this requires specific permissions, what the execution environment entails (e.g., sandboxing), potential side effects (e.g., page modifications), or error handling. For a tool that executes arbitrary code, this is a significant gap in safety and 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 concise and front-loaded, consisting of a single sentence that directly states the tool's dual capabilities. There's no wasted verbiage, and it efficiently communicates the core functions without unnecessary elaboration. However, the lack of detail limits its helpfulness despite the efficient structure.

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

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

Given the tool's complexity (executing arbitrary code with 3 parameters), no annotations, and 0% schema coverage, the description is incomplete. While an output schema exists, the description fails to address critical aspects like parameter meanings, usage scenarios, and behavioral risks. For a high-stakes tool like this, more context is needed to ensure 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 0%, so the description must compensate, but it provides no information about parameters. The three parameters ('script', 'session_id', 'no_monitor') are entirely undocumented in the description, leaving their purposes and formats ambiguous. The description doesn't explain what 'script' should contain, how 'session_id' relates to the context, or what 'no_monitor' controls.

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: executing JavaScript in a page context or sending CDP bridge commands. It specifies the action ('execute arbitrary JS', 'send JSON CDP bridge commands') and the context ('current page context', 'through the page bridge'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'cdp_command' or 'scan_page', which may 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. It mentions two capabilities but doesn't specify scenarios for choosing between executing JS or sending CDP commands, nor does it compare to siblings like 'cdp_command' for CDP interactions or 'scan_page' for page analysis. Without usage context, the agent must infer based on tool names 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 behavioral disclosure burden. It clearly implies a read-only filesystem lookup returning a path, with no side effects. It doesn't elaborate on failure modes or prerequisites, but the simple nature of the operation makes the description 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 focused sentence that front-loads the action and resource. Every word contributes: 'Get absolute path', 'unpacked Chrome extension directory', and 'for manual installation' all add necessary information without 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 zero-parameter helper that returns a filesystem path, the description is complete. An agent can correctly invoke it without further details, especially since the output format is covered by 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 tool has zero parameters and the schema is empty, so there is nothing for the description to clarify about parameters. Following the baseline guidance for zero-parameter tools, a score 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 uses a specific verb ('Get'), a precise resource ('absolute path to the unpacked Chrome extension directory'), and an explicit purpose ('for manual installation'). This clearly distinguishes it from extension-management siblings like list_extensions, set_extension_enabled, and uninstall_extension.

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 'for manual installation' gives clear context for when this tool is useful. It does not explicitly state alternatives or exclusions, but for a zero-parameter path-lookup tool the situational cue is sufficient. A 5 would require explicit when-not-to-use 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 that cookies are fetched; it does not mention whether any browser permissions are required, whether the extension bridge session needs to be active, whether the call is read-only, or what happens when no cookies exist. 'Get' implies a read operation, but key behavioral context is missing.

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. The core action and scope are front-loaded, and the mention of 'via the Chrome extension bridge' adds relevant context. It is concise, though it sacrifices some helpful 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?

For a simple getter with an output schema available, the description provides enough to understand the primary purpose. However, it lacks guidance on session_id, usage boundaries relative to cookie-modifying tools, and behavioral details. It is adequate but has clear gaps; it is not fully self-sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for tab_id by distinguishing 'current page' from 'specified tab', but it never explains session_id, which remains entirely undocumented. The description only partially clarifies the parameter space.

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 identifies a clear action ('Get') and resource ('cookies') with a specific scope: current page or specified tab. It does not explicitly contrast with sibling tools like set_cookies or delete_cookies, but the read/write distinction is inferable from the verb, so it is not misleading.

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 prefer this tool over alternatives or when not to use it. Sibling tools include set_cookies and delete_cookies, but the description never names them or explains the boundary between reading and modifying cookies. The implied usage is clear only from the verb 'get'.

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 indicates this is a read operation ('return') for diagnostic purposes, which implies it's likely non-destructive and safe. However, it lacks details on potential side effects, error conditions, or performance characteristics (e.g., rate limits), leaving gaps 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 key information ('return extension path, bridge ports, and connection status') and includes the purpose ('for setup/diagnostics'). There is no wasted text, 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 (0 parameters, no annotations, but with an output schema), the description is reasonably complete. It specifies what data is returned and the diagnostic context. However, it could benefit from more detail on output format or error handling, though the presence of an output schema mitigates this 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 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to explain parameters, so it appropriately focuses on output semantics. A baseline of 4 is applied since no parameters are present, and the description adds value by hinting at what information is returned.

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 specific verbs ('return') and resources ('extension path, bridge ports, and connection status'), and specifies the context ('for setup/diagnostics'). However, it doesn't explicitly differentiate from sibling tools like 'extension_path' or 'list_extensions' that might provide related information, preventing a perfect score.

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 ('for setup/diagnostics'), suggesting when this tool might be appropriate, but it doesn't provide explicit guidance on when to use it versus alternatives like 'extension_path' or 'list_extensions', nor does it specify exclusions or prerequisites. This leaves some ambiguity for the agent.

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 the action happens 'via the real keyboard' which suggests system-level interaction, but doesn't disclose important behavioral traits like whether this requires specific permissions, if it's synchronous/asynchronous, potential side effects on other applications, or error conditions. The description is minimal and lacks 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 that front-loads the core functionality. Every word earns its place - 'Send a hotkey chord' establishes the action, examples clarify the format, and 'via the real keyboard' provides important context about the implementation level. No wasted words or redundant 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?

Given 1 parameter with 0% schema coverage and no annotations, the description is insufficiently complete. While an output schema exists (which reduces need to describe return values), the tool performs a system-level action with potential side effects, yet the description lacks crucial information about permissions, platform compatibility, error behavior, and the scope of what 'real keyboard' means in practice.

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

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

With 0% schema description coverage (parameter 'keys_csv' has no description in schema), the description must compensate but provides minimal parameter guidance. It gives examples of format ('command,l' or 'ctrl,shift,p') which helps understand the CSV format, but doesn't explain what constitutes valid keys, modifier combinations, platform differences, or error handling for invalid input.

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 specific action ('Send a hotkey chord') and resource ('via the real keyboard'), with concrete examples ('command,l' or 'ctrl,shift,p') that make the purpose unambiguous. It distinguishes this tool from siblings like 'type_text' or 'mouse_click' by focusing on keyboard shortcuts rather than text input or mouse 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 implies usage for keyboard shortcuts but doesn't explicitly state when to use this tool versus alternatives like 'type_text' for regular text input or 'mouse_click' for mouse interactions. No guidance is provided about when not to use it or specific scenarios where it's preferred over other input 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the scope ('visible to the CDP bridge extension itself'), which adds some context about visibility constraints, but fails to describe key behaviors such as whether this is a read-only operation, what the output format includes (e.g., extension names, IDs, versions), or any rate limits. For a tool with no annotation coverage, this is insufficient.

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 that efficiently conveys the core purpose without unnecessary details. It is front-loaded with the main action and resource, making it easy for an agent to quickly understand 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 has an output schema (which should document return values), the description doesn't need to explain outputs. However, with no annotations and low schema coverage for the single parameter, the description is incomplete—it lacks usage guidelines, behavioral details, and parameter explanations. For a simple listing tool, it's minimally adequate but has clear 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 has one parameter ('session_id') with 0% description coverage, and the tool description provides no information about parameters. Since there is only one parameter and schema coverage is low, the description does not compensate by explaining its purpose (e.g., what 'session_id' refers to or when it should be used). However, with zero parameters explained in the description, the baseline is 4, but the lack of any parameter context reduces it to 3.

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

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

The description clearly states the action ('List') and resource ('Chrome extensions'), and specifies the scope ('visible to the CDP bridge extension itself'), which helps distinguish it from generic extension listing tools. However, it doesn't explicitly differentiate from sibling tools like 'list_tabs' or 'get_setup_status', which might also involve listing operations 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing the CDP bridge extension to be active, or compare it to sibling tools like 'list_tabs' for tab management. This leaves the agent without context for tool 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 carries full burden for behavioral disclosure. It states what the tool does but lacks critical details: whether this requires specific permissions, how 'connected' is defined (e.g., active vs. all tabs), what the output format includes (though an output schema exists), or any rate limits. This leaves significant gaps for a tool that interacts with browser sessions.

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 wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse, which is ideal 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?

Given the tool's low complexity (0 parameters) and the presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and behavioral gaps (e.g., missing context on 'connected' or permissions), it doesn't fully prepare the agent for real-world use, keeping it at a baseline level.

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 the schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, but it correctly doesn't mislead about inputs. A baseline of 4 is appropriate as it avoids unnecessary parameter discussion for a zero-param tool.

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 ('List') and the resource ('currently connected browser tabs/sessions'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'switch_tab' or 'open_new_tab' that also involve tab operations, which prevents a perfect score.

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 session), exclusions, or comparisons to similar tools like 'switch_tab' for tab 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'real desktop' which provides some context about the execution environment, but fails to describe important behavioral aspects like whether this is a blocking operation, what happens if coordinates are invalid, or what the output contains. For a tool that interacts with the desktop UI, 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 extremely concise at just 7 words, front-loading the core functionality with zero wasted words. Every element ('Click', 'real desktop', 'screen coordinates') contributes essential information without 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 (desktop interaction with 5 parameters), no annotations, and 0% schema coverage, the description is incomplete. However, the existence of an output schema means the description doesn't need to explain return values. The description provides the absolute minimum viable information but leaves critical gaps in parameter understanding and 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?

With 0% schema description coverage and 5 parameters, the description provides no information about any parameters. It doesn't explain what 'x' and 'y' coordinates represent, what button options exist, what 'clicks' and 'interval' control, or their default values. The description fails to compensate for the complete lack of 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 action ('Click') and target ('on the real desktop at screen coordinates'), providing a specific verb+resource combination. However, it doesn't distinguish this from sibling tools like 'mouse_drag' or 'mouse_move', which would require explicit differentiation for a perfect score.

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 'mouse_drag' or 'mouse_move'. There's no mention of prerequisites, context, or exclusions, leaving the agent to 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 mentions 'the real mouse' which implies physical movement, but fails to describe critical behaviors like whether this interrupts user control, requires specific permissions, has visual effects, or what the output contains. For a tool that manipulates hardware input, 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 that gets straight to the point with zero wasted words. It's appropriately sized for the tool's complexity and front-loads the core functionality.

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

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

For a tool with 6 parameters, 0% schema coverage, no annotations, and hardware interaction implications, the description is inadequate. While an output schema exists (which reduces the need to describe return values), the description doesn't address critical context like coordinate systems, timing behavior, or interaction effects that would help an agent use 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?

With 0% schema description coverage for all 6 parameters, the description provides no information about parameter meanings beyond what's implied by the action. It doesn't explain what x1/y1/x2/y2 represent (screen coordinates), what units duration uses (seconds implied by default 0.3), or what button options exist. The description fails to compensate for the complete lack of 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 action ('drag') and resource ('the real mouse') with specific directionality ('from one point to another'), which distinguishes it from sibling tools like mouse_click or mouse_move. However, it doesn't explicitly differentiate from potential drag-like operations in other tools, 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 like mouse_move or mouse_click, nor does it mention prerequisites or exclusions. 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 the full burden of behavioral disclosure. It mentions moving 'the real mouse cursor' which implies physical movement, but doesn't cover important aspects like whether this requires specific permissions, what happens if coordinates are out of bounds, or if there are any side effects. The description is minimal and lacks behavioral 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, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized 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?

Given that there's an output schema (which means return values are documented elsewhere), the description covers the basic action. However, for a tool that physically moves a mouse cursor with 3 parameters and no annotations, the description should provide more context about behavior and usage. It's minimally adequate but has clear 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 description mentions 'screen coordinates' which relates to the x and y parameters, but doesn't explain what these coordinates represent or the units. With 0% schema description coverage and 3 parameters (x, y, duration), the description provides only basic context without compensating for the schema's lack of descriptions. The baseline is appropriate given the 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 ('Move') and target ('the real mouse cursor to screen coordinates'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'mouse_click' or 'mouse_drag' which are related mouse operations, so it doesn't reach the highest score.

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 'mouse_click' or 'mouse_drag', nor does it mention prerequisites or context for usage. It simply states what the tool does without any 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 does not cover important traits such as whether the tool requires specific browser permissions, if it handles invalid URLs, or what happens on success/failure. 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 a single, efficient sentence that is front-loaded with the core action. It wastes no words and directly communicates the tool's function 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?

Given the tool's low complexity (one parameter) and the presence of an output schema, the description is minimally adequate. However, as a mutation tool with no annotations, it should ideally include more behavioral context, such as error handling or prerequisites, to be 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 description adds meaning by specifying that the 'url' parameter is used to open a new tab, which clarifies its purpose beyond the schema's basic type definition. With 0% schema description coverage and only one parameter, this compensation is adequate, though not exhaustive.

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 ('Open') and the resource ('a new browser tab with the given URL'), making the purpose specific and unambiguous. It distinguishes from sibling tools like 'open_url' by specifying it opens a new tab rather than navigating the current tab.

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 (opening a new tab for a URL), but does not explicitly state when to use this tool versus alternatives like 'open_url' or 'switch_tab'. It provides clear intent but lacks explicit guidance on exclusions or comparisons.

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 'real-browser JS navigation' which hints at implementation but doesn't cover critical aspects like whether navigation blocks execution, error handling, permission requirements, or side effects. For a navigation tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is a single, efficient sentence that front-loads the core functionality ('Navigate the current tab to a URL') and adds technical context ('using real-browser JS navigation') without unnecessary words. Every element serves a purpose.

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 moderate complexity (navigation with 3 parameters), no annotations, and the presence of an output schema, the description is minimally adequate. It states the core action but lacks details about parameters, error conditions, and behavioral traits that would be needed for full contextual understanding.

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 0%, so the description must compensate for undocumented parameters. It doesn't mention any parameters at all, failing to explain 'url' requirements, 'session_id' purpose, or 'timeout' behavior. However, with only 3 parameters and a clear primary action, the baseline remains at 3 despite the lack of parameter explanation.

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 ('current tab to a URL'), with specific implementation details ('using real-browser JS navigation') that distinguish it from simple URL opening. However, it doesn't explicitly differentiate from sibling tools like 'open_new_tab' or 'switch_tab', which prevents a perfect score.

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 'open_new_tab' or 'switch_tab', nor does it mention prerequisites or constraints. It states what the tool does but offers no context for selection among the many browser automation 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 provided, the description carries the full burden of behavioral disclosure. It clearly indicates this is a read-only reporting function (not a mutation), but doesn't disclose important behavioral aspects like refresh rate, coordinate system, units of measurement, or whether it requires specific permissions. The description adds basic context but lacks 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, efficient sentence that immediately communicates the tool's purpose without any unnecessary words. It's perfectly front-loaded with the core functionality and contains zero redundant information or fluff.

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

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

Given the tool's simplicity (0 parameters, no annotations, but has output schema), the description provides adequate context for understanding what information will be retrieved. The existence of an output schema means the description doesn't need to explain return values. However, for a reporting tool with no annotations, some additional behavioral context (like coordinate format or refresh behavior) would enhance 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 0 parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't waste space discussing nonexistent parameters, maintaining focus on what the tool actually does. This meets the baseline expectation 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 tool's purpose with specific verbs ('Report') and resources ('current desktop mouse position and primary screen size'). It distinguishes itself from sibling tools like mouse_click or mouse_move by focusing on information retrieval rather than action execution.

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 (when you need mouse position and screen size information) but doesn't explicitly state when to use this tool versus alternatives. No guidance is provided about prerequisites, limitations, or specific scenarios where this tool is preferred over other 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates key behaviors: it's a read operation ('Read'), it preserves authentication state, it simplifies HTML/text, and it operates on the 'current page' context. However, it doesn't mention potential limitations like rate limits, error conditions, or what 'simplified' specifically 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, well-constructed sentence that efficiently communicates the core functionality. Every word earns its place: 'Read' establishes the action, 'current page' specifies the target, 'simplified HTML/text' describes the output format, and 'preserving login state from the real browser' adds crucial behavioral context.

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

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

For a tool with 6 parameters (0% schema coverage) and no annotations, the description does an adequate job explaining the core purpose and key behavior. However, it completely ignores parameter semantics, and while an output schema exists, the description doesn't hint at return format or structure. The presence of many sibling tools suggests this operates in a browser automation context that could use more explicit positioning.

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

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

With 0% schema description coverage for 6 parameters, the description provides no information about any parameters. It doesn't mention session_id for session management, text_only for format control, cutlist for content filtering, maxchars for output limits, instruction for processing guidance, or extra_js for JavaScript injection. The description fails to compensate for the complete lack of 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 verb ('Read'), resource ('current page'), and key behavioral characteristics ('simplified HTML/text', 'preserving login state from the real browser'). It distinguishes itself from screenshot siblings like capture_page_screenshot by focusing on content extraction rather than visual capture.

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 (when you need to extract page content while maintaining authentication state), but doesn't explicitly state when to use this versus alternatives like execute_js for JavaScript execution or get_cookies for cookie management. No specific exclusions or prerequisites 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?

No annotations are provided, so the description carries full burden. It mentions the action ('Set the active browser tab') but lacks details on behavior: e.g., what happens if multiple tabs match the URL substring, whether it fails if no match is found, if it requires specific browser state, or what the output includes. This is a mutation tool with zero annotation coverage, leaving significant gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Set the active browser tab') and specifies the input criteria. There is no wasted verbiage, making it highly concise and well-structured for quick understanding.

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 2 parameters with 0% schema coverage, no annotations, and an output schema (which handles return values), the description is moderately complete. It covers the basic purpose but lacks behavioral details (e.g., error handling, matching logic) and parameter semantics, leaving room for improvement despite the output schema mitigating some gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions parameters ('session id or URL substring') but doesn't explain their semantics: e.g., what a session_id is, how URL substring matching works (case-sensitive, partial match), or that at least one parameter should be provided. With 2 parameters and no schema descriptions, this adds minimal value beyond naming them.

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 the active browser tab') and the target resource ('browser tab'), with specific criteria ('by session id or URL substring'). It distinguishes from siblings like 'list_tabs' (which lists tabs) and 'open_new_tab' (which creates new tabs), but doesn't explicitly contrast with 'open_url' (which might also activate tabs).

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 needing to switch tabs based on session_id or url_pattern, but doesn't specify when to choose this over alternatives like 'open_url' (which might open and activate a URL) or 'list_tabs' (for tab discovery). No explicit when-not-to-use or prerequisite guidance is 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the optional click behavior but lacks critical details: whether this simulates real keyboard events (vs. programmatic text insertion), what 'real keyboard' means in automation context, whether it respects focus/selection, what happens with special characters, or any rate limits. The description provides minimal behavioral context beyond the basic 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 perfectly concise at 10 words, front-loading the core functionality ('Type text via the real keyboard') followed by the optional enhancement ('optionally after clicking a field'). Every word earns its place with zero redundancy or 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?

Given this is an automation tool with 4 parameters, 0% schema coverage, no annotations, but with an output schema, the description is insufficiently complete. It doesn't explain the automation context, what 'real keyboard' means technically, coordinate systems for clicking, or typing behavior details. While the output schema may document return values, the description lacks critical context for proper tool selection and invocation.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. The description mentions 'optionally after clicking a field' which hints at the click_x/click_y parameters, but doesn't explain what 'interval' controls (typing speed/delay) or provide context about coordinate systems. With 4 parameters and 0% schema coverage, the description adds only marginal semantic value beyond what parameter names suggest.

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: 'Type text via the real keyboard, optionally after clicking a field.' This specifies the verb ('type') and resource ('text'), and distinguishes it from keyboard shortcut tools like 'hotkey'. However, it doesn't explicitly differentiate from text-input alternatives like 'execute_js' for web page text entry.

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 with 'optionally after clicking a field', suggesting this tool is for text input in UI contexts. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'execute_js' for web page text manipulation or 'cdp_command' for browser automation. No exclusion criteria or prerequisites are mentioned.

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