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 says 'Check a checkbox or radio button,' but doesn't disclose that this mutates the element's checked state, whether it triggers events, or any prerequisites. It's a state-changing operation with no transparency about side effects.

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

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

The description is one concise, front-loaded sentence that directly states the 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?

For a simple action tool with full schema coverage, the description plus schema is minimally sufficient. However, since it's a mutation tool with no annotations and no output schema, it could benefit from mentioning return behavior, error conditions, or that it works on the current page.

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 'selector' and 'sessionId' already described in the schema. The tool description adds no additional parameter 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 specifies the tool's action ('Check') and target ('checkbox or radio button'), which is a clear verb+resource pair. It implicitly distinguishes from sibling tools like browser_click (generic click) and browser_uncheck (opposite action), though it doesn't 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 clearly states the context: use for checkboxes or radio buttons. This implies it should be used over generic clicks for these element types, and the existence of browser_uncheck suggests when not to use (when unchecking). However, it doesn't explicitly state 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?

With no annotations, the description carries full responsibility for disclosing behavioral traits. It only says 'Clear all cookies' and fails to mention the impact on the browser session, whether it clears cookies for a specific sessionId or globally, or if it persists across navigations. This is a significant gap for a mutation tool.

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

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

The description is extremely concise with no wasted words, but it is under-specified. While it is front-loaded and clear, it omits critical parameters and behavioral details, making it borderline acceptable for conciseness.

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

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

Given the tool's complexity (one optional parameter, no output schema), the description is incomplete. It does not explain how the optional sessionId is used, what the return value (if any) is, or what side effects clearing all cookies has on the browsing context. This leaves the agent with insufficient information to use the tool correctly 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 coverage is 100% because the sessionId parameter has a description ('Browser session ID'), so the baseline is 3. The tool description does not add any further meaning about how sessionId affects the clearing operation, but it doesn't need to because the schema already provides basic parameter semantics.

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

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

The description uses a specific verb 'clear' and resource 'cookies' with scope 'all', clearly distinguishing it from sibling tools like browser_get_cookies and browser_set_cookies. It leaves no ambiguity about the tool's primary 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 provides no guidance on when to use this tool versus alternatives, such as when to clear specific cookies via browser_set_cookies or whether it should be used before navigation. It simply states the action without contextual or conditional advice.

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 'Click' without mentioning side effects, prerequisites (e.g., element visibility), or what happens if the element is not found. This is minimal for a tool with mutation-like behavior.

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

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

The description is a single concise sentence that communicates the core function without any redundant words. It is appropriately sized for the tool's simplicity.

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

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

For a simple click action, the description is adequate, but it omits any mention of sessionId behavior or return values. Given the large sibling toolset, additional context about when to use click versus other interaction tools would improve completeness.

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

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

The schema covers both parameters with descriptions. The tool description adds value by explaining that 'selector' can be a CSS selector, text content, or accessibility locator, which clarifies the parameter's flexibility beyond the schema's generic phrasing.

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 ('Click') and the resource ('element'), and specifies how to identify it ('selector or accessibility properties'). However, it does not explicitly distinguish itself from sibling tools like browser_press or browser_hover, though the action is inherently different.

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

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

No guidance is provided on when to use this tool versus alternatives such as browser_press, browser_fill, or browser_hover. The description only states 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the action without detailing side effects, resource cleanup, idempotency, or error conditions. This leaves significant ambiguity about what closing a session entails.

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

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

The description is a single, succinct sentence that is front-loaded and easy to parse. It is concise in length, though it sacrifices substantive content for brevity, which is slightly more than a pure restatement but still efficient.

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

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

Despite the tool's simplicity, the description is too sparse given the lack of annotations and output schema. It does not explain what happens after closing, whether the session ID becomes invalid, or any impact on other browser operations, leaving the context 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?

The input schema already provides a clear description for the single parameter ('Session ID to close'), achieving 100% schema description coverage. The tool description adds no additional meaning to the parameter, 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 'Close a browser session' is essentially a tautology of the tool name 'browser_close_session', adding no new information beyond what the name already conveys. It does not articulate the purpose beyond restating the action, so it fails to add value.

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 relationships with sibling tools like browser_new_session, nor does it indicate appropriate use cases or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to mention potential side effects (e.g., page state changes), return values, session requirements, or whether the code runs in the main frame or isolated context. This is a significant gap for a powerful 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 sentence, which is concise and front-loaded with the core action. However, it is underspecified, delivering no context about prerequisites, side effects, or when to use the tool. It is concise but not adequately informative.

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

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

Given the complexity of the tool (arbitrary JavaScript execution), the lack of annotations, and no output schema, the description is severely incomplete. It does not cover return values, errors, security implications, or how the sessionId affects execution. This is insufficient for an agent to safely and effectively use 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?

The schema already provides clear descriptions for both parameters (script and sessionId), covering 100% of them. The tool description adds no additional meaning about parameter usage, formats, or constraints beyond what the schema states.

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 executes JavaScript code in the browser context, using a specific verb ('execute') and a distinct resource ('JavaScript code'). It differentiates itself from sibling browser_* tools by focusing on arbitrary code execution rather than predefined actions.

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

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

The description implies this tool is for running custom JavaScript, but it does not explicitly say when to use it over the sibling tools (e.g., for complex interactions not covered by click/fill). No exclusions or alternative recommendations 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 are absent, so the description must carry the full burden of disclosing behavior. It does not state whether existing values are cleared, whether input events are triggered, or whether the element must be interactable, which are critical for a mutation tool.

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

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

The description is a single, front-loaded sentence with no redundant or extraneous information. It is concise and efficient, earning the highest score.

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

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

For a simple action with full schema coverage, the description is minimally viable. However, it lacks disambiguation from browser_type and does not clarify behavior around event firing or value replacement, leaving gaps for an agent navigating a suite of many browser 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 descriptions cover all three parameters at 100% coverage, providing clear meanings for value, selector, and sessionId. The tool description adds no significant semantic detail beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the action ('Fill') and the target ('text input field') with the specified value. However, it does not distinguish from sibling tools like browser_type, which could also operate on inputs, so it lacks differentiation.

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

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

No guidance is provided on when to use this tool versus browser_type or other input methods. It does not mention prerequisites, such as element visibility, or any exclusions, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries the full behavioral transparency burden. It does not disclose whether the operation is read-only (though 'get' implies it), what happens if the element or attribute is missing, or the return type. This lack of explicit behavior leaves a gap.

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

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

The description is a single sentence with no filler, efficiently front-loading the purpose. It earns its place without any 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 getter with no output schema, the description provides only the action and target. It is minimally complete but lacks context on return values and error behavior, leaving some uncertainty for an agent. A score of 3 reflects an adequate but not rich description.

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

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

The input schema describes all parameters with 100% coverage, and the description adds no additional meaning beyond the schema's own descriptions. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description states the action clearly: 'Get an attribute value from an element'. It identifies the specific verb and resource, but does not explicitly differentiate from sibling getter tools like browser_get_text or browser_get_html, so it stops 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 offers no guidance on when to use this tool over alternatives, nor does it mention any exclusions or prerequisites. It simply restates the function without any context about selection.

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

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

With no annotations provided, the description must fully disclose behavior. It only states 'get' with no mention of return format, whether messages are cleared, session requirements, or read-only guarantees. While 'get' implies a non-destructive read, the description does not explicitly convey any behavioral traits.

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 or redundancy. It is front-loaded and immediately clear, making it optimally concise for the information it contains.

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?

There is no output schema and no annotations, so the description should explain return values and usage context. It only states 'Get console messages from the browser' without describing what the console messages include, whether sessionId is required, or how to handle multiple sessions. This incomplete context leaves an agent under-informed for correct invocation.

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

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

The schema provides full description coverage for the single parameter sessionId, described as 'Browser session ID'. The description adds no additional meaning about how sessionId is used or the effect of omitting it, so it relies entirely on the schema, which is already 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 uses a specific verb 'get' and clearly identifies the resource as 'console messages', which is distinct from sibling getters such as browser_get_text or browser_get_network. It unambiguously states the tool's function, though it adds no additional scope or filter details.

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 debugging scenarios, prerequisites such as an active session, or exclusions like whether it works without a session ID. No contextual usage direction is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'get' which implies read-only, but does not explain what is returned, how cookies are formatted, whether a session is required, or what happens if the session does not exist. This is insufficient for an agent to anticipate tool behavior.

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

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

The description is a single concise sentence, but it is under-specified. While there is no wasted wording, the brevity sacrifices necessary context, making it barely adequate rather than well-structured.

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

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

Given the simple getter nature and absence of an output schema, the description should at least clarify what cookies are returned and under what conditions. It fails to provide this, leaving the tool incomplete for an agent to use confidently. Sibling tools like set_cookies add context that could have been leveraged.

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 'urls' and 'sessionId' already described. The tool description adds no extra meaning beyond the schema, so it meets the baseline of 3 but does not enhance parameter understanding.

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

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

The description 'Get cookies from the browser' clearly states the operation and resource, and distinguishes from siblings like set_cookies and clear_cookies. However, it lacks specificity about whether it retrieves all cookies or those for specific URLs, which is a minor clarity gap.

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

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

The description provides no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, session requirements, or differentiation from browser_set_cookies/browser_clear_cookies. This leaves the agent without direction 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?

With no annotations, the description carries full burden. It adds scoping behavior (element or page) but does not disclose potential limitations such as behavior with invalid selectors or whether the operation is purely local. It is adequate for a simple read tool but not rich.

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

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

The description is a single, front-loaded sentence 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 simple getter with fully described parameters, the description adequately covers the core functionality. The lack of an output schema is mitigated by the straightforward 'HTML content' outcome, though it could mention return format nuances.

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

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

Schema description coverage is 100% for all three parameters, so the baseline of 3 applies. The description adds no additional parameter 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 clearly states the tool gets HTML content, specifying both element and full-page scope. This distinguishes it from sibling getters like browser_get_text and browser_get_attribute.

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?

It implies usage context (element vs entire page) but provides no explicit guidance on when to choose this over other getters like browser_get_text or browser_get_url. There are no exclusions or alternatives mentioned.

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

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

With no annotations, the description carries the full burden. It only says 'get' without disclosing whether the log is cleared on retrieval, whether it captures all requests since session start, or if there are any side effects. This lack of behavioral context is a significant gap.

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

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

The description is a single, front-loaded sentence with zero fluff. It is appropriately concise for a straightforward getter tool.

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

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

The tool has no output schema and no annotations, yet the description doesn't explain what the returned network requests look like, how many entries are returned, or any ordering/filtering behavior. This leaves the agent under-informed for practical use.

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

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

The schema fully describes the only parameter (sessionId) with its own description, so schema coverage is 100%. The tool description adds no param-specific details, earning the baseline 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 'Get network requests made by the browser' clearly states the action (get) and resource (network requests), and the phrase 'made by the browser' distinguishes it from other getter tools like get_console or get_cookies.

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

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

No guidance is given on when to use this tool versus sibling tools, nor any exclusions or prerequisites. For example, it doesn't mention whether a session must be active or whether this complements get_console.

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

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

No annotations are provided, and the description only states the action without disclosing details like text extraction semantics (visible vs hidden), error handling, or return format. This leaves the agent without important behavioral context for a read operation.

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

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

Single sentence, no filler, immediately states the function 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 getter, the description covers the core behavior and optional selector, but omits return type specifics and edge-case behavior (e.g., missing element), which matters since there is no output schema or 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 covers both parameters with descriptions, including selector optionality and session ID. The tool description adds no extra parameter semantics beyond this, so baseline 3 applies.

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

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

The description uses a specific verb 'get' and resource 'text content', and clarifies scope ('element or entire page'), distinguishing it from sibling getters like get_html and get_attribute.

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 retrieving text but does not explicitly state when to prefer it over alternatives or when not to use it. No exclusions or alternative tool mentions 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, the description carries full responsibility for disclosing behavior. It only states a get operation, which implies read-only, but does not mention that a session is required, that it returns a string, or that it will not modify page state. The lack of any behavioral detail beyond the verb leaves the agent under-informed.

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 wastes no words. It is appropriately sized for the simplicity of the tool and immediately states the action and target.

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

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

The tool is simple with one parameter and no output schema, so the description could be minimal. However, it would benefit from noting that it retrieves the title of the page in the active session, and whether an error occurs if no page is loaded. As is, it is minimally complete but lacks important contextual 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 description coverage is 100% for the single parameter sessionId, so the baseline is 3. The tool description adds no parameter-specific meaning, but the schema adequately documents the parameter, so no penalty is applied.

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

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

The description 'Get the current page title' uses a specific verb and resource, clearly distinguishing it from sibling tools like browser_get_text, browser_get_html, and browser_get_url. The purpose is unambiguous and concise.

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, nor does it mention prerequisites like an active session. The usage is only implied by the tool name and simple verb, but no explicit context or exclusions are 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?

With no annotations provided, the description must disclose behavioral traits, but it only states the action. It doesn't mention that the tool returns a URL string, whether it errors if no page is loaded, or if any side effects occur. This leaves the agent uncertain about expected behavior for a simple getter.

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

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

The description is a single, front-loaded sentence with zero unnecessary words. It is appropriately concise for a simple getter tool.

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

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

For a tool with one optional parameter and no output schema, the description is minimally viable but incomplete. It lacks clarification about return format, error behavior, and session requirements, which would be helpful for an agent to invoke 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 only parameter, sessionId, is fully documented in the schema with a clear description ('Browser session ID'), so schema coverage is 100%. The description adds no extra parameter meaning, but the baseline of 3 is appropriate given the schema handles 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 'Get the current page URL' is a specific verb+resource statement that clearly identifies the tool's function. It effectively distinguishes from sibling tools like browser_get_title and browser_get_text by targeting the URL specifically.

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 (like needing an active session or page), and no exclusions. There is no mention of context such as 'use when you need the address of the current page' or comparison to similar getter 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?

There are no annotations, and the description does not disclose any behavioral traits such as failure behavior when no history exists, whether it waits for page load, or any side effects. The description is too minimal to inform the agent about edge cases.

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

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

The description is a single, concise sentence that directly states the action without any wasted words. It is front-loaded and easy to parse.

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

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

Given the simplicity of the tool and the presence of an input schema, the description is minimally adequate, but it lacks information about return values, error conditions, and when the sessionId is required. The absence of an output schema and annotations makes the description slightly under-specified.

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% for the single parameter (sessionId), so the baseline is 3. The description does not add any additional meaning about the parameter 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 clearly states the action ('navigate back') and the resource ('browser history'), which is specific and distinguishes it from siblings like browser_go_forward. It leaves no ambiguity about what the tool does.

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

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

The usage is implied by the name and description, but there is no explicit guidance on when to use this tool versus alternatives. For example, it does not mention that this is for moving to the previous page rather than navigating to a new URL or going forward.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only restates the tool's name without disclosing side effects, error conditions (e.g., no forward history), or session requirements. The agent gains little additional behavioral transparency from this text.

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

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

The description is a single, clear sentence with no extraneous information. It is appropriately concise 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?

For a simple navigation tool with one optional parameter, the description is minimal but adequate. However, it doesn't clarify optional sessionId behavior or potential failure modes like missing forward history, leaving some gaps.

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

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

The input schema already documents sessionId with a 'Browser session ID' description, and schema coverage is 100%. The tool description adds no additional meaning to the parameter, but the schema fully covers 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 uses a specific verb ('Navigate') with a clear resource ('browser history') and direction ('forward'), distinguishing it from browser_go_back. This clearly communicates the tool's 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 implies the tool is for moving forward in browser history but does not explicitly state when to use it over alternatives like browser_go_back or browser_navigate. No exclusions or prerequisites are mentioned.

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

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

With no annotations, the description carries the full burden for disclosing behavioral traits, but it provides none. It doesn't mention side effects (e.g., triggering hover menus), requirements (e.g., element visibility), or error handling—just a bare action statement.

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

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

The description is a single, front-loaded sentence with zero filler words. It conveys the core purpose efficiently and is appropriately sized for a simple interaction tool, earning the highest score for 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 has no output schema and no annotations, the description is too sparse to be complete. It omits context about return values, session handling, and how hover relates to other browser actions, leaving the agent underinformed for a browser automation task.

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 both parameters ('selector' and 'sessionId') are already documented in the input schema. The description adds no additional meaning beyond the schema, matching 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 clearly states the action ('Hover') and the resource ('an element'), using a specific verb+noun structure. It uniquely identifies the operation among siblings like browser_click and browser_fill, but does not explicitly name alternatives or add nuance, so it stops short of the highest tier.

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

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

The description gives no guidance on when to use hover versus other actions, nor does it mention prerequisites or exclusions. It simply states what the tool does, leaving the agent without context for selecting it over 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 must carry the full burden of behavioral disclosure. It only states the action but does not disclose the return type (e.g., boolean), behavior when the element is not found, or how multiple matches are handled.

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

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

The description is a single, direct sentence with no wasted words. It is immediately clear 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?

For a simple query tool with no output schema, the description is too sparse. It does not specify the return value or error conditions, leaving important behavioral details unspecified. It also lacks 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 schema already provides clear descriptions for both parameters ('Selector for the checkbox/radio element' and 'Browser session ID'), so schema coverage is complete. The description adds no additional parameter semantics, yielding the baseline score.

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

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

The description clearly states the tool performs a verification of checkbox/radio state, using the specific verb 'Check if' and the resource 'checkbox/radio'. This distinguishes it from sibling tools like browser_check and browser_uncheck, which modify 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 gives no guidance on when to use this tool versus alternatives. It does not mention that it is a read-only verification, nor does it contrast with browser_check/browser_uncheck or the other state-query tools like browser_is_visible.

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 disclosure. It only states the basic purpose and gives no details about return type, error handling, or waiting behavior. This is insufficient for an agent to understand side effects or expected results.

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 unnecessary words. It is front-loaded and easy to parse, though extremely brief.

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 state-checking operation with no output schema and no annotations. The description does not explain what the tool returns (e.g., boolean), how it behaves if the element is not found, or any prerequisites. This is significantly incomplete for an agent to use correctly.

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

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

The input schema has 100% description coverage for both parameters, so the description doesn't need to add parameter details. However, it also doesn't provide any additional semantics beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action (check) and the target (an element's enabled state). It uses a specific verb and resource, distinguishing it from sibling tools like browser_is_visible and browser_is_checked.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention conditions for use, exclusions, or relationships to other state-checking tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'check if visible' and does not clarify return format (e.g., boolean), whether it waits for visibility or checks immediately, error handling for missing elements, or whether it triggers any side effects.

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

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

The description is a single, direct sentence that efficiently conveys the core purpose. There is no wasted text, though it could be more informative without losing conciseness.

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

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

The tool is simple but still lacks essential context: no output schema, no annotations, and no description of return values or behavior on missing elements. For a check-type tool, the user likely needs to know if it returns a boolean or throws an exception, which is omitted.

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 'Selector for the element' and 'Browser session ID' being accurate though generic. The description itself adds no additional parameter context, so the schema provides the baseline which 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 states a specific action (check) and resource (element visibility), which is clear. However, it does not explicitly distinguish from sibling state-check tools like browser_is_enabled or browser_is_checked, though the name itself makes 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 on when to use this tool versus alternatives such as browser_wait_for_selector or browser_snapshot. There is no mention of prerequisites, such as the element needing to exist or be attached to the DOM, nor when not to use it.

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

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

There are no annotations, so the description carries the full transparency burden, but it only says 'navigate to a URL' without disclosing wait behavior, error handling, or page load completion. It also does not mention whether sessionId affects the operation.

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

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

The description is a single concise sentence with no redundant words. It is front-loaded with the action and directly states the target.

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

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

For a browser navigation tool with no output schema, this description is incomplete: it does not explain what happens after navigation (e.g., whether it waits for the page to load, returns success, or errors). It also does not clarify the role of sessionId, and there are related sibling tools that imply additional 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 already describes both parameters with 100% coverage, so the description adds little beyond the schema. It mentions 'URL' but does not clarify the purpose or usage of sessionId beyond the schema's short 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 clearly states the tool's function with the specific verb 'Navigate' and resource 'URL in the browser', making it unmistakable. It is not a tautology and distinguishes from sibling tools that handle history or other browser actions.

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

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

No guidance is provided on when to use this tool versus alternatives like browser_go_back or browser_wait_for_navigation. The description does not mention exclusions or conditions, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries full behavioral burden but only adds 'isolated' as a trait. It does not disclose what happens when the session is created, whether it returns a session ID, or how it relates to the browser lifecycle, leaving significant ambiguity.

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

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

A single, front-loaded sentence with no redundant words. It effectively conveys the core action in minimal space, earning full marks.

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 lacks an output schema and annotations, so the description should explain return values and session behavior. It does not, leaving the agent to guess whether a session ID is returned or how isolation manifests, making it 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?

The description mentions no parameter details, but the schema provides complete descriptions (100% coverage) for the optional viewport object and its width/height properties. The baseline of 3 applies since the schema fully documents parameters.

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

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

The description uses a specific verb ('Create') and resource ('new isolated browser session'), clearly distinguishing it from navigation and interaction siblings. The qualifier 'isolated' adds specificity beyond the tool's name.

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

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

The description provides no explicit guidance on when to invoke this tool, such as 'use before browser_navigate' or that it is the standard entry point. The need to create a session is only implied by the domain context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action but does not mention how the PDF is saved (e.g., file path behavior, overwrite semantics), whether it consumes the sessionId, or whether any return value is produced. This is a significant gap for a tool that writes a file.

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. While it is concise, it under-specifies important behavioral details, so it does not earn a perfect score.

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

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

Given the tool's simplicity and lack of output schema or annotations, the description is incomplete. It omits critical context such as what the 'current page' refers to, what the function returns, and whether a browser session must already exist. The schema helps with parameters but not with overall tool behavior.

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

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

The input schema already provides 100% coverage with descriptions for both 'path' and 'sessionId'. The description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description 'Generate a PDF of the current page' uses a specific verb (generate) and resource (PDF of the current page), clearly distinguishing it from sibling tools like browser_screenshot. It is immediately obvious what the tool does.

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

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

No guidance is provided on when to use this tool vs alternatives such as browser_screenshot or other export methods. There are no exclusions, prerequisites, or context about sessions, making it unclear when this tool should be selected.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects (e.g., triggering form submission, key events, or requiring focus). The agent cannot infer whether this is a safe read-only operation or a state-changing one.

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 with no wasted words. It is appropriately minimal for a simple action and front-loaded with the key verb.

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

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

Given the absence of annotations and output schema, the description is too thin to be complete. It lacks information on return values, effect on the browser state, or how it relates to sibling actions like typing. For a tool with many sibling actions, this level of completeness is insufficient.

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 100% of parameters (key and sessionId) with descriptions. The tool description adds no additional semantics beyond the schema. Since schema coverage is high, a baseline of 3 is appropriate, though the description could have elaborated on key format or supported modifiers.

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 keyboard key' clearly names the action (press) and the target (keyboard key). It distinguishes from siblings like browser_click (mouse click) and browser_type (typing a sequence), though it does not explicitly name alternatives. It is concise 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?

There is no guidance on when to use this tool versus alternatives such as browser_type, browser_click, or browser_fill. No context is given about focus requirements, key combinations, or interactions with forms.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only restates the action ('reload') and adds no details about side effects (e.g., page reload may discard form inputs, trigger new network requests, or require an active session). The description does not go beyond what the tool name already suggests.

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 containing every essential piece of information. It is extremely concise and well-structured for the simplicity of the operation, with no wasteful 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 tool with one optional parameter and no output schema, the description is minimally sufficient but lacks context about session requirements or behavior on failure (e.g., if no page is loaded). It could mention that it requires an active browsing session, but the overall complexity is low.

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

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

The input schema has one optional parameter (sessionId) with a description 'Browser session ID', achieving 100% schema description coverage. The tool description adds no extra parameter semantics, but the baseline of 3 applies since the schema fully covers the parameter.

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

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

The description 'Reload the current page' uses a specific verb ('reload') and resource ('current page'), clearly distinguishing it from sibling tools like browser_navigate or browser_go_back. It is immediately obvious what the tool does, even without additional context.

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

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

The description implies usage from its name and the fact that it operates on the current page, but it provides no explicit guidance on when to use it over alternatives like browser_navigate or browser_go_forward. No exclusions or alternative recommendations are 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It fails to mention potential file writing side effects, return value, or interaction with browser session state. The description only restates the core action without addressing whether it is read-only, destructive, or requires specific 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 concise sentence with no wasted words, directly stating the tool's purpose. While it could be more informative, its brevity is acceptable for a simple tool, though it omits important nuances.

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 4 parameters, no output schema, and no annotations, placing a burden on the description to explain operational behavior. It omits critical details such as file format, return value, how selector and fullPage interact, and whether a session is required. The schema covers parameter syntax but not usage context, leaving the description incomplete for safe invocation.

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

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

Schema description coverage is 100%, with all four parameters (path, fullPage, selector, sessionId) clearly documented. The description does not add any semantic meaning beyond what the schema already provides, matching the baseline for fully covered parameters.

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

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

The description clearly states the action ('Take a screenshot') and the target ('page or an element'), making the tool's purpose unambiguous. It distinguishes itself from sibling tools by being the only screenshot-specific browser tool, though it doesn't explicitly contrast with 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 provides no guidance on when to use this tool versus alternatives like browser_pdf or other capture methods. No context is given for appropriate scenarios, prerequisites, or exclusions, leaving the agent without decision-making support.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Scroll the page or an element' without mentioning side effects like lazy-loading triggers, whether scrolling is instant or animated, what happens if the selector matches no element, or if the tool waits for scroll completion. This leaves significant behavioral aspects undisclosed.

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 with the action verb 'Scroll' and clearly states the target. It contains no fluff or redundant information, making it highly efficient and easy to parse.

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

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

Given the simplicity of the tool and the comprehensive schema documentation, the description plus schema adequately cover invocation details. However, the lack of usage context and behavioral side-effect information prevents it from being fully complete, as an agent may not know when to use it or what to expect.

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 detailed descriptions for all four parameters (direction, amount, selector, sessionId), achieving 100% schema coverage. The description itself adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'scroll' and identifies the target as 'the page or an element', which clearly indicates the tool's function and distinguishes it from sibling navigation and interaction tools like browser_navigate or browser_click. It is unambiguous and directly states what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when it should be used before reading page content or how it relates to waiting for elements. There are no explicit when-to-use or when-not-to-use instructions, making it merely a statement of function without contextual usage direction.

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 action but omits important details such as whether events are triggered, compatibility with custom dropdowns, or behavior when options are 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 a single, front-loaded sentence with no wasted words. It is appropriately sized for the simplicity of the tool, though it lacks depth in other dimensions.

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

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

The tool has no annotations or output schema, so the description needs to provide more context. It does not cover behavioral expectations or edge cases, leaving the description incomplete for a browser automation 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%, so the schema fully documents each parameter. The description adds no additional meaning beyond the schema, leading to a 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 'Select an option from a dropdown' uses a specific verb and resource, clearly identifying the tool's action. It does not explicitly distinguish from sibling tools like browser_fill or browser_click, but the mention of 'dropdown' narrows the scope sufficiently.

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

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

No guidance is given on when to use this tool versus alternatives. The description implies it is for dropdowns, but does not state exclusions, prerequisites, or suggest sibling tools for other scenarios.

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

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

With no annotations provided, the description carries the full burden. It states a mutation ('Set') but does not disclose whether cookies are replaced or merged, whether a sessionId is required, or what side effects occur. The minimal wording 'in the browser' lacks depth.

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, 'Set cookies in the browser,' is extremely concise and front-loaded. Every word contributes to the core meaning with 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?

For a mutation tool with no annotations and no output schema, the description is too sparse. It lacks critical context such as whether existing cookies are cleared, how sessionId affects scope, or any practical usage hints. The absence of guidance makes it 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 description coverage is 100% for both parameters ('Cookies to set' and 'Browser session ID'), so the schema already explains each parameter. The tool description adds no further semantic nuance beyond what the schema provides, but it does not need to compensate.

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

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

The description 'Set cookies in the browser' uses a specific verb ('Set') and resource ('cookies') and clearly distinguishes from sibling tools like browser_get_cookies and browser_clear_cookies. It leaves no ambiguity about the tool's primary 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 provides no guidance on when to use this tool versus alternatives (e.g., when to use browser_clear_cookies first, or when a session is required). Sibling tools exist, but no exclusions or alternative recommendations are 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool is a snapshot (non-mutating) and returns accessibility tree data, but it does not describe output format, whether it requires a valid session, or any potential waiting/loading behavior. This is partial but has clear 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, well-structured sentence that is front-loaded and contains no unnecessary words. It earns its place fully.

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 (one optional param), but without annotations or an output schema, the description needs to cover behavior and usage. It clearly states the outcome (accessibility tree snapshot) but lacks explicit usage guidance, output format, or behavioral details like session requirements. Adequate but with notable 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% for the single parameter (sessionId), so the schema already documents it. The tool description adds no additional parameter context beyond what the schema provides, hence 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 uses a specific verb ('Get') and a clear resource ('accessibility tree snapshot of the page'), with a stated purpose ('for AI-friendly element references'). It effectively distinguishes this from sibling tools like screenshot (visual), get_html (raw HTML), and get_text (text).

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

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

The phrase 'for AI-friendly element references' implies a clear usage context: use when you need a semantic, AI-accessible representation of page elements. However, it does not explicitly name alternatives or state when not to use it, so it falls short of the top score.

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 discloses a non-obvious behavioral trait—typing character by character to trigger key events—which is valuable for agent decision-making. It does not mention potential side effects like clearing existing text or requiring focus, but the core behavior is well covered.

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 front-loads the primary action ('Type text character by character') and appends the key use-case rationale, making it both concise and information-dense.

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 three parameters and full schema coverage, the description adequately explains the tool's purpose and distinctive behavior. It lacks explicit details on prerequisites or error behavior, but given the absence of an output schema and the straightforward nature of typing, it is reasonably complete.

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

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

The input schema already has 100% coverage for parameters with clear descriptions. The description adds a small semantic nuance to the 'text' parameter by implying sequential character input, but it does not significantly go beyond what the schema provides, 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 the tool types text character by character, a specific verb + resource. It distinguishes itself from siblings like browser_fill (likely bulk input) and browser_press (key presses) by emphasizing the character-by-character behavior and key event triggering.

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 parenthetical 'useful for triggering key events' provides clear context for when to use this tool over alternatives. However, it does not explicitly name alternatives or state when not to use it, so it falls short of full explicit guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without revealing any side effects, prerequisites, behavior on already-unchecked elements, or handling of invalid selectors, which is insufficient for an agent to predict the tool's behavior.

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

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

The description is extremely concise with a single, front-loaded sentence that directly states the tool's purpose. No words are wasted, making it easy for an agent to quickly parse the intent.

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

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

Given the lack of annotations and output schema, the description is insufficiently complete. It does not mention how the selector is used, session handling, or expected outcomes, leaving gaps in the agent's understanding for a functional tool.

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

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

The input schema describes both parameters (selector and sessionId) with 100% coverage, so the schema handles parameter semantics. The description adds no additional meaning beyond what the schema already provides, warranting 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 'Uncheck a checkbox' clearly states the action (uncheck) and the resource (checkbox), using a specific verb that distinguishes it from the sibling tool browser_check, which performs the opposite action. The purpose is unambiguous for an agent.

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_check or browser_click. There is no mention of context, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name.

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

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

With no annotations, the description carries the full burden for behavioral disclosure, but it only states the wait action. It does not explain timeout behavior, error handling, return values, or whether navigation completion is based on network idle or load events. This is a significant gap for a wait operation.

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

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

The description is a single, front-loaded sentence with no redundant wording. It is appropriately concise for a simple tool, though it could earn a higher score if it included key usage context without becoming verbose.

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

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

The tool is relatively simple, but the description is too minimal given the absence of annotations and output schema. It lacks context about when to use it, what happens on timeout, and how it relates to navigation actions. More detail is needed for an agent to use it successfully.

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 descriptions for both parameters (timeout and sessionId), so schema coverage is 100%. The description itself does not add parameter-specific meaning, which is acceptable given the high schema coverage; 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 a specific action ('Wait for navigation') with a resource ('navigation'), and the name distinguishes it from related tools like browser_wait_for_selector. However, it does not explicitly clarify what 'complete' means (e.g., load event, network idle), leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives, such as after browser_navigate or instead of browser_wait_for_selector. The description gives no context about typical usage scenarios or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without explaining polling behavior, timeout defaults, what happens on timeout, or that the state parameter can wait for detachment/hidden states. The word 'appear' is also misleading for non-visible states.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. It is efficient, though somewhat under-specified for the tool's complexity; still, it is appropriately concise.

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

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

For a wait tool with no output schema and no annotations, the description is too sparse. It does not cover return behavior, timeout semantics, or how the state parameter changes the waiting condition, leaving critical context for the agent to infer or discover through trial and error.

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

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

The schema already provides descriptions for all 4 parameters, achieving 100% coverage, so the baseline is 3. The description adds minimal meaning beyond the schema, only loosely connecting 'appear' to the state property without clarifying how selector, timeout, or sessionId are used.

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

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

The description uses a specific verb 'Wait for' with resource 'an element', clearly distinguishing it from the sibling browser_wait_for_navigation. However, 'appear' is narrower than the full state options (visible, hidden, attached, detached) exposed in the schema, so it does not fully capture all possible conditions.

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_wait_for_navigation or other polling strategies. No exclusions or alternative recommendations are given; the intended usage is only implied by the name and generic description.

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