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

With no annotations, the description carries the full burden of behavioral disclosure. It correctly states the core operation and restricts scope to input/textarea elements, but does not mention side effects such as whether focus is required, whether input/change events are fired, or what happens if the element is read-only. The description is accurate 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?

The description is a single, front-loaded sentence with no filler. Every word contributes to conveying the tool's purpose and 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?

For a simple mutation tool with three well-documented parameters and no output schema, the description plus schema provides sufficient context for an agent to invoke it correctly. Some edge cases (e.g., contenteditable elements, event behavior) are not covered, but they are not critical for the core operation.

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

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

Schema description coverage is 100%: selector, strategy, and timeoutMs are all documented in the input schema. The description adds no additional parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('clear') and names the exact resource ('an input or textarea element'), making the tool's function immediately obvious. It is clearly distinct from sibling tools like fill_element, click_element, or hover_element, so an agent can select it without ambiguity.

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

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

The description implies when to use the tool: whenever text needs to be removed from an input or textarea. However, it does not explicitly state when not to use it or mention any alternative approaches (e.g., using fill_element with an empty string), leaving usage guidance implied rather than 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?

With no annotations provided, the description must disclose behavioral details, but it does not mention waiting behavior, default timeout, whether the element must be visible/interactable, what happens if no element matches, or whether it clicks the first match. The description only restates the basic action.

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

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

The description is a single, front-loaded sentence that is easy to parse and contains no filler. It is concise, though it omits some selector strategies and behavioral 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 no annotations, no output schema, and three parameters, the description leaves out important context such as waiting semantics, timeout behavior, error conditions, and interaction with page state. It is minimally adequate but not complete enough for an agent to confidently invoke the tool in varied scenarios.

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

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

Schema description coverage is 100%, and the schema already documents selector, strategy, and timeoutMs. The description adds a partial list of strategies but omits 'tag' and 'class' from the enum, and adds no meaning beyond what the schema provides. 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 action ('Click') and the target resource ('an element'), and mentions selector strategies. It does not explicitly differentiate from sibling interaction tools like fill_element or hover_element, but the verb alone provides a clear purpose.

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

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

There is no guidance on when to use this tool versus alternatives like hover_element, fill_element, or press_key. The intended usage is only implied by the tool name and description, with no conditions or exclusions provided.

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

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

With no annotations, the description carries the behavioral burden, and it does state the key behavior: closing the active session and freeing resources. It implies irreversibility and that the session will no longer be usable, which is sufficient for this zero-parameter tool.

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

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

A single, front-loaded sentence that states both the action and its purpose with no filler. Every word contributes to understanding the tool's function.

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

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

For a zero-parameter tool with no output schema, the description fully captures the necessary call context: what is closed, when it applies, and what the side effect of resource release is. Nothing essential 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?

The tool takes no parameters, so there is no parameter semantics burden. The baseline of 4 applies because the description cannot and does not need to add parameter meaning beyond the empty 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 uses a specific verb ('Close') with a clear resource ('the active Selenium browser session') and an outcome ('free resources'). It distinguishes itself from sibling tools like manage_tabs by referring to the entire browser session rather than individual tabs.

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

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

The description clearly indicates this is the teardown/cleanup tool for a Selenium session, giving the agent a clear context for when to call it. It does not explicitly mention alternatives or exclusions, such as closing a single tab via manage_tabs, but the context is unambiguous enough for a simple lifecycle 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that execution happens in the 'browser page context' and that a result is returned. However, it does not spell out side effects, destructive potential, serialization constraints, or how errors and async results are handled, which is meaningful for a code-execution tool.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every phrase contributes to understanding the tool's core purpose and execution context.

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

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

With no output schema and no annotations, the description is the only behavioral contract beyond the parameter schema. It covers the essentials—executing arbitrary JavaScript and returning a result—but omits caveats an agent would benefit from when invoking arbitrary code, such as result serializability, error behavior, or side-effect warnings. This is adequate for basic invocation but not fully complete for a high-power execution 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%, with both parameters already documented. The 'args' property even explains the arguments[0] convention, and the 'script' property explains the need to use 'return'. The tool description adds little parameter-level meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a clear verb and resource: 'Execute arbitrary JavaScript code in the browser page context' and promises to 'return the result.' This cleanly separates it from the sibling browser-automation tools, none of which expose arbitrary script execution.

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

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

The description gives no explicit guidance on when to use this tool versus the available alternatives, such as click_element, get_page_content, or fill_element. The word 'arbitrary' hints at a catch-all capability, but there is no stated preference, exclusion, or prerequisite, leaving the routing decision entirely to the agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the core action (typing text) and does not mention that the element is cleared before typing by default, that Enter can be pressed, that the tool waits for the element up to timeoutMs, or any error behavior. These details exist in the parameter descriptions but not in the tool-level description.

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 redundant information. The action and target are front-loaded, and every word adds meaning. It is an example of efficient, 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?

The tool has six parameters with meaningful defaults (e.g., clearBefore=true, pressEnter=false, timeoutMs=10000) and no annotations to convey side effects or safety behavior. The description alone leaves important behavioral context implicit, though the schema fills many gaps. The combined context is sufficient for a basic fill action, but the tool-level description is not fully complete on its own.

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

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

Schema description coverage is 100%, and every parameter includes its own description in the input schema. The tool description itself adds no parameter-specific meaning, which is acceptable because the schema already documents each parameter fully. 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 states a specific verb ('Type') and a specific resource ('an input or textarea element'), making the tool's function immediately clear. It also differentiates itself from sibling tools like press_key (which types anywhere) and clear_element (which only clears), so an agent can distinguish it without opening the schema.

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 filling input and textarea elements, which gives some contextual signal. However, it does not explicitly mention when to prefer this tool over alternatives, such as press_key or select_dropdown, nor does it state any exclusions or preconditions.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the operation is inspection-oriented and states the returned data categories, which is useful. It does not mention timeout or no-match behavior, but for a read-only query tool this is a minor gap.

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

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

The description is a single front-loaded sentence with no redundancy. It compactly states both the action and the expected output, so 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?

With no output schema, the description lists key return fields but not their exact structure. It also leaves sibling differentiation and timing behavior unspecified, making it adequate for basic invocation but not fully complete for an agent deciding between related tools.

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

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

Schema description coverage is 100%, with each parameter already documented. The description adds no extra parameter-level detail beyond 'matching a selector,' 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 uses a specific verb+resource ('find and inspect elements') and lists concrete return fields (tag, text, attributes, visibility). This clearly identifies the tool's role and differentiates it from sibling interaction tools like click_element and fill_element.

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

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

No explicit when-to-use or alternative tools are mentioned. The read-only phrasing 'find and inspect' implies use for querying element state, but the description does not state when not to use it or contrast with related tools like wait_for_element or get_element_attribute.

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

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

With no annotations, the description carries the full burden. It implies a read-only operation through the word 'Get' and states what is returned, but it does not disclose behavioral details such as requiring an open browser/page or how errors are handled. For a zero-parameter getter this is minimally adequate but not thorough.

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 or repetition. Every word carries meaning, and the core action and outputs are 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 zero-parameter read-only getter, the description names both outputs (URL and page title) and is sufficient for an agent to select and invoke the tool. It does not specify the return structure or session prerequisites, and there is no output schema to compensate, but the low complexity makes this a minor gap.

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

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

The tool has zero parameters, and the instruction gives a baseline of 4 for such cases. The description reinforces that the tool simply reads current context, so there are no parameter semantics to clarify.

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

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

The description uses a specific verb ('Get') and a precise resource ('current page URL and page title'), clearly distinguishing this tool from siblings like get_page_content or get_element_attribute. It adds the page title beyond what the tool name alone implies, making the 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?

No guidance is provided about when to use this tool versus alternatives, such as get_page_content or navigate. There is no mention of prerequisites like an active browser session, nor any exclusion criteria.

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

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

With no annotations, the description must carry the behavioral burden. 'Retrieve' conveys read-only intent and the timeoutMs parameter hints at wait behavior, but the description does not state what happens if the element or attribute is missing, whether a default/null is returned, or if any page mutation occurs.

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 action-first sentence with inline examples and no filler. Every word earns its place and the core operation 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, the description plus fully documented schema is nearly sufficient. The main gap is the absence of an output schema or explicit note about return/error behavior, but the operation is simple enough that an agent can invoke it correctly with the provided information.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds 'property' terminology and attribute examples, but those largely duplicate the schema's examples and don't clarify selector, strategy, or timeout semantics further.

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

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

The description uses a specific verb ('Retrieve') with a clear object ('specific attribute or property') and includes concrete examples (href, src, value, class). It clearly communicates what the tool does, though it does not explicitly name sibling 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?

The intended use is implied by the wording—use this when you need an element's attribute value—but there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives such as get_page_content or find_elements. This is adequate but leaves routing to inference.

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

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

With no annotations, the description carries the burden. 'Retrieve' implies a read-only operation and 'current page' clarifies scope, but the description does not disclose truncation behavior at maxLength, return structure, or error cases. It adds only modest context beyond the input 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?

A single efficient sentence that front-loads the verb and resource. Every word earns its place, and no redundant detail is present.

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 tool with fully documented parameters and no required arguments, the description is largely sufficient. Minor gaps like truncation behavior and guidance on choosing 'structure' vs 'text' do not prevent 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?

Schema description coverage is 100%, so the description need not add parameter meaning. The format values are already well documented in the schema; the description only echoes them, adding no new parameter semantics.

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

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

The description states a specific verb ('Retrieve') and a clear resource ('content of current page'), and enumerates the three output formats. This makes the tool's purpose immediately distinct from siblings like get_current_url or take_screenshot.

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

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

Usage is implied by the action and scope: agents should call this when they need text, HTML, or an interactive outline of the current page. However, no explicit when-to-use vs alternatives or any exclusion criteria 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Hover mouse over a target element' and does not mention whether the element is scrolled into view, whether it waits for the element to appear, what events are triggered, or what happens if the selector matches no element. The timeoutMs parameter implies waiting behavior, but the description does not state 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 a single sentence with no wasted words. It states the action and the target resource directly, and the key verb is front-loaded. It is appropriately sized for the tool's simplicity.

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

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

The tool is simple, the parameter schema is fully self-explanatory, and the action is clear. However, with no annotations and no output schema, the description lacks behavioral details such as wait behavior, error conditions, and return value. It is minimally viable but leaves some invocation nuances unspecified.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters clearly, including enums and defaults. The description adds no extra parameter context, which is acceptable given the high schema coverage, earning the baseline score 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 states a specific verb ('Hover') and a clear resource ('a target element'), making the tool's function immediately obvious. It also distinguishes itself from sibling tools like click_element or fill_element since hovering is a unique interaction not represented elsewhere in the sibling 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?

There is no guidance on when to use this tool versus alternatives. The description only states what it does, with no mention of scenarios that call for hovering, such as triggering tooltips or hover menus, nor any exclusions or 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action and configuration options, but does not disclose side effects, default headless behavior, whether a browser session handle is returned, whether multiple instances are allowed, or common failure conditions.

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

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

The description is a single sentence with no filler. It front-loads the action and resource, and the trailing option list is compact yet 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?

The tool is easy to invoke because all parameters are optional and the schema documents defaults and enums. However, with no output schema and no annotations, the description does not explain what the tool returns or how the launched browser connects to sibling tools, leaving a moderate completeness gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mostly paraphrases the schema properties (browser enum, headless, viewport dimensions, proxy, args) and adds no new constraints, format details, or edge-case semantics beyond 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 uses a specific verb, 'launch', with a clear resource, 'browser instance', and names the supported browsers (Chrome, Firefox, Edge). This clearly distinguishes it from siblings like close_browser, navigate, and get_current_url.

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 or alternative guidance is provided. The verb 'launch' implies this is the initial step before other browser operations, but the description does not state that ordering, mention 'use before navigate', or rule out cases where launching is unnecessary.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It reveals nothing beyond the action names: no mention that set/delete/delete_all mutate browser state, that delete_all may clear cookies across domains, that cookies are scoped to the current page/URL, or what happens on error. For a tool with five distinct behaviors, this is thin.

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 front-loaded sentence with zero filler: the resource and the complete operation set are conveyed in ten words. Every word earns its place and nothing should be cut.

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 (5 behaviors, 7 parameters) with no annotations and no output schema, yet the description provides only the action list. Per-action parameter contracts, return behavior, and lifecycle preconditions are all missing, so an agent cannot reliably determine what to pass for each action or what to expect back.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the action vocabulary but does not clarify the conditional per-action parameter requirements — for example, that 'set' effectively needs name, value, and domain while 'delete_all' needs no extra parameters. Since the schema also fails to encode these conditionals, the description neither gains a bonus nor drops below 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 names the resource ('browser cookies') and enumerates five concrete operations (get_all, get, set, delete, delete_all), which clearly scopes what the tool does. It also distinguishes from the sibling browser-automation tools, none of which handle cookies. The verb 'Manage' is somewhat generic, but the explicit action list compensates.

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 invoke this tool versus alternatives or under what conditions. It omits prerequisites such as an active browser session or an already-navigated page, and gives no exclusions. The only usage signal is the action enum, leaving the agent to infer timing and context entirely.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It names four actions but does not disclose side effects such as whether opening a new tab switches focus, what happens when closing the active tab, or how list results are returned. This is thin for a tool that can mutate tab 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 compact sentence with no filler. The action list is front-loaded and immediately scannable, making it easy for an agent to parse the tool's scope quickly.

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

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

The description is adequate for basic action dispatch, and the schema covers all parameters, but it omits conditional dependencies and state-change caveats. Since there is no output schema, the list action's return format is also left unspecified, though this is not a major blocker for using 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%, with each parameter already documented, including conditional requirements for url and tabIndex. The description only restates the action names and adds no extra semantic detail beyond what the schema provides, so the baseline score applies.

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

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

The description uses a clear verb ('manage') with a specific resource ('browser tabs') and enumerates four concrete operations: list, switch, open, and close. This makes the tool's purpose immediately distinguishable from sibling tools that operate on the current page or browser lifecycle.

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 listed actions imply tab-level usage, but the description does not explicitly state when to use manage_tabs versus siblings like navigate (for current-tab navigation) or launch_browser. There is no when-not-to-use guidance or mention of alternatives, so usage context is only 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action itself and does not mention whether navigation waits for page load, updates browser history, or handles errors such as invalid URLs or network failures. This is a bare statement of intent, not a behavioral contract.

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 action verb, and contains no 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 one-parameter action, the description is adequate, but it omits the explicit prerequisite of an active browser session (though implied) and the post-condition of page-load behavior. Without an output schema or annotations, an agent cannot know whether the tool blocks until navigation completes, which is a minor but real gap.

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

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

Schema description coverage is 100%, and the url parameter is fully documented with type, format, and an example. The description adds no parameter-specific detail, but none is needed because the schema already provides sufficient semantic meaning.

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

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

The description states a specific verb ('navigate'), resource ('active browser'), and target ('specified URL'), making the tool's function unmistakable. It clearly distinguishes from siblings like navigate_history (history traversal) and launch_browser (session creation) 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?

The description implies usage when the agent needs to load a specific URL in the current browser, but it provides no explicit guidance about prerequisites (e.g., requiring launch_browser first) or alternatives (e.g., navigate_history for back/forward). No exclusions or conditions are stated.

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

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

No annotations are provided, so the description alone must disclose behavior. It largely repeats the enum values already present in the schema and adds no detail about side effects, return value, page-load waiting, or which tab is affected.

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

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

One short, front-loaded sentence states the action category and all supported actions with no redundant 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?

For a one-parameter action tool, the description is minimally adequate, but it omits return behavior, whether navigation applies to the active tab, and any follow-up expectations such as waiting for page load.

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

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

Schema description coverage is 100% and the parameter is self-documenting via its enum and description. The tool description adds no meaning beyond 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 provides a specific verb ('Perform') and resource ('browser navigation actions') and enumerates the exact actions: back, forward, or refresh. This clearly distinguishes navigate_history from sibling tools like navigate (URL navigation) or manage_tabs.

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

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

The action enumeration gives clear context for when to use this tool: whenever the agent needs history-based navigation rather than entering a URL or manipulating tabs. However, it does not explicitly name alternatives or state when-not-to-use conditions.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It accurately conveys the core operation and target, but does not mention potential side effects of destructive keys such as DELETE or BACK_SPACE, nor does it clarify behavior beyond the basic key press. The information is adequate 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?

The description is a single, focused sentence that includes concrete examples and no extraneous content. It is front-loaded with the main action and resource, making it easy to parse quickly.

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

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

For a relatively simple tool with full schema coverage and no output schema, the description plus schema is sufficient for an agent to invoke it correctly. The main limitation is the lack of explicit usage guidance relative to sibling tools, but that is already accounted for in the usage_guidelines dimension.

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

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

Schema description coverage is 100%, with the key enum, selector description, and strategy defaults fully documented in the input schema. The description adds no parameter-specific semantics beyond naming example keys, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Send') with a clear resource ('page or element') and specifies special keyboard keys such as ENTER, TAB, ESCAPE, and arrows. This clearly distinguishes it from sibling tools like click_element, fill_element, and hover_element, which serve different interaction purposes.

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

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

The description implies usage when special keyboard keys are needed, but it does not explicitly state when to prefer this tool over fill_element, click_element, or clear_element. No exclusions or alternative routing are provided, leaving the agent to infer 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?

No annotations are provided, so the description carries the full behavioral disclosure burden. It only states the action itself and does not disclose whether the tool waits for interactability, fires change events, matches strictly, or what happens when no option matches or the select is not found.

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, front-loaded sentence with no redundant words. It efficiently communicates the core operation and selection modes without bloat.

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 relatively simple and the schema covers all parameters, but because there is no annotations block or output schema, the description alone is only minimally sufficient. It lacks behavioral context such as waiting, matching semantics, failure behavior, and return value, making it adequate but not complete.

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

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

Schema description coverage is 100%, so the schema already documents all parameters including defaults and enum values. The description adds little beyond restating the selection modes already present in selectBy and optionValue, 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 states a specific action and resource: selecting an option in an HTML <select> dropdown, and lists the supported selection modes (value, visible text, index). It is clear and distinct from generic sibling tools like click_element or fill_element, though it does not explicitly name alternatives.

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

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

The description does not provide when-to-use guidance, prerequisites, or exclusions relative to sibling tools. It implies the tool is for <select> dropdowns, but it never states that it should be used instead of click_element or fill_element for native selects, nor mentions custom dropdowns as a non-target.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clearly identifies the state-changing effect, but it does not explain whether it affects the viewport or full browser window, or whether resizing triggers a reload or 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?

A single, front-loaded sentence with no filler. Every word contributes useful information, making it easy for an agent to parse quickly.

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

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

The tool is simple, has only two parameters fully documented by the schema, and no output schema. The description covers the core invocation need, though it could be more explicit about whether the size applies to the viewport or the outer window.

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%: both width and height are fully described in the schema with units and constraints. The description repeats the same 'pixels' unit without adding new semantic meaning, so the 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 direct verb ('Set'), names the resource ('browser window'), and specifies the exact dimensions ('width and height' in pixels). This clearly distinguishes it from navigation, element, and tab tools among the siblings.

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

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

No guidance is given about when to use this tool versus alternatives, nor are prerequisites or exclusions mentioned. The description states only what the tool does, not the context in which it should be chosen.

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

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

No annotations are present, so the description bears the full burden. 'Switch execution context' is accurate but does not disclose that the switched context persists for subsequent commands, must be reset, or how failures are handled. This is a meaningful gap for a state-changing browser automation tool.

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

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

A single, front-loaded sentence with no filler. Every word contributes to the core behavior, and the main target types are listed compactly.

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 covers the conditional parameters well (selector for 'element', frameIndex for 'index'), but the overall definition lacks key stateful context: it does not state that the context persists, that 'default' resets to the main document, or any behavior on invalid targets. Adequate but incomplete for a stateful tool with no output schema.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters and their enums. The tool description adds no extra parameter semantics, which is acceptable under 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?

States a specific operation, 'switch execution context', with explicit target classes ('iframe, parent frame, or default document'). This clearly differentiates it from sibling navigation and element tools, which do not manage frame context.

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

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

No guidance is provided about when to use this tool, prerequisites (e.g., an iframe must exist), or when to return to the default context. It doesn't reference alternatives or exclusions, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It usefully states that the result is PNG image data, but it does not mention whether the page is modified, what happens when an element selector is invalid, or whether scrolling or waiting is involved. For a capture action this is acceptable but not fully transparent.

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

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

The description is a single, front-loaded sentence with no filler. It states the action, scope, and output format efficiently, and every part earns its place.

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

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

For a simple two-parameter tool with full schema coverage, the description is largely complete: it specifies what is captured and the return type. The absence of an output schema is partially mitigated by mentioning PNG image data, though details like base64 encoding or error behavior are not covered. This is a minor gap given the low 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 description coverage is 100%, so the parameters are already well documented in the input schema. The description adds only the high-level distinction between viewport and element capture, but no additional parameter-level semantics beyond what the schema provides. 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 and resource: 'Take a screenshot of the current page viewport or a specific element.' It clearly states the output format ('return PNG image data') and is unambiguous. It also distinguishes itself from the sibling navigation and element-interaction tools by describing a unique capture action.

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 conveys when to use the tool: whenever a screenshot of the visible page or a specific element is needed. It does not explicitly list exclusions or alternatives, but no sibling tool performs screenshots, so additional exclusion guidance is not necessary.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It states the core waiting behavior but does not explain timeout behavior, return value, polling semantics, or whether it throws an error when the condition is not met. An agent cannot predict the outcome when the wait fails.

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

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

The description is a single, direct sentence with no filler. It front-loads the action and enumerates the supported conditions compactly. Every word earns its place.

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

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

For a tool with no annotations and no output schema, the description is too thin. It omits what happens on timeout, whether the tool returns a boolean or throws, and any guidance on typical usage. The schema covers inputs well, but behavioral and outcome information 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 description coverage is 100%, so the schema fully documents selector, strategy, condition, and timeoutMs. The description adds no new meaning beyond the schema; it only repeats the condition options in prose. This meets the baseline but does not go beyond 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 clearly identifies the operation (wait) and the target (element), and lists the specific conditions supported. This distinguishes it from sibling action tools like click_element or fill_element, which perform direct actions rather than waiting.

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

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

No guidance is provided about when to use this tool versus alternatives. The description implies it should be used when an element must reach a certain state before proceeding, but it does not mention when not to use it, what happens on timeout, or how it relates to find_elements or other wait-like operations.

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