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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds that it specifically clears text in input/textarea elements, matching the destructive hint. However, it doesn't disclose behavioral details such as whether clearing triggers input events, requires focus, or what happens if the target isn't an input/textarea.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It efficiently conveys the action and target element type, earning a full score for conciseness and structure.

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

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

For a simple one-parameter mutation tool with annotations and no output schema, the description covers the core behavior. However, it lacks any note about return values, behavior on invalid targets, or whether events are triggered, leaving a minor gap in completeness.

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

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

The input schema provides full coverage for the single 'target' parameter, describing it as 'Input element reference (snapshot ID) or CSS selector.' The tool description adds no extra parameter semantics, but since schema coverage is 100%, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Clears the text in an input or textarea element.' It uses a specific verb ('clears') and names the resource ('input or textarea element'), which distinguishes it from sibling tools like browser_type that enter text into 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 explicit guidance on when to use this tool versus alternatives. It implies usage for clearing input/textarea content but doesn't mention exclusions or direct the agent to alternative tools for related actions, such as selecting all or deleting text via keyboard.

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?

Annotations indicate destructiveHint=true and readOnlyHint=false, but the description adds no behavioral context such as potential side effects (navigation, event triggering) or permission requirements. It simply repeats the action without enriching the safety profile provided by annotations.

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

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

The description is under-specified rather than concise. A single sentence with no useful detail does not earn its place; it fails to convey the tool's purpose beyond the name.

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 and no output schema, the description is extremely sparse. It does not mention return values, side effects, or how the target is resolved, leaving significant gaps that the schema cannot fully cover.

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 (target, button, modifiers, etc.). The description adds no additional parameter meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description 'Perform click on a web page' essentially restates the tool name 'browser_click' and adds only the obvious 'web page' context. It does not specify what element is clicked, how the click is performed, or distinguish it from sibling tools like browser_mouse_move_click or browser_dispatch_event.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention prerequisites, typical scenarios, or exclusions for when this tool should not be used (e.g., for coordinate-based clicks).

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?

Beyond the annotations (destructiveHint=true, readOnlyHint=false), the description adds no additional behavioral context such as whether unsaved changes are lost, whether the browser process ends, or how the page state is affected. It is essentially a restatement of the tool name.

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

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

The description is a single short phrase, 'Close the page,' which is highly concise and front-loaded. Every word contributes meaning with no extraneous content.

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

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

Given the tool's simplicity—no parameters, no output schema, and destructive annotations—the description is sufficient for basic use. However, it leaves ambiguous whether 'page' means the current tab or the entire browser, and it does not state any recovery options, but the annotations cover the destructive nature.

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

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

With zero parameters and 100% schema coverage (empty properties object), the description is not required to explain parameter semantics. The baseline of 4 applies, and the description does not introduce any ambiguity.

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

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

The description 'Close the page' uses a specific verb and resource, clearly indicating the action of closing the current browser page. This distinguishes it from sibling tools like browser_navigate or browser_tabs, as no other close action exists.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or situations where closing the page is appropriate.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds no additional behavioral context beyond the basic return action, such as the effect of the 'all' parameter or the filename-save behavior, though these are covered in the schema.

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

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

The description is a single sentence with no filler or repetition. It is appropriately sized for a simple tool and front-loads the core 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?

The tool has full schema coverage and annotations, but the description omits behavioral nuances like the filename-save option and the meaning of 'all' (unless gleaned from the schema). Given the absence of an output schema, a slightly richer description would improve completeness, but the current state is adequate.

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 each parameter having a clear description, so the schema fully documents the parameters. The main description adds no extra parameter semantics, so a baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Returns' with the clear resource 'all console messages', making the tool's function immediately understandable. However, it does not explicitly differentiate from sibling tools like browser_network_requests or browser_evaluate, which could also return browser data.

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 information is provided about when to use this tool versus alternatives. The description does not mention any exclusions, prerequisites, or competing tools, leaving the agent without guidance on tool selection.

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

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

Annotations already flag the operation as not read-only and destructive (readOnlyHint=false, destructiveHint=true). The description adds only that it dispatches a 'custom event' with optional initialization, but does not warn about potential side effects or that dispatching arbitrary events may not trigger framework-specific handlers. It does not contradict the annotations.

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

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

The description is a single sentence, immediately verb-first, with no filler. Every word contributes to the core meaning.

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

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

The tool has no output schema and minimal annotations; the description leaves out crucial context such as what happens when the event is dispatched, whether the return value indicates success, and when to use this instead of browser_click or browser_type. The openWorldHint and destructiveHint suggest potential side effects, but the description does not elaborate, leaving gaps for an agent deciding if this is appropriate.

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

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

The input schema already describes all three parameters with 100% coverage. The description's phrase 'custom initialization parameters' adds negligible meaning over the schema's 'Optional event initialization options,' and 'target element' mirrors the schema's 'target' description.

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 the specific verb 'dispatches' and identifies the resource as a 'custom event' on a 'target element,' making its function clear. It distinguishes from sibling interaction tools like browser_click or browser_type by focusing on arbitrary custom events.

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

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

The description provides no guidance on when to use this tool versus using higher-level interaction tools like browser_click or browser_type. There is no mention of use cases, exclusions, or when to prefer 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?

Annotations already indicate readOnlyHint=false and destructiveHint=true, so the agent knows it is a mutating action. The description adds no additional behavioral context such as side effects, event triggering, element visibility requirements, or that it simulates user interaction. It provides no value beyond the annotations.

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

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

The description is a single, precise sentence with no fluff. It is perfectly concise and front-loaded, containing only the essential information. Every word earns its place, making it an example of efficient writing.

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?

While the tool is simple and the schema fully documents parameters, the description lacks any further context about return values (none are specified) or the implications of a destructive action beyond the annotation. It is minimally adequate but misses opportunities to explain the drag-and-drop behavior, such as the order of events or that the element references must correspond to snapshot entries.

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 has 100% parameter coverage, with each parameter having a descriptive comment. The description adds no extra meaning beyond the schema; it merely restates that the tool operates between two elements, which is already implied by the parameter descriptions. Baseline of 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 states the action clearly: 'Perform drag and drop between two elements'. It identifies a specific verb and resource, and implies the two key parameters. However, it does not distinguish this tool from the sibling 'browser_drop', which could also involve a drop action, reducing 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 instead of alternatives, no prerequisites, and no context about appropriate scenarios. It simply states what it does without any usage direction or mention of alternative tools.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description doesn't need to repeat safety information. It adds the 'as if dragged from outside the page' behavioral context and the constraint that paths/data must be provided, which is useful but not extensive.

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

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

The description is two sentences, front-loaded with the core purpose, and contains no redundant wording. Every clause 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?

With four parameters, no output schema, and annotations providing safety hints, the description covers the operation's purpose and key constraints. It doesn't describe return values, but that's not required for a drop action and the schema fills in parameter details.

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

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

Schema coverage is 100%, so all four parameters have descriptions. The description adds an explicit constraint that at least one of paths or data must be provided, which is not enforced by the schema (which only requires target). This adds meaningful semantic value.

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

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

The description clearly states the tool drops files or MIME-typed data onto an element, simulating an external drag-and-drop. This distinguishes it from sibling tools like browser_file_upload or browser_drag by specifying the 'outside the page' source and the drop target.

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 'as if dragged from outside the page' provides clear context for when to use this tool, but it does not explicitly mention when not to use it or point to alternatives. This is clear context without exclusions, so it earns a 4.

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

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

The description only says 'emulates' without clarifying whether the emulation is temporary, persistent, or how it interacts with existing browser state. Although annotations include destructiveHint=true, the description adds no additional behavioral context beyond what the annotations already indicate, so the agent receives minimal extra insight.

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

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

The description is a single concise sentence with no filler, clearly front-loading the main action. It covers both parameters without unnecessary detail, earning a perfect score for brevity and 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 simplicity, the complete schema, and the presence of annotations, the description is largely sufficient. It could benefit from a note about resetting emulation (e.g., using 'null' or 'no-preference'), but the schema already exposes those enum values, so the description is adequately complete for a straightforward tool.

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

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

The schema provides 100% coverage with descriptions for both parameters, including enums. The description maps directly to these enums (light/dark, screen/print), but does not add significant new meaning beyond what the schema already documents, so a baseline score of 3 is appropriate.

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

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

The description clearly states the tool emulates light/dark color schemes and media type queries (screen vs. print), using a specific verb and resource. This distinguishes it from other browser tools like resize or navigate, and matches the tool name and title.

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 testing responsive design or print styles, but does not provide explicit when-to-use or when-not-to-use guidance. There are no alternatives mentioned, so the context is only implicit from the action itself.

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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true, so the agent is aware of the destructive nature. However, the description adds no extra behavioral context—it does not explain the risks, side effects, or the level of access the JavaScript execution has. Minimal additional value beyond annotations.

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

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

The description is a single, front-loaded sentence with no redundant words. It efficiently communicates the core purpose without wasted 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?

For a tool that executes arbitrary JavaScript (destructive, open-world), the description is too sparse. It does not mention return value behavior, potential page mutations, or any safety caveats. With no output schema and a sensitive sibling (browser_run_code_unsafe), more context is needed to guide correct use.

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

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

The input schema describes all four parameters with 100% coverage, including the 'function' signature and 'target'/'element' usage. The description adds no further parameter meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Evaluate') and identifies the resource ('JavaScript expression') and scope ('on page or element'). It is clear and distinguishes its core function, though it does not explicitly differentiate from the sibling tool 'browser_run_code_unsafe'.

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

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

No guidance is provided on when to use this tool versus alternatives, such as when to prefer browser_run_code_unsafe or other browser interaction tools. The description lacks usage context or exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds that the output is a structured JSON array, providing useful context about the return format. However, it does not disclose potential edge cases (e.g., behavior when no table is found, handling of multiple tables, or nested tables), leaving some transparency 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 concise sentence that immediately conveys the action and output. It contains no redundant words or filler, and the most important information is front-loaded.

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

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

For a simple read-only tool with one parameter and good annotations, the description is adequate but minimal. It lacks details on which table is extracted (first table, all tables, table matching a selector) and the exact structure of the JSON array. Notably, there is no output schema, so the description could have provided more detail on the return format.

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

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

The input schema already includes a fully descriptive entry for the single 'target' parameter ('Target table reference (snapshot ID) or CSS selector.'), so schema coverage is 100%. The tool description does not add any additional parameter semantics, so it stays at the baseline of 3.

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

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

The description clearly states what the tool does: 'Extracts tabular HTML table data into a structured JSON array.' It uses a specific verb ('Extracts'), names the resource ('tabular HTML table data'), and specifies the output format. This distinguishes it from sibling tools like browser_get_html or browser_snapshot, which provide raw HTML or page snapshots, not structured table extraction.

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

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

The description offers no guidance on when to use this tool versus alternatives. It does not mention that other browser tools like browser_evaluate or browser_get_html could serve similar purposes, nor does it state specific scenarios where extracting a table is preferred. This lacks explicit 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?

Annotations indicate destructiveHint=true and readOnlyHint=false, but the description adds no behavioral context beyond the basic action. It fails to mention that this likely involves a file chooser, that omitting 'paths' cancels the chooser (as noted in the schema), or what destructive implications might arise. No value is added beyond annotations.

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

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

The description is a single, tight sentence with no filler words. It conveys the core purpose immediately and is appropriately concise for the tool's simplicity.

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

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

Despite the schema being detailed, the description alone is insufficient for an agent to understand the tool's role within the broader browser tool set. It does not explain the difference between this upload method and 'browser_upload_file_direct', nor does it mention the interactive file-chooser behavior that is central to using this tool effectively. The lack of a return-value description is acceptable given no output schema, but the tool selection guidance is incomplete.

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

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

Schema coverage is 100%, and the schema already describes the 'paths' array, including the behavior when omitted. The description's 'one or multiple files' slightly reinforces the array semantics but does not add substantial new meaning 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 'Upload one or multiple files' clearly identifies the action (upload) and the resource (files), and it adds the scope of multiple files. However, it does not distinguish this tool from its sibling 'browser_upload_file_direct', which likely serves a similar purpose via a different mechanism.

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_upload_file_direct' or other browser interaction tools. There is no mention of prerequisites, conditions, or exclusions, leaving the agent to guess the appropriate 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, indicating a mutating operation. The description adds no further behavioral context, such as the need for exact element references, potential permission prompts, or how it handles unsupported field types. It simply restates the title's implication.

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

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

The description is a single, front-loaded sentence with no wasted words. However, it could be more informative without losing conciseness, so not a perfect 5.

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

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

This is a mutating batch operation on forms with varied field types. The description does not mention return behavior, error conditions, or prerequisites like obtaining element references, and there is no output schema. It is minimally adequate but incomplete for the tool's complexity.

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

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

Schema coverage is 100% with descriptions for target, name, type, value, and element. The description adds no parameter-level detail beyond the schema, so the baseline of 3 applies.

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

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

The description uses the specific verb 'fill' and the resource 'multiple form fields', clearly indicating a batch filling operation. It distinguishes from siblings like browser_type or browser_toggle_checkbox by implying a composite action, though it does not explicitly name those alternatives.

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

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

No explicit when-to-use guidance is provided. The phrase 'Fill multiple form fields' implies usage for batch filling, but it does not mention when to use single-field tools like browser_type or select_option instead, nor when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds behavioral context: it returns matching nodes with surrounding context and paths, and notes efficiency. It does not contradict annotations and provides value beyond them.

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

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

The description is two sentences, front-loaded with the core purpose, then efficiently adds return format and efficiency context. No redundant words 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?

For a find tool with rich schema and annotations, the description covers the return behavior (matching nodes with surrounding context and paths) and efficiency rationale. It lacks exact output schema details, but that is not required given the high-quality input schema and annotations.

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

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

Schema description coverage is 100%, with each parameter (text, regex) having detailed descriptions including case-insensitivity and flags. The tool description adds no per-parameter meaning beyond what the schema already provides, so a baseline score is appropriate.

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

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

The description clearly states the tool searches the accessibility snapshot of the current page for text or a regular expression, using a specific verb and resource. It also distinguishes from siblings by noting it is cheaper than capturing the whole snapshot when only locating an element and its ref.

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

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

The description provides a clear usage context: use when you need to locate an element and its ref in the snapshot, implying an alternative to full snapshot capture. However, it does not explicitly name alternative tools or state when not to use it, but the context is sufficient.

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 annotations declaring destructiveHint=true, the description should disclose side effects or state changes, but it only says 'focuses' without elaboration. It adds no behavioral context beyond the minimal verb, leaving the agent unaware of potential impacts.

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

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

The description is a single concise sentence, which is efficient and easy to parse. However, it is so brief that it sacrifices informational depth, though for a simple tool with one parameter this brevity is acceptable.

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 a single parameter and no output schema, the description is incomplete regarding side effects (focus can change page state), return behavior, or use cases. The destructiveHint annotation signals this is not a pure read operation, so more context is needed to use the tool safely.

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

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

The schema fully documents the 'target' parameter (100% coverage), so the description's 'target element' adds little new meaning. It doesn't explain selector syntax or snapshot ID usage beyond what the schema already provides, but it does reinforce the parameter's role.

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 ('focuses') and identifies the resource ('target element'), clearly stating the tool's function. It lacks explicit differentiation from sibling tools like browser_click or browser_hover, but the action is distinct enough to be understood.

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 focus versus alternatives such as browser_click or browser_hover, and there are no exclusions, prerequisites, or context hints. The user is left to infer appropriate use cases.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the return format ('key-value dictionary') and scope ('all attributes'), but it does not disclose behavior for missing elements or whether it waits for the element.

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

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

The description is a single, front-loaded sentence with no redundant wording. It conveys the essential information efficiently.

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

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

Given the low complexity (one parameter, read-only, good annotations), the description is largely complete. It could mention empty-result behavior or error handling, but that is a minor gap. The lack of usage guidance is a slight omission.

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

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

Schema coverage is 100%: the single 'target' parameter is described as 'Target element reference (snapshot ID) or CSS selector.' The description adds no further parameter semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Returns'), the resource ('all attributes of an HTML element'), and the output format ('key-value dictionary'). This specificity distinguishes it from sibling tools like browser_get_html or browser_get_element_state.

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 use when element attributes are needed, but it does not explicitly state when to prefer this over alternatives like browser_get_element_state, nor does it mention any exclusions or prerequisites. Guidance is only implicit.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by naming the specific states checked, but it does not disclose the return format, behavior for missing elements, or any other side effects beyond what annotations already convey.

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

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

The description is a single sentence that front-loads the action and lists the relevant states without any redundant words. Every token contributes to the meaning, making it an exemplary concise 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 simple getter with one parameter and clear read-only annotations, the description covers the core purpose and the set of states. However, given there is no output schema, it would be helpful to mention what the tool returns (e.g., booleans for each state or a single state). The lack of return-value detail is a minor gap, but the simplicity of the tool keeps the description largely complete.

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

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

The schema provides a complete description for the only parameter 'target' as 'Selector or snapshot ID of the element to check.' The description does not add any additional meaning to the parameter, so it relies entirely on the schema's already high 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 uses a specific verb 'Checks' and clearly specifies the resource ('element') while enumerating the exact states it can report: visible, enabled, editable, checked, or focused. This makes the tool's function unambiguous and distinguishes it from sibling tools like browser_get_attributes or browser_get_html.

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

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

The description implies usage by listing the states one can verify, but it does not explicitly state when to use this tool instead of alternatives, nor does it provide any exclusions or prerequisites. The intended use case is inferable but not clearly articulated.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that omitting the target returns the entire page, which is useful context. However, it does not disclose return format or edge-case behavior, so it earns a mid-range 3.

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

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

The description is a single sentence that immediately states the action and object, with no unnecessary words. Every word earns its place by covering the core behavior and the default case.

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

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

For a simple read-only tool with one fully described parameter and annotations indicating safety, the description is complete. It states what is returned and the two modes (element or page), so no further details are necessary for an agent to invoke it correctly.

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

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

The schema has 100% coverage for the single parameter, and the property description is identical to the tool description. The description adds no additional meaning beyond what the schema already provides, so a baseline 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 uses a specific verb 'Returns' and identifies the resource as 'raw HTML', with clear scope: a target element or the entire page. This differentiates it from sibling tools like browser_get_attributes and browser_get_links, which fetch different data.

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

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

The description clearly indicates when to use the tool (to retrieve raw HTML of an element or page) and the optionality of the target. It does not explicitly mention when not to use it or name alternatives, so it misses the 'exclusions' criterion for a 5.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so safety is clear. The description adds the scope 'all links from the current page,' but does not elaborate on return format or edge cases like absent links. This is acceptable given annotations, but minimal.

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

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

A single sentence with no filler. Every word carries meaning, specifying both the operation and the scope.

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

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

The tool is simple with no parameters and clear annotations. The description adequately states what the tool does, although it leaves the exact return format unspecified. Given the tool's low complexity, this is sufficient.

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

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

The input schema has zero parameters, and the description appropriately requires none. Since there are no parameters to describe, the baseline of 4 applies.

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

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

The description uses a specific verb 'extracts' and a clear resource 'all links from the current page.' This distinguishes it from sibling tools like browser_get_html or browser_get_attributes, which extract other types of 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 implies its use when the agent needs to collect hyperlinks from the currently loaded page, but it does not explicitly mention when to prefer this over alternatives like browser_get_html or browser_snapshot. No exclusions or comparisons are provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds a clear list of retrieved fields, which is useful, but it does not disclose any additional behavioral traits such as whether it waits for page load or returns null for missing fields. Since annotations cover the key safety aspects, a score of 3 is appropriate.

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

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

A single, well-structured sentence that front-loads the action (Retrieves) and then lists specific items. No fluff, no repetition of the tool name or annotations. 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?

Since there is no output schema, the description must convey what is returned. It successfully lists the key fields (URL, title, frames, tabs count, viewport, agent info). The phrase 'including' suggests the list is not exhaustive, and it does not explain the shape of frames data or other nuances, but for a simple read-only tool this is reasonably complete.

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

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

The tool has zero parameters, and the schema is empty (coverage 100%). Per the rubric, 0 params gives a baseline of 4. The description adds no parameter info because there are none to explain, but it does clarify the output contents, which is helpful for interpretation.

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 starts with the specific verb 'Retrieves' and names the resource 'detailed page metadata', then enumerates the exact data types (URL, title, frames, tabs count, viewport, agent information). This clearly distinguishes it from sibling tools like browser_get_html (which returns HTML) and browser_snapshot (which returns accessibility snapshot).

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

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

The description implies the use case: when the agent needs page-level metadata, this is the tool. However, it does not explicitly state when to use it versus alternatives or mention exclusions. With many sibling tools covering similar data (e.g., browser_get_links, browser_get_attributes), more explicit guidance would be better.

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?

Annotations indicate destructiveHint=true and readOnlyHint=false, but the description contributes no additional behavioral context. It does not explain side effects (e.g., what happens when accepting vs. dismissing, whether it unblocks the page, or the impact of promptText). The description merely repeats the concept of 'handling' without disclosing consequences.

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

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

The description is concise in word count (one short sentence) but is under-specified. It earns no place because it adds no information beyond the tool name. True conciseness requires conveying necessary details efficiently; this fails by not conveying anything useful.

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

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

The description omits critical context: it does not mention that this applies to JavaScript dialogs, that a dialog may block further browser actions, or that it requires user interaction via accept/promptText. With no output schema, the description should clarify success/failure conditions, but it does not. It is insufficient for an agent to understand the full scope of the tool.

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

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

Schema description coverage is 100%, so parameters are already well-documented: 'accept' and 'promptText' have clear descriptions. The tool description adds no extra meaning beyond the schema, which meets the baseline for high coverage. No enhancement needed.

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

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

The description 'Handle a dialog' is a direct restatement of the tool name 'browser_handle_dialog', providing no specifics about what 'handle' means (accept/dismiss). It fails to distinguish from sibling tools like browser_handle_download or browser_dismiss_dialog (if it existed). The verb 'handle' is vague and the resource 'dialog' is only slightly more specific than the 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?

No guidance is given on when to use this tool, such as 'Use when a JavaScript dialog (alert/confirm/prompt) appears' or 'Only needed when a dialog blocks interaction'. There is no mention of alternatives or prerequisites. The description simply states the action without contextual triggers.

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?

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds context about intercepting the download event and saving to workspace, which is useful. However, it does not disclose specifics like overwrite behavior, file naming conflicts, permissions, or what happens if the download fails, so it only partially adds value beyond annotations.

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

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

The description is a single sentence, front-loaded with the main action ('Clicks'), and contains no filler. Every word adds meaning, 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?

With only two parameters and no output schema, the description covers the core action but omits important details such as the return value (e.g., saved file path), potential destructive side effects (e.g., overwriting files), and where exactly in the workspace the file is saved. Given the tool's simplicity, it is minimally complete but has 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%, with clear descriptions for both 'target' (selector or snapshot ID) and 'filename' (optional custom name). The tool description does not add additional parameter meaning beyond what the schema already provides, aligning with the baseline of 3.

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

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

The description uses a specific verb ('Clicks') and identifies the resource (element triggering download) and the outcome (intercepts download event, saves file to workspace). It clearly distinguishes from sibling tools like browser_click (just clicks) and browser_file_upload (uploads), making its purpose unambiguous.

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

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

The description implies the tool is intended for clicking elements that trigger downloads and saving the resulting file, but it does not explicitly state when to use it over alternatives (e.g., browser_click) or mention exclusions. The context is clear enough for an experienced agent, but no explicit 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?

The annotations indicate readOnlyHint=false and destructiveHint=true, which suggest the tool may have side effects, but the description provides no behavioral context beyond the simple action of hovering. It does not explain what happens on hover (e.g., triggering tooltips, menus, or state changes), nor does it address the potentially destructive nature implied by the annotations. The description adds no value beyond the structured data.

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

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

The description is a single, front-loaded sentence with no filler words. It is efficient and easy to read, fitting the simplicity of the tool. However, it is perhaps too terse, omitting usage context that could be included without much cost.

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 lack of an output schema and the presence of a destructiveHint, the description is too sparse to be fully useful. It does not explain what the tool returns, how it integrates with page snapshots, or how the permission mechanism works. The context signals show a parameter count of 2 and no output schema, so the description must carry more explanatory weight, but it only provides a minimal action statement.

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 both 'target' and 'element' having clear definitions. The description does not add any additional meaning to the parameters, but it doesn't need to since the schema already provides sufficient detail. Baseline 3 is appropriate because the schema carries the semantic weight.

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

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

The description 'Hover over element on page' clearly states the action (hover) and the target (element on page). It is specific enough to distinguish from siblings like browser_click or browser_mouse_move_click, though it does not explicitly call out the differences. The verb is precise and the resource is clear.

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

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

There is no guidance on when to use this tool versus alternatives such as browser_mouse_move_click or browser_click. The description only states what the tool does, not the context in which it should be chosen, nor any exclusions or prerequisites. This leaves the agent to infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, but the description adds no further behavioral context. It does not explain why the action is destructive, whether events are trusted, or what side effects might occur, so it fails to build on the annotation baseline.

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 is front-loaded and free of filler. Every word contributes to the meaning, 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?

For a simple 2-parameter tool with complete schema and some annotation coverage, the description is adequate but has gaps: it does not explain return values, behavioral effects, or when to prefer this over sibling tools. It is minimally complete but could be improved with usage context.

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

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

The input schema provides 100% coverage with clear descriptions for both parameters (key and action). The tool description adds no additional meaning beyond what the schema already documents, so the baseline of 3 is appropriate.

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

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

The description clearly states it fires a keydown or keyup event for custom key combinations or modifier actions, using a specific verb+resource. It differentiates from siblings like browser_press_key (full press) and browser_type (typing) by focusing on separate keydown/keyup events.

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

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

The description implies usage for custom key combinations or modifier actions but does not explicitly state when to use this tool versus alternatives like browser_press_key or browser_dispatch_event. No exclusions or preference guidance are provided.

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

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

The annotations already signal destructive behavior (destructiveHint=true), so the description needed to add context beyond that. It does not specify that 'clear' clears all storage (since key is not required for clear), nor does it mention that 'set' overwrites existing values. The description merely restates the action enum from the schema without adding new safety or semantic 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, focused sentence that front-loads the core purpose. Every word contributes to meaning, with no filler or redundancy. It is appropriately minimal for the tool's 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?

The schema and annotations cover parameters and safety, but the description does not clarify edge behaviors such as clearing the entire storage when no key is provided, or what the 'get' action returns. It is adequate for a simple tool but leaves these contextual gaps for the agent to infer.

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

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

Schema description coverage is 100%, so the schema fully documents each parameter (action, storageType, key, value). The description adds no additional meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description clearly states the tool's function: 'Inspects, sets, or clears values in local/session storage.' The verb+resource structure is specific and unambiguous, and it distinguishes this tool from sibling browser tools that handle navigation, clicks, or DOM interaction.

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?

Although no explicit alternatives are mentioned, the description clearly implies usage: it is the only tool for interacting with local/session storage among the siblings. The scope is unambiguous, so an agent can infer when to call it. It lacks explicit 'use this tool when...', but the uniqueness of its resource provides clear 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?

Annotations already declare destructiveHint=true, so the description does not need to restate that. It adds the notion of intercepting and mocking/blocking, which is essentially the core behavior, but it does not disclose details such as whether mocks persist across navigation, how to later remove a route, or side effects on page behavior. This is minimal extra context beyond annotations.

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

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

The description is a single sentence that front-loads the main action and immediately gives concrete examples. There is no wasted or redundant wording; every phrase adds value.

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

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

With 4 parameters, no output schema, and a destructive action, the description is reasonably helpful but incomplete. It does not explain the lifecycle of a mock route, whether the interception applies to all requests, or what the return value looks like. The schema covers parameter details, but broader behavioral context is missing.

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

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

Schema coverage is 100%, with all parameters described. The description adds example URL patterns (images/ads) but does not provide additional meaning beyond the schema's own descriptions, so it meets but does not exceed the baseline for well-covered schemas.

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 ('intercepts and mocks/blocks') and clearly identifies the resource (network requests matching a URL pattern). It distinguishes from sibling tools by focusing on modifying/blocking rather than observing network activity, and includes concrete examples.

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 clear context (intercepting network requests for blocking or mocking) and gives examples of typical use cases. However, it does not explicitly mention when not to use this tool or suggest alternatives like browser_network_requests, so it stops short of a 5.

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

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

The description adds little beyond the annotations. It states the tool moves and clicks but does not disclose that clicking is optional (despite the schema default), nor does it describe the coordinate system, potential side effects, or event behavior. The destructiveHint annotation is present, but the description does not elaborate on what destructive consequences might occur.

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

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

The description is a single sentence with no filler, making it highly concise and front-loaded. While it lacks depth, it is appropriately brief for a simple tool, though a bit more context could be added without hurting conciseness.

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

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

Given the existence of sibling tools like browser_click and browser_hover, the description does not provide enough context to distinguish when this tool is the right choice. It omits the optional nature of clicking, the coordinate reference frame, and return behavior, making it under-specified for reliable selection.

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

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

The input schema provides 100% coverage of parameter descriptions, including x, y, click, and button. The description merely adds 'target coordinates' without providing extra meaning or clarifying edge cases, so it meets the baseline but adds little value.

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

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

The description clearly identifies the tool as controlling fine mouse movement to specific coordinates and potentially clicking there. It distinguishes itself from browser_hover and browser_click by emphasizing coordinate-based movement, though it doesn't explicitly state that the click is optional, which could cause minor 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?

No guidance is provided on when to use this tool versus alternatives like browser_click or browser_hover. The description does not include any context about suitable scenarios, prerequisites, or exclusions.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=true, signaling this is a state-changing action. The description adds minimal additional behavioral context, but the simple act of navigation is sufficiently clear; it does not contradict annotations.

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

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

The description is a single, short sentence that directly states the purpose with no unnecessary words. It is well-structured and front-loaded.

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

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

Given the tool's simplicity, one parameter, and existing annotations that cover safety and side effects, the description is adequately complete. No output schema is needed for this navigation action.

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

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

The input schema covers the url parameter with a clear description ('The URL to navigate to'), providing 100% coverage. The tool description adds no extra parameter information, but the schema is sufficient.

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

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

The description 'Navigate to a URL' uses a specific verb and resource, clearly indicating the action of changing the current page to a new URL. It distinguishes from siblings like browser_navigate_back by focusing on direct URL navigation.

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

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

There is no guidance on when to use this tool versus alternatives like browser_navigate_back or browser_click. The description only states what it does without specifying appropriate contexts or limitations.

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

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

The description adds no behavioral context beyond the annotations. While annotations indicate destructiveHint=true, the description does not mention potential side effects like losing form input or that it may be a no-op if no history exists.

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

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

The description is a single concise sentence that is front-loaded and contains no filler. It fully states the purpose 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 tool's simplicity, lack of parameters, and presence of annotations, the description is largely complete. However, it omits any caveats about history availability or side effects, which would make it more robust.

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

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

The tool has zero parameters, so the description is not required to explain parameter meanings. Baseline for zero-parameter tools is 4, and the description appropriately focuses on the action itself.

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 'Go back to the previous page in the history' clearly states the tool's function with a specific verb and resource. It distinguishes itself from siblings like browser_navigate by focusing on history navigation.

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

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

The description provides no guidance on when to use this tool versus alternatives such as browser_navigate or browser_tabs. It does not mention prerequisites, fallback behavior, or scenarios where this tool is preferred.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is known. The description adds that it returns full details or a specific part, but does not disclose any other behavioral traits such as output size, permissions, or side effects. With annotations providing the safety profile, this is adequate but not rich.

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

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

Two sentences, no fluff. The primary purpose is front-loaded, and the reference to the sibling tool is concise. 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?

No output schema exists, so the description must explain return value expectations. It mentions headers and body and introduces the 'part' option, covering the core. The filename parameter is not mentioned, but the schema handles that, so the description remains sufficient for a single-request detail tool.

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

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

Schema coverage is 100% with descriptions for all three parameters, so the baseline is 3. The description adds valuable context for the 'index' parameter by explaining that it comes from browser_network_requests, which goes beyond the schema's generic '1-based index' description. This extra guidance justifies a 4.

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

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

The description clearly states the tool returns full details (headers and body) of a single network request, with an optional part selector. It distinguishes itself from the related browser_network_requests tool by indicating this is the detail lookup for an item in that list.

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

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

The description explicitly says 'Use the number from browser_network_requests', providing direct guidance on how to obtain the required index and implying the workflow of first listing requests via the sibling tool. This is clear and actionable, though it doesn't explicitly state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, covering safety. The description adds the 'since loading the page' scope and the numbered-list behavior, which are not in annotations. It does not mention the file-saving side effect implied by the 'filename' parameter, but that is captured in the schema, so the description remains consistent and adds useful 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?

Two concise sentences, front-loaded with the core purpose and immediate follow-up. No filler, redundant, or misleading wording.

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

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

The tool is a simple list operation with no output schema. The description clearly states what is returned (numbered list of network requests) and how to proceed (use browser_network_request with the number). Combined with schema descriptions for parameters and annotations for safety, the tool description is fully sufficient for correct invocation and interpretation.

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

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

Schema description coverage is 100%, so all three parameters (filter, static, filename) are already well-described. The description adds no new parameter-level detail beyond implying that the output is a numbered list usable with browser_network_request. This is baseline value given 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 states a specific verb ('Returns') and resource ('numbered list of network requests since loading the page'), clearly distinguishing this list-oriented tool from the sibling browser_network_request which fetches details. It immediately tells the agent what to expect.

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

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

The description explicitly points to browser_network_request as the follow-up for full details, giving an alternative and usage context. It does not mention when *not* to use this tool (e.g., if only a specific request type is needed), but the provided alternative is clear enough for typical workflows.

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

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

The description adds no behavioral detail beyond what annotations already provide (readOnlyHint=false, destructiveHint=true). It does not mention whether the key press is a full down+up cycle, whether it requires focused element, or potential side effects. The description essentially restates the title, offering no additional context.

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

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

The description is a single, concise sentence that directly conveys the tool's purpose. It is front-loaded and contains no filler, making it 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?

For a simple one-parameter tool with complete schema and annotations, the description is mostly adequate. However, it lacks guidance on when to use it relative to similar tools and does not explain nuances of key pressing (e.g., event behavior), so it is not fully complete.

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

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

The input schema fully documents the single 'key' parameter with an explanatory description and example values. Since schema coverage is 100%, the description does not need to elaborate on parameters. Baseline of 3 is appropriate; the description adds no extra meaning.

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

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

The description 'Press a key on the keyboard' clearly states the action (press) and the resource (key). It is specific and unambiguous, but it does not explicitly differentiate from sibling tools like browser_key_down_up or browser_dispatch_event, so it lacks sibling distinction.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention prerequisites, exclusions, or scenarios for which browser_type or browser_key_down_up would be preferred. Users must infer usage from the tool name and schema.

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?

Annotations already indicate readOnlyHint=false and destructiveHint=true, so the safety profile is known. However, the description adds no behavioral context beyond the bare action, such as whether it affects the viewport or the actual OS window, or if it triggers reflow.

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

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

The description is a single, concise sentence with no filler. Every word is essential, and it is front-loaded with the action.

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

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

Given the simplicity of the tool (2 required numeric params, no output schema), the description is minimal but lacks details about the effect of resizing on the current page state or the meaning of the destructive hint. It is adequate for basic invocation but leaves room for clarification.

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

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

The input schema fully documents both width and height parameters with descriptions. The tool description does not add any additional parameter guidance, so it relies entirely on the schema. Baseline 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 uses the specific verb 'resize' and the resource 'browser window', making the action unambiguous. It distinguishes from sibling tools like browser_navigate or browser_scroll_to, but does not add scope like target width/height, so it is clear but not highly detailed.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states the action with no context, such as responsive testing or viewport adjustments.

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

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

The description adds substantial behavioral detail beyond the destructiveHint annotation by specifying that it executes arbitrary JavaScript in the Playwright server process and is RCE-equivalent. This discloses the security-critical execution environment and potential for full server compromise, which is crucial for an agent deciding whether to invoke it.

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

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

The description is two sentences: the first states the tool's purpose, the second delivers the critical safety warning. Every word earns its place, with no fluff 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 high-complexity, dangerous tool with no output schema, the description covers the most essential context: the RCE risk and server-process execution. It does not explicitly state return-value behavior, but the schema's example (return await page.title()) implies the result is returned. This is adequate given the schema's richness and the warning's clarity.

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 detailed explanations for both parameters: code includes a full example showing the function signature and usage of page, and filename explains precedence when both are provided. The tool description adds no additional parameter semantics, so baseline 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 'Run a Playwright code snippet' and immediately highlights the unsafe RCE-equivalent nature, distinguishing it from browser tools like browser_evaluate that run in page context. The verb 'run' and resource 'Playwright code snippet' are specific, and the warning makes the tool's unique position unmistakable.

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 explicit alternatives or when-not-to-use conditions are given. The unsafe/RCE warning implies caution and suggests this is an advanced/risky tool, but there is no direct guidance such as 'prefer browser_evaluate for in-page JavaScript' or 'use only when other browser tools are insufficient.' Usage context is implicit, not explicit.

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?

Annotations already provide destructiveHint: true and openWorldHint: true, but the description adds no further behavioral context, such as coordinate system interpretation, effect of combining target with coordinates, or whether the action has side effects beyond scroll position. It simply restates the basic function without enriching the agent's understanding.

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

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

A single, concise sentence front-loads the action and resource, with no redundant words or filler. It is perfectly sized for the given 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?

The tool has four optional parameters and no required ones, but the description leaves ambiguity about default behavior when no parameters are provided and how the target and coordinates interact. Given the destructiveHint annotation, more behavioral caveats would be beneficial, but the schema partially compensates.

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

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

Schema coverage is 100% with detailed descriptions for each parameter. The description adds minimal value by summarizing the modes but does not clarify parameter relationships or default behavior. This aligns with the baseline of 3 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 uses a specific verb 'Scrolls' and clearly identifies the resource ('the page or a specific element') and the two modes ('into view or to custom coordinates'). This distinguishes it from sibling tools like browser_navigate or browser_find, leaving no ambiguity about its function.

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

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

The description implies usage for scrolling but provides no explicit guidance on when to choose this tool over alternatives. It does not mention when not to use it, such as when a simple navigation would suffice, leaving room for assumption.

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?

Annotations already indicate destructiveHint=true and readOnlyHint=false, but the description adds no behavioral context beyond the action. It does not disclose side effects, whether selection changes page state, or any permission requirements.

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

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

The description is a single sentence with no extraneous words, making it highly concise and front-loaded. It is appropriately sized 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?

Despite having schema and annotations, the description lacks context about multi-select behavior, what happens after selection, or how the selection affects the page state. It is minimally complete for a simple action but insufficient for robust agent guidance.

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

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

The input schema provides descriptions for all three parameters (target, values, element), achieving 100% coverage. The description adds no additional parameter details, so it meets the baseline but does not exceed it.

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

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

The description 'Select an option in a dropdown' uses a specific verb and resource, clearly indicating the tool's function. It lacks explicit differentiation from sibling tools like browser_toggle_checkbox, but the dropdown focus is distinct enough to be understood.

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

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

The description provides no guidance on when to use this tool versus alternatives such as browser_fill_form or browser_click. It does not mention scenarios, prerequisites, or exclusions.

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

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

The word 'emulates' adds a useful behavioral nuance (simulating, not changing the real location), but the description does not mention side effects, persistence, or how to reset. Annotations already indicate destructiveHint=true, but the description adds little beyond that.

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

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

The description is one concise sentence with no redundant words. However, it omits potentially useful context like parameter specifics or behavioral notes, so it is not maximally informative.

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

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

For a simple tool, the description is minimally adequate, but it lacks any usage context, side-effect disclosure, or clarification of the destructive hint. With no output schema and no guidance on when to use, it falls short of being fully complete.

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

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

The schema describes all three parameters (latitude, longitude, accuracy) with ranges and optionality, giving 100% coverage. The description does not add any semantic detail beyond what the schema provides, so it meets the baseline.

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

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

The description clearly states the tool emulates a specific geographic location for the browser context, with a specific verb ('emulates') and resource. This distinguishes it from all sibling browser tools, none of which address geolocation.

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, no prerequisites, and no context such as when emulation might be needed. It lacks any 'use when' or exclusionary language.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, which covers the safety profile. The description adds minimal behavioral context: it identifies the snapshot as an accessibility snapshot and notes superiority to screenshots, but doesn't describe the output format, size, or side effects. No contradiction with annotations.

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

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

The description is a single, concise sentence that immediately states the action and includes a useful comparative note. Every word contributes to the core message without redundancy or filler.

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

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

The description captures the core purpose and distinguishes it from screenshots, but it does not explain what an accessibility snapshot contains or the return format. With no output schema, some uncertainty exists, yet the thorough parameter schemas and safety annotations make the tool's context reasonably complete.

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

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

The input schema covers all four parameters with detailed descriptions (100% coverage), including coordinate semantics and file-saving behavior. The tool description itself does not add parameter information, which is acceptable given the schema's completeness.

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

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

The description clearly states the tool 'Capture accessibility snapshot of the current page', specifying the verb, resource, and scope. The phrase 'better than screenshot' distinguishes it from browser_take_screenshot, even though it doesn't address other siblings like browser_get_html.

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

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

The description provides a comparative recommendation ('this is better than screenshot') that suggests preferring this tool over screenshots for accessibility needs. However, it does not explicitly state exclusions or mention alternatives beyond screenshots, leaving some indirectness in the 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?

Annotations already declare readOnlyHint=false and destructiveHint=true, covering the safety profile. The description adds the action list but this is redundant with the schema enum. It doesn't disclose additional behaviors such as what 'close' with omitted index does (though schema notes it) or effects of 'select'. With annotations present, the description provides minimal extra value, warranting a 3.

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, 'List, create, close, or select a browser tab,' which is extremely concise and front-loaded. Every word contributes to the core function. There is no filler or repetition.

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

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

This is a multi-action tool with no output schema, yet the description does not explain return values (e.g., what 'list' returns) or when each action is appropriate. It lacks essential context for an agent to fully understand the tool's capabilities beyond the action names. The schema covers parameters but not behavioral outcomes, leaving the description insufficiently complete.

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

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

Schema description coverage is 100% with each parameter (url, index, action) described. The description adds no parameter-level detail beyond the schema, so it neither enhances nor detracts. Baseline 3 is appropriate for full schema coverage.

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

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

The description clearly states the tool manages browser tabs with four specific actions (list, create, close, select), matching the schema enum. It identifies the resource (browser tab) and action verbs, making the purpose unambiguous. It doesn't explicitly contrast with sibling tools like browser_close or browser_navigate, so it's not a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention scenarios like 'use for tab-level operations instead of browser_close' or any prerequisites. Merely listing actions implies usage but provides no exclusions or comparative context, which falls short for a tool with many 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?

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the description doesn't need to cover those. It adds valuable behavioral context by explicitly stating that the screenshot cannot be used for actions, which is not derivable from the annotations alone. This is useful for the agent to avoid misuse.

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

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

The description is a single sentence that is front-loaded with the core action and immediately provides the key caveat about usage. Every word earns its place, with zero wasted text. It is concise and well-structured.

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

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

The description tells what the tool does and a key limitation, but it does not mention what the tool returns (e.g., a file path, image reference) or that it saves a file. With no output schema defined, the agent is left to infer the result, which is a notable gap for a tool that produces a file. The schema covers file naming, but the description doesn't clarify the return value, making it only partially complete.

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

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

The schema description coverage is 100%, with all parameters having detailed descriptions (type, scale, target, element, filename, fullPage). The tool description itself adds no additional parameter semantics, but the schema fully covers the parameters, so a baseline of 3 is appropriate.

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

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

The description clearly states the tool's action ('Take a screenshot') and the specific resource ('current page'), making it easy to understand its core function. It also distinguishes itself from the sibling tool browser_snapshot by noting that screenshots are not for actions, which differentiates it from a very similar-sounding tool.

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

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

The description explicitly states when NOT to use this tool: 'You can't perform actions based on the screenshot' and provides the alternative 'use browser_snapshot for actions.' This gives clear, actionable usage guidance and differentiates from a key sibling tool.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, establishing the safety profile. The description adds the behavioral detail that the screenshot is saved to the workspace, which is not covered by annotations. It does not contradict the read-only hint, as saving a local file does not mutate the external browser state.

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, tightly worded sentence that front-loads the core action and destination. It contains no filler, redundancy, or unnecessary qualifiers. Every phrase 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?

For a simple tool with full schema coverage and clear annotations, the description is adequate. It covers the primary behavior (element screenshot and workspace save) but does not mention what the tool returns (e.g., file path) since no output schema exists. This is a minor gap; the overall information provided by description, schema, and annotations is sufficient for an agent to invoke it correctly.

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

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

The schema has 100% parameter description coverage, with each of the three parameters (type, target, filename) fully explained. The description itself adds no extra parameter-level detail, but given the schema's thoroughness, the baseline of 3 is appropriate. No need for the description to repeat what the schema already provides.

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 that the tool takes a screenshot of a specific element and saves it to the workspace. This distinctive verb+resource phrasing sets it apart from the sibling browser_take_screenshot, which presumably captures the full page. The purpose is immediately obvious and unambiguous.

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

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

The description does not explicitly mention when to use this tool versus alternatives, such as browser_take_screenshot for full-page captures. No when-not conditions or alternative tool references are provided. Usage is implied by the name and description, but an agent must infer the distinction without direct 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?

Annotations already indicate a write operation with destructive potential (readOnlyHint=false, destructiveHint=true). The description adds the trait 'deterministically' suggesting it sets the state directly, but does not elaborate on event firing or side effects. No contradiction with annotations.

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

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

Single sentence, concise, front-loaded with action and target. No wasted words.

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

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

Given the simple 2-parameter tool and existing annotations, the description covers the core action but omits return behavior and any prerequisites. Since there is no output schema, the agent might need to know if a result is returned. Overall adequate but not rich.

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 covers 100% of parameters with descriptions for target and checked. The tool description adds no additional semantic detail to the parameters beyond repeating 'checkbox/radio button'.

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 the specific verb 'Checks or unchecks' with resource 'checkbox/radio button element', clearly distinguishing it from sibling tools like browser_click or browser_select_option. It is specific and unambiguous.

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

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

The description does not explicitly state when to use this tool over alternatives like browser_click, nor does it mention preconditions or exclusions. The word 'deterministically' subtly hints at superiority over clicking but no direct guidance is given.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutating operation. The description adds no additional behavioral context beyond the literal action, such as whether it replaces text or how it handles focus.

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

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

The description is a single, front-loaded sentence that conveys the basic function without waste. Perfectly concise.

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

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

Given the tool's simplicity and the rich schema/annotations, the description is minimally sufficient, but it leaves out details about side effects or return behavior that could be important for an agent. A more complete description would mention whether the text replaces existing content or if the target needs to be focused.

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 describes all 5 parameters with 100% coverage, so the description does not need to elaborate. It adds no additional parameter semantics 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 verb 'Type' and the resource 'editable element', making its core function evident. However, it doesn't explicitly distinguish itself from sibling tools like browser_fill_form or browser_press_key, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, and no prerequisites or exclusions are mentioned. The schema descriptions for `slowly` and `submit` offer some context, but the description itself is silent.

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?

Annotations already declare the tool as destructive and a write operation, and the description adds the specific behavioral detail of bypassing the modal. However, it does not disclose additional traits such as replacement of existing selections, error conditions, or side effects on the page.

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?

Single sentence, immediately front-loaded with the action, and every word contributes useful information. No redundancy or structure issues.

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

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

Despite the short length, the combination of the description and schema fully specifies how to invoke the tool: target identifies the file input element, paths provides local file paths, and the description clarifies the direct bypass mechanism. An output schema is absent, but for this simple mutation the description is sufficiently complete.

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

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

Schema description coverage is 100% with both parameters clearly described. The description adds no extra parameter-level meaning, so per rules the baseline score is 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?

Description clearly states a specific action ('directly sets input files on a file input element') and includes a differentiator ('bypassing the file-chooser modal requirement'), which distinguishes it from standard upload tools. This gives the agent an accurate understanding of the tool's unique function.

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

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

The description implies a use case (when bypassing the file-chooser modal is desired) but does not explicitly state when to use this tool versus siblings like browser_file_upload or browser_drop, and lacks exclusions or prerequisites.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds minimal behavioral detail beyond this, such as the waiting mechanism or timeout behavior, but does not contradict annotations. Some extra context is provided by mentioning the three wait modes.

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

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

The description is a single, well-structured sentence that immediately conveys the core function. It is concise with no wasted words.

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

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

For a simple wait tool with three optional parameters and no output schema, the description covers the main usage scenarios. However, it does not explain behavior when no parameters are provided or timeout handling, leaving minor gaps.

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

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

Schema coverage is 100%, so each parameter has a description. The tool description reinforces the relationship between text (appear) and textGone (disappear) and time, but it does not explain interaction rules (e.g., whether multiple can be used together). This adds marginal value over the schema.

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

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

The description clearly states the tool waits for text to appear or disappear or for a specified time to pass. This is a specific action on a resource (browser state) and distinguishes it from siblings like browser_wait_for_network_idle by focusing on text and time.

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 waiting on UI conditions but does not explicitly state when to choose this over alternatives such as browser_wait_for_network_idle. No exclusions or alternative comparisons are provided, making the guidance purely implied.

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

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

The description adds meaningful behavioral detail beyond the annotations: the 500ms idle threshold requirement. It clarifies that it waits for a stable idle state, which is useful context. Annotations already cover read-only and non-destructive nature, so the bar is lower, and this description adds value.

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

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

A single, focused sentence that states exactly what the tool does. No redundancy or extraneous 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?

For a simple, single-parameter wait tool with read-only annotations, the description provides sufficient detail: the trigger condition and the stability threshold. No output schema is needed, and the absence of extra behavior is acceptable.

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

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

Schema coverage is 100% — the timeout parameter is fully described in the schema with its default and unit. The description adds no extra parametric detail, so the baseline 3 applies.

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

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

The description uses a specific verb 'waits' and clearly identifies the resource and condition: network idle state for at least 500ms. This distinguishes it from siblings like browser_wait_for (which likely waits for other conditions) and browser_network_requests (which lists requests).

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: use this when you need to wait for network activity to settle. However, it does not explicitly mention alternatives or when not to use it, leaving the agent to infer from the name and sibling tool names.

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?

Annotations already signal side effects (destructiveHint=true, readOnlyHint=false), so the description appropriately doesn't repeat safety warnings. It adds useful specifics like saving to a target directory and returning a local path, but doesn't disclose overwrite behavior or failure scenarios, which is a minor gap beyond the annotations.

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

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

The description is compact (two sentences), front-loaded with the primary action, and every phrase adds value. No filler 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 simple tool with well-documented parameters and no output schema, the description adequately covers the return value and main behavior. It could mention error handling or edge cases, but given the tool's simplicity and the presence of annotations, it is sufficiently complete. A 4 reflects that minor behavioral details are missing.

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

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

The input schema has 100% coverage with descriptive text for both url and outputDir. The description mentions target directory and absolute local path, but these echo the schema without adding significant new meaning. Baseline 3 is appropriate.

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

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

The description clearly states the tool's action (downloads an image, converts it to PNG), the resource (image from a URL), and the output (saves to a directory, returns absolute local path). This specificity distinguishes it from all sibling browser tools, which are unrelated to image processing.

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

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

The description provides a clear context: use this tool when you need to download an image and convert it to PNG, saving it locally. It doesn't explicitly mention alternatives or exclusions, but the context is unambiguous given the tool's unique function among siblings.

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