acrawl

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

With no annotations, the description must carry the burden of behavioral disclosure. It indicates the tool returns violations grouped by impact level but does not detail potential side effects (none expected for a read-only audit), performance impact, or permission requirements. The behavior is adequately implied but not fully transparent.

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

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

The description is two sentences long, no redundancy, and the most critical information (what the tool does) is front-loaded. Every sentence serves a purpose.

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

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

Given three parameters, no output schema, and no annotations, the description covers the core functionality well. It could be slightly more complete by mentioning that the audit follows WCAG standards or that output includes actionable details, but it suffices for context.

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

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

Schema description coverage is only 33% (only 'scope' has a description). The description adds meaningful context for 'scope' by explaining its purpose. However, it does not elaborate on the 'impact' enum values or the 'standard' options, leaving room for ambiguity despite the schema providing enums and defaults.

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

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

The description clearly states it runs an axe-core WCAG accessibility audit on the current page, specifying the verb ('Run'), resource ('WCAG accessibility audit'), and scope ('on the current page'). It distinguishes itself from sibling tools like 'get_page_performance' and 'measure_coverage' by focusing specifically on accessibility.

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

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

The description explicitly advises using the 'scope' parameter to limit the audit to a specific DOM subtree, providing clear usage guidance. However, it does not mention when not to use the tool or suggest alternatives, though no direct alternative exists among siblings.

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

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

Discloses behavioral traits: closes browser tab, discards partial results, transitions to 'cancelled' status. No annotations provided, so description carries full burden. Lacks mention of side effects or reversibility, but sufficient.

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

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

Two concise sentences, front-loaded with action and effects, followed by usage guidance. No redundant or extraneous information.

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

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

Given the tool's simplicity (single parameter, no output schema), the description explains behavior and usage adequately. However, it does not mention the expected response or confirmation after cancellation, leaving a minor gap.

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

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

Schema coverage is 100%; the schema already describes the parameter with format and source. Description adds no additional parameter info, 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?

Description clearly states the action (abort a running script) and resource (running script). It specifies immediate closure of browser tab and discarding partial results. Distinguishes from siblings like run_script and script_status.

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?

Explicitly states when to use: 'Use when a script is stuck, taking too long, or its results are no longer needed.' Does not mention when not to use, but provides clear context.

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

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

With no annotations, the description carries full burden: it discloses potential side effects (navigation, form submission, dynamic content changes) and states the return value ('post-action page_state'). It also explains the 'widen' parameter's effect. Could mention scroll-into-view behavior, but overall satisfactory.

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

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

The description is two sentences: first states the core action and targeting methods, second provides usage guidance. Every sentence earns its place; no fluff.

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

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

Given 5 parameters and no output schema, the description covers the action, parameter usage, side effects, and return value. It does not explain error behavior (e.g., missing element), but is otherwise sufficiently complete 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?

Schema coverage is 100%, so the baseline is 3. The description adds significant value by explaining parameter usage concretely (e.g., 'Use selector for CSS/ref-based targeting') and describing the role and region parameters, which goes beyond the schema's field descriptions.

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

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

The description starts with a specific verb ('Click') and resource ('a page element'), then details two distinct targeting methods (CSS selector/@eN reference vs visible label text), which clearly distinguishes it from sibling tools like 'click_at' that use coordinates.

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

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

The description explicitly advises when to use 'selector' vs 'text' with roles and regions, and notes that text-based targeting is useful for SPAs and modals. It does not, however, contrast with sibling tools like 'click_at' or 'hover', so some usage guidance is implicit.

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

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

With no annotations, the description fully carries the burden. It discloses it uses a 'real mouse event', returns 'post-action page_state', and notes it is 'less reliable' than the selector-based click. It does not discuss rate limits or permissions, but for a clicking action this is adequate transparency.

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

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

The description is two sentences, front-loaded with the primary action, then usage guidelines. Every sentence adds value with no wasted words. It is highly concise and well-structured.

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

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

Given no output schema, the description mentions 'post-action page_state' which is sufficient for a click tool. It also references sibling tools. It might implicitly assume coordinates are within viewport, but overall it is complete for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds significant extra context: for 'widen' it explains default and full-page diff effect; for 'x' and 'y' it explains how to obtain them via getBoundingClientRect. This goes well beyond the schema definitions.

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 explicitly states 'Click at specific viewport coordinates (x,y) using a real mouse event' and distinguishes itself from the sibling 'click' tool by specifying exclusive use for elements without stable CSS selectors like canvas, maps, SVG regions. It provides a clear verb-resource pair and differentiates use cases.

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 explicit when-to-use ('exclusively for elements without stable CSS selectors') and when-not-to-use ('prefer the selector-based click tool for normal DOM elements'), along with instructions for obtaining coordinates via execute_js with getBoundingClientRect.

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 disclosure burden. It transparently reports that the script runs in the page's main frame with full DOM/window access and warns that return values may reflect pre-mutation state due to reactive frameworks, suggesting settle_ms as mitigation. It does not mention potential side effects like page navigation or security implications, a minor omission, but coverage is strong overall.

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 dense but well-organized: purpose and usage guidance are front-loaded, followed by parameter-specific details. Every sentence adds value, though the length is slightly longer than strictly necessary; it remains efficient and scannable.

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 an arbitrary-JS execution tool with no output schema, the description covers all critical aspects: script syntax, execution environment, async caveats, and optional parameters. An agent receives everything needed to call it correctly and avoid common pitfalls, making it complete for its complexity.

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

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

Despite 100% schema coverage, the description adds significant semantic depth: it explains the three valid script forms (expression, statement list, explicit return), supports top-level await, and details hover_selector's purpose (inspecting :hover styles) and settle_ms's role in handling async reactivity. This goes well beyond the schema's basic field descriptions.

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 verb ('Execute'), resource ('arbitrary JavaScript in the page context'), and explicitly differentiates it from siblings by calling out 'prefer click, fill_form, and select_option for standard interactions.' This makes the tool's unique role 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?

It provides explicit guidance on when to use: 'Use as a last resort when CSS selectors and other tools cannot achieve the interaction' and names concrete alternatives. It also explains when hover_selector and settle_ms are beneficial, giving context for parameter usage. No ambiguity remains about 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?

With no annotations, the description carries full burden. It discloses that fields are resolved by label text, works in modals and div-based UIs, and returns page_state with URL and structural diff. No contradictions.

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

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

The description is concise and front-loaded with the main action. Every sentence adds value, with no wasted words. Well-structured.

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

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

Given the complexity (4 parameters, nested object, no output schema), the description covers usage, behavioral traits, and parameter semantics well. It could detail return values more but is sufficient.

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

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

Schema coverage is 100%, but the description adds meaning: explains field identifier types, when form_selector is needed, and defaults for submit and widen. Adds value beyond the schema.

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

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

The description clearly states it fills form fields and optionally submits, with a specific verb and resource. It distinguishes from sibling tools like click, select_option, etc. by focusing on form filling.

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

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

The description provides clear context on when to use the tool and how to disambiguate multiple forms using form_selector. It doesn't explicitly state when not to use, but the guidance is sufficient.

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

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

No annotations are provided, so description carries the full burden. It discloses key behavioral traits: no DOM traversal or page refetch (lightweight read) and that all_tabs 'never switches tabs' (no side effect). It does not mention permissions or rate limits, but for a simple read-only info tool this is a minor gap.

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

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

Four sentences, front-loaded with the return values and scope. Slight redundancy between 'without any DOM traversal or page refetch' and 'lightweight metadata', but overall efficient and well-structured.

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

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

Given the simple read-only nature, no output schema, and 100% parameter coverage, the description is complete: it explains the return values, use case, and explains the optional all_tabs behavior. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so the schema fully documents the single all_tabs parameter. The description repeats its behavior ('set all_tabs=true to also list every tab...') with no additional syntax or constraints 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?

States a specific verb ('Get') and resource (current page URL, title, readyState), and immediately distinguishes from siblings by naming navigate() and page_map() as alternatives for different needs. An agent can tell this is the lightweight identity check tool without reading the schema.

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

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

Explicitly says when to use it ('ideal for confirming navigation or redirect outcomes between steps') and when to use alternatives ('Use this instead of navigate() or page_map() when you only need to verify the current page identity'). The condition 'only need to verify' implicitly rules out cases requiring deeper inspection.

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 cover behavioral traits. It accurately describes the output (specific metrics, top 20 resources). However, it does not mention any side effects, prerequisites (e.g., page must be loaded), or limitations (e.g., only works after page load). No contradictions.

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

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

The description is two sentences, front-loads the purpose, and every sentence adds value. No redundancy or fluff.

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

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

Given zero parameters and no output schema, the description is largely complete. It specifies the metrics returned and the environment. Minor omission: could clarify unit (e.g., milliseconds) or confirm the tool returns data from the current page state.

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

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

The input schema has zero parameters, and schema coverage is 100%. According to the guidelines, 0 parameters yields a baseline of 4. The description adds no parameter info but compensates by clearly describing the return data.

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 page performance metrics, names the APIs used (Navigation Timing and Resource Timing), and lists specific metrics (TTFB, DOM timings, top 20 resources). This effectively distinguishes it from sibling tools like list_resources or inspect_request, which provide different detail.

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 states it works on both browsers and SPAs, implying its usage for page-level performance analysis. However, it does not explicitly guide when to prefer this tool over alternatives like list_resources or inspect_request, nor does it mention 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?

No annotations exist, so description carries full burden. Discloses return values (URL and page_state) and behavior (equivalent to browser back). Could mention error cases (e.g., no history) but is adequate.

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

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

Three concise sentences with main action first. No redundant information. Every sentence adds value.

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

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

No output schema, but description explains return values (URL and page_state). Could detail page_state structure further, but given context signals, it's 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?

No parameters; schema coverage is 100% (none). Baseline for 0 params is 4. Description adds no param info because none needed.

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

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

The description clearly states the tool navigates back in browser history, equivalent to the back button. It distinguishes from siblings like 'navigate' by specifying it returns to the previous page.

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?

Explicitly says 'Use after clicking into a page to return to a listing or search results without re-navigating by URL,' providing clear when-to-use and implicit 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 provided, so description carries full burden. It states that hover triggers UI and returns page_state with revealed elements. However, it does not disclose hover duration, potential side effects (e.g., persistent menus), or error handling. Adequate but leaves 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?

Two concise sentences plus a usage tip. All sentences are meaningful and front-loaded with core purpose. No wasted words.

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

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

Given the tool's simplicity and lack of output schema, the description covers the main functionality: triggering hover-dependent UI and returning page_state. It differentiates from siblings. Missing details like error handling or asynchronous behavior, but these are acceptable for a straightforward tool.

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

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

Schema coverage is 100%, and the description does not add extra meaning to parameters. The schema already describes 'selector' and 'widen' adequately. No additional parameter context is provided in the description, so baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Hover the mouse over a page element to trigger hover-dependent UI such as tooltips, dropdown menus, or expandable content.' It distinguishes itself from sibling tools like click by specifying when to use hover instead. Strong verb+resource combination.

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?

Provides explicit guidance: 'Use this before click when content only appears on mouseover; use click instead if the element needs activation rather than hover.' This clearly contrasts with the click sibling. However, no exclusions for other scenarios (e.g., dynamic elements) are mentioned.

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

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

With no annotations provided, the description carries the full burden. It explicitly lists what the tool returns (domain, path, expiry, flags, security issues) and mentions capabilities (third-party detection, filtering). It does not claim any side effects, which is consistent with an inspection tool. A minor gap is not stating read-only behavior explicitly, but the context implies it.

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

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

The description is two sentences, front-loading the core purpose and then detailing the return content. Every phrase adds value: 'security analysis', the enumerated issues list, 'third-party detection', 'filtering options'. No redundant or filler text.

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 read-only inspection tool with two optional parameters and no output schema, the description is sufficiently complete. It covers the return value comprehensively, mentions filtering, and lists specific security issues. The context (current page, security analysis) sets proper expectations. No additional information is needed for correct usage.

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

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

The input schema describes both parameters (domain and issues_only) with clear descriptions. The tool description adds 'filtering options' but does not elaborate beyond what the schema already covers. Since schema coverage is 100%, the baseline is 3. The description provides no additional semantic nuance beyond the schema.

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

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

The description clearly identifies the tool's action ('Inspect cookies'), resource ('the current page'), and the specific value-added feature ('with security analysis'). It enumerates the output fields including security issues, which distinguishes it from any potential generic cookie getter. Since there are no direct sibling tools for cookies, it is unambiguous.

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

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

The description states the tool inspects cookies on the current page, implying it should be used when cookie inspection is needed. It mentions filtering options (domain, issues_only) and third-party detection, providing context for use. However, it does not explicitly exclude when not to use it (e.g., if only basic cookies are needed) or name alternatives, but the absence of sibling cookie tools makes this less critical.

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 provided, so description carries full burden. It discloses that the tool returns concrete instances with specific data. While it doesn't explicitly state it's read-only or non-destructive, the inspection nature is clear and no side effects are implied.

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 of 18 words. It is front-loaded with the purpose and contains no unnecessary information, making it highly concise and effective.

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 inspection tool with 2 parameters and no output schema, the description adequately explains the input (id from list_page_logs) and output (instances with details). Minor omission: no mention of pagination or behavior when limit is exceeded, but likely not critical.

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 baseline is 3. The description adds minimal semantic value beyond the schema, as it reiterates the id source (list_page_logs) and limit behavior which are already in schema descriptions.

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

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

Description clearly states the verb 'inspect', the resource 'a deduplicated console log group', and specifies the returned details (timestamps, stack traces, source locations). It distinguishes from sibling tool list_page_logs by indicating this tool inspects a specific group from that output.

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?

Description implies usage after list_page_logs with group_by='message', providing clear context. It does not explicitly state when not to use or name alternatives, but the guidance is sufficient for typical use.

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

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

No annotations provided, so description carries burden. It discloses return content: metadata, timing, initiator type, notes on unavailability. Does not mention side effects or permissions, but read-only nature is implied.

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

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

Two sentences, no wasted words. Front-loaded with verb and resource, then return details. Efficient and clear.

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

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

No output schema, but description adequately lists return information. Notes unavailable headers/bodies. For a simple inspection tool with 2 params, it is sufficiently complete.

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

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

Schema covers id with description, include_body has default but no explanation of effect. Description mentions return content but does not describe how include_body alters output. Schema coverage is 50%.

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

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

Description clearly states the verb 'inspect', the resource 'network request', and the specific identifier 'list_network_activity'. It distinguishes from sibling tools like list_network_activity and inspect_websocket.

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?

Description specifies to use after list_network_activity with an @rN id, implying context. It does not explicitly state when not to use or list alternatives, but the context is clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns key-value pairs with size info, but does not mention performance impact, permission requirements, or whether it is a read-only operation (which is implied but not explicit).

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

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

Two sentences, each serving a purpose: first states the core action, second lists return details and filtering. No wasted words, 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 two-parameter tool with no output schema, the description covers the essential functionality. It could mention that it only works on browser pages or requires a loaded page, but it is generally sufficient.

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

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

Schema description coverage is 100%, so the description adds minimal value beyond the schema. It repeats filtering by storage type and key pattern, but does not provide additional semantics or examples.

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 inspects browser storage (localStorage and sessionStorage) on the current page, returns key-value pairs with size info, and supports filtering. This distinguishes it from siblings like inspect_cookies or inspect_request.

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 mentions filtering capabilities but does not explicitly state when to use this tool versus alternatives like inspect_cookies or inspect_request. It implies usage for inspecting storage but provides no exclusions or when-not 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, the description carries the full burden. It lists supported features (direction filter, pattern search, sort_by) but does not disclose whether the operation is read-only, auth requirements, or potential side effects. 'Inspect' implies non-destructive, but it is not explicit.

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

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

Two concise sentences: first states purpose, second lists prerequisites and features. No fluff, well front-loaded. Every sentence adds value.

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

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

Given 5 parameters and no output schema, the description covers core purpose and main features but omits details on the return format, direction enum meanings, and limit parameter. It is adequate but incomplete for a tool with moderate complexity.

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

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

Schema description coverage is 40% (id and pattern have descriptions). The description reinforces the id parameter source and mentions direction, pattern, and sort_by features, but does not explain the limit parameter or detail enum values. It adds some value but not enough to fully compensate for low coverage.

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

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

The description clearly states the tool's purpose: 'Inspect actual WebSocket messages for a connection.' It specifies the resource (WebSocket messages) and the action (inspect), and uniquely differentiates from siblings by requiring an ID from list_websocket_activity and listing supported features.

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

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

The description provides a clear prerequisite: 'Provide @wsN ID from list_websocket_activity.' This guides the agent to use it after listing activity. It implicitly distinguishes from other inspect tools by focusing on WebSocket. However, it does not explicitly state when not to use this tool.

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

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

With no annotations, the description must carry behavioral disclosure. It reveals rules are additive and refresh() needed to apply, but does not mention persistence across navigations, side effects, or rule lifecycle (e.g., whether rules survive tab refresh). Partial but not comprehensive.

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?

Three sentences, each adding distinct value: purpose, additive behavior, and usage tip. No wasted words; front-loaded with main action.

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

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

For a complex tool with 4 parameters and nested objects, description covers basic usage but misses details like how to view active rules, rule ordering, or conflict resolution. Adequate but not thorough.

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 baseline is 3. Description adds value by explaining glob pattern syntax with examples and regex prefix ('re:'), which goes beyond the schema's brief descriptions.

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 explicitly states the tool manages network interception rules, with actions like block and mock. It clearly distinguishes from sibling inspection tools (e.g., inspect_request) by focusing on modifying network behavior.

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?

Provides usage guidance: rules are additive and require refresh() after adding. Lacks explicit when-not-to-use or alternatives, but the additive nature and refresh requirement are helpful 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, the description carries full burden. It discloses that network capture starts automatically at browser launch and that results return stable @rN refs. However, it does not mention whether listing clears buffered data or 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 very concise (two sentences), front-loads the purpose, and lists capabilities 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?

The description covers the tool's purpose, filtering capabilities, and return format (stable refs). It mentions an inline 'content_type' field but could be improved by explicitly describing the structure of each row in the output.

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 high (80%), so the baseline is 3. The description summarizes filtering capabilities but does not add significant new meaning beyond the schema's parameter descriptions.

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 explicitly states the verb 'List' and resource 'observed network requests buffered during this browser session.' It distinguishes from siblings like 'inspect_request' by noting that this tool returns stable @rN refs for follow-up inspection.

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

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

The description provides clear context on when to use the tool (to list network requests) and mentions a follow-up sibling ('inspect_request'). However, it does not explicitly state when not to use it or alternative tools.

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

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

With no annotations, the description carries the full burden. It discloses that logs are buffered, deduplicated by default with @logN IDs, and that temporal filtering uses half-open intervals on seq_at_initiation. This is detailed but could mention if there are limits or truncation.

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

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

Two sentences, front-loaded with purpose, and no wasted words. Each sentence adds essential information.

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

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

Given 4 parameters, no output schema, and no required params, the description covers grouping and temporal filtering reasonably well. It mentions @logN IDs linking to inspect_log. Missing explicit output format but that's acceptable without output schema. Minor gap: no mention of pagination or limits.

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%, but the description adds significant meaning beyond schema: explains that 'message' grouping deduplicates and assigns IDs, 'source' groups by file, 'level' by severity; what 'all' means for level; and half-open interval for since/until. This enhances understanding.

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

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

The description clearly states it lists buffered console logs with optional filtering, matching the name. It distinguishes from siblings like inspect_log and list_network_activity by specifying it deals with console logs and grouping by message, source, or level.

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 explains when to use it (to list logs with optional filters and grouping), but does not explicitly state when not to or contrast with alternatives like inspect_log. However, the context is clear enough for an AI agent to infer appropriate use.

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

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

No annotations provided, so description carries full burden. It states returns complete set without caps, which is clear. However, it doesn't mention potential side effects (likely none) or response format specifics like JSON array structure.

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

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

Two sentences, front-loaded with purpose, then usage guidance. Every sentence adds value; no unnecessary words.

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

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

Given no output schema, description mentions returned fields per resource type but doesn't specify exact return structure (e.g., array of objects). However, for a simple list tool, it's fairly complete and covers key aspects.

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

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

Schema has zero parameters and description confirms 'No parameters required.' This is clear and sufficient, adding value by explicitly stating no input needed.

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

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

Clearly states it lists discoverable resources on the page, specifying types (links, images, forms) and their properties. Explicitly distinguishes from sibling page_map by mentioning the 50-link limit and image URL capability.

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?

Provides explicit guidance on when to use: when page_map's limit is insufficient or when image URLs are needed. This directly helps agent select between sibling 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?

No annotations provided, so the description carries the full burden. It discloses the output format (JSON array) and metadata fields, implying a read-only operation. However, it does not mention side effects, pagination, or whether results are sorted. The description is adequate but could be more explicit about the lack of modifications.

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?

Three sentences, each valuable: first states action and result, second clarifies output format, third provides usage guidance. Front-loaded and no unnecessary words.

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

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

Given no output schema, the description provides essential metadata fields and usage context. It differentiates from siblings well. While the exact JSON structure is not detailed, the listed fields are sufficient for a simple list tool. Could improve by specifying property names or sorting 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 tool has 0 parameters, and the schema coverage is 100%. Baseline for 0 parameters is 4. The description does not add parameter information, but none is needed. It implicitly confirms no inputs, 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 uses the specific verb 'List' and clearly identifies the resource as 'all previously saved scripts'. It provides metadata fields and explicitly distinguishes from sibling tools like run_script by stating 'Use to discover available scripts before running them with run_script by 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 gives clear usage contexts: discovering scripts before running them or auditing existence. It mentions a specific alternative (run_script) by name, but does not explicitly state when not to use the tool or list other alternatives like read_script.

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 provided, so description carries full burden. It states outputs (connections with IDs) but does not disclose behavioral traits like pagination, latency, or whether it's read-only. As a list tool, it's likely read-only, but this is not stated.

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

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

Two concise sentences that efficiently convey the tool's purpose, output format, and a pointer to a related tool. No wasted words.

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

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

Given no output schema and no annotations, the description provides sufficient context about what the tool returns and how to get more detail. It lacks mention of result ordering or limits, but overall is adequate for a list operation.

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

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

Schema coverage is 100%, and both parameters are described in the schema. The description does not add extra meaning beyond what the schema already provides for 'since' and 'until', so 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 it provides an overview of WebSocket connections and message counts, returns connections with @wsN IDs, and distinguishes from inspect_websocket by directing to that tool for message content.

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

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

It explicitly mentions using inspect_websocket for actual message content, providing a clear when-to-use distinction. However, it lacks explicit when-not-to-use or alternatives 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?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states the tool returns per-file byte usage but does not mention potential side effects (e.g., whether it modifies page state) or prerequisites (e.g., page must be fully loaded). For a read-only measurement tool, this is adequate but 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?

The description is two sentences, front-loading the key action and resource, and wastes no words. Every sentence serves a purpose: stating function, describing output, and listing use cases.

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 two parameters, no output schema, and no annotations, the description adequately covers purpose, output shape (per-file bytes used vs total), and applicability. It could mention return format details, but overall it is complete enough for an agent to understand invocation intent.

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

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

With 100% schema description coverage, the baseline is 3. The description does not add additional meaning to the parameters beyond what the schema already provides (reset and type enums). It focuses on output instead.

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 measures JavaScript and CSS code coverage on the current page, specifying the verb (Measure) and resource (code coverage). It distinguishes from sibling tools like get_page_performance by focusing on coverage rather than performance metrics.

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 explicit use cases: identifying unused bundles, oversized dependencies, and optimization opportunities. While it doesn't explicitly state when not to use it or name alternatives, the context is clear enough for an agent to decide.

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 and does well: it discloses the automatic HTTP-to-headless escalation with the JS-detection heuristics (React, Next.js, Vue, Angular, short noscript bodies), the composite return of prose plus a YAML accessibility tree, and the token-saving pruning behavior. It omits any mention of auth requirements, rate limits, or page-size caps, so it stops short of a 5.

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?

Four sentences, front-loaded with the purpose and format options, then escalation behavior and return shape. It is dense and earns its space, though the escalation-heuristics sentence is packed tightly and could be slightly leaner.

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 6-parameter tool with no output schema, the description covers the return structure (fit_markdown prose plus a YAML accessibility tree for follow-up calls) and the fetch-escalation model. It is nearly complete, missing only edge-case behavior for failures or blocked pages.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters well, including enums and defaults. The description largely restates what the schema provides (format options, boilerplate pruning), adding only the ~40% token-savings figure that is itself also in the schema, so the baseline 3 is appropriate.

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

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

States a specific verb+resource (navigate to a URL and return page content) and enumerates the four output formats. It explicitly positions itself as the primary web-access tool, which distinguishes it from siblings like read_content, page_map, and refresh.

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?

'Use this as the primary tool for accessing any web page' gives clear default guidance, and it names a fallback condition ('Use markdown if fit_markdown seems to be missing important content'). However, it never names alternative tools (read_content, page_map) or states when NOT to navigate, so routing among siblings is left partly implicit.

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

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

No annotations are provided, so the description must carry the burden. It does not disclose whether the operation is read-only, permissions required, or performance implications. The get verb implies read but safety is not explicit.

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 very concise and front-loaded. Two sentences cover purpose, node format, scope, and depth with no wasted words.

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

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

Given the tool's simplicity (2 params, no output schema, no annotations), the description provides adequate context including the output format and parameter usage. Minor gaps like default behavior with no scope are tolerable.

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

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

Schema description coverage is 100%, so baseline is 3. The tool description adds no new meaning beyond what the schema already provides for depth and scope.

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

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

The description clearly states it retrieves the YAML accessibility tree and provides the node format. It is a distinct purpose among siblings but does not explicitly differentiate from similar tools like audit_accessibility.

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 on when to use this tool versus alternatives. The description implies its use for structural view but lacks explicit when-to-use or when-not-to-use 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?

Discloses that it returns post-action page_state reflecting DOM changes. Lacks details on error handling or permissions, but otherwise sufficient for a simple event dispatch 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?

Three well-structured sentences with front-loaded purpose. Every sentence adds value; no repetition or fluff.

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

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

No output schema, but description explains return value. Covers all parameters and use cases adequately for a low-complexity 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%, baseline 3. Description adds valuable context for all three parameters: key format, selector usage, and widen behavior.

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?

Clear verb 'Dispatch' with specific resource 'keyboard key press event on page or targeted element'. Lists supported keys and use cases, distinguishing from sibling tools like click or hover.

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?

Explicitly states use cases for form submission, closing modals, focus navigation, or keyboard shortcuts. Does not explicitly mention when not to use, but context is clear.

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 exist, so description carries full burden. It discloses return fields (content, character count, more available), pagination behavior, and hints at heading-not-found behavior (lists available headings). Could add more detail on error handling but covers core behavior well.

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

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

Two sentences, front-loaded with purpose, includes usage guidance at the end. No redundant or irrelevant content.

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

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

For a tool with 4 parameters, no annotations, no output schema, description covers usage context, behavior, return values, and alternatives. Slightly lacking in describing exact response format or error handling, but sufficient for basic use.

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

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

Schema coverage is 100% with detailed parameter descriptions. The description reinforces usage patterns (pagination, alternative selector) but does not add significant new semantic information beyond the schema.

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

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

The description clearly states the tool extracts plain text from a page section using heading name or CSS selector. It distinguishes from siblings page_map and navigate by specifying when to use each.

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?

Explicitly states when to use: after page_map to read specific sections without re-fetching, or use navigate for full page content. Also describes pagination support with max_chars and offset.

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?

Without annotations, the description carries the full burden. It transparently states the return value ('complete script object including version, steps, and limits'), which adds useful behavioral context. However, it does not explicitly confirm it is a read-only operation with no side effects, though 'read' strongly implies this.

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

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

The description is two sentences long, front-loading the core purpose and following with usage guidance. Every word adds value; there is no redundancy or unnecessary detail.

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

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

For a simple read tool with one parameter and no output schema, the description fully covers what the tool does, what it returns, and when to use it. It is sufficient for an agent to understand and select the tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not add any additional meaning beyond the schema's existing parameter description (name, format, source). No extra context or clarification is provided.

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 ('Read the full JSON definition') and the resource ('a previously saved script'). It distinguishes itself from sibling tools like list_scripts (which lists names) and run_script (which executes), making the purpose unambiguous.

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

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

The description provides explicit usage scenarios: 'Use to inspect a saved script's logic before running it, or to understand what an existing script does before modifying and re-saving it.' This gives clear context for appropriate use, though it does not explicitly state when not to use it or name alternatives for exclusion.

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, so description carries full burden. It mentions returning page_state and seq increment, but lacks details on side effects like losing unsaved data, though implied by reload.

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?

Three concise sentences, front-loaded with purpose, then usage context, then return detail. No redundancy.

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

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

For a no-parameter tool without output schema, it adequately explains action, timing, and return behavior (page_state with seq increment).

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?

Zero parameters; baseline score is 4. Description adds no parameter-specific info but explains the return value, which 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 'Reload the current page' with a specific verb and resource, and distinguishes from siblings like 'navigate' or 'go_back'.

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?

Provides explicit context: 'Use after setting intercept rules to replay the page with rules active.' It doesn't list when not to use, but the use case is clear.

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 were provided, so the description carries full burden. It discloses autonomous behavior, LLM loop usage, and structured output, but lacks details on potential side effects like cost, rate limits, or that it may invoke other tools internally.

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?

Three concise sentences: core action, how it works, usage guidance. No redundancy, every sentence adds value and is front-loaded.

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

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

Given the tool's complexity (autonomous goal execution) and absence of an output schema, the description is fairly complete. It covers purpose, behavior, and usage context, though it could mention that the agent can be restricted via the allowed_tools parameter (already in schema). Minor omission.

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

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

Schema coverage is 100% with descriptions for all parameters. The tool description does not add additional meaning beyond what the schema already provides, earning the baseline score of 3.

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

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

The description clearly states it executes a high-level crawl goal autonomously, using an LLM loop to plan, navigate, and extract data. It contrasts itself from sibling tools like navigate, click, etc., making its unique 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?

Explicitly states to use this for complex multi-page tasks and to use individual tools for fine-grained control. Provides clear context on when this tool is appropriate versus 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 the burden well: it discloses async semantics ('returns a script_id immediately'), the collection path (wait_for_scripts), that execution happens on a cloned tab, and that save_as persists to disk. It does not say what happens on partial failure — how far a script progressed before erroring, or which steps mutated state — which matters for a tool that invokes arbitrary tool calls.

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?

Front-loaded with the action, then the async return contract, then the usage trigger — the right ordering. The capability enumeration (loops, conditionals, try/catch, parallel, variable capture) partially overlaps the schema, but it usefully signals scope before the agent commits to reading the full step grammar.

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 complex tool with a very rich 4-param schema and no output schema, the description covers the async lifecycle, result collection, persistence, and the decision trigger. What's left out is failure/partial-completion semantics and the eventual result shape, the latter of which the sibling script_status/wait_for_scripts presumably cover.

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

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

Schema coverage is 100% and the schema itself documents name/script/limits/save_as in depth, so baseline 3 applies. The description only restates the mutual exclusivity of inline script vs. saved name, which the schema already states explicitly; it adds no syntax or constraint detail beyond it.

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

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

Specific verb + resource ('Execute a deterministic multi-step script') with the differentiator spelled out: no per-step LLM round-trips, running on a cloned browser tab. That framing distinguishes it from execute_js (single JS eval) and run_goal (agentic loop) without the agent needing to open those schemas.

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?

Gives an explicit trigger heuristic ('when you detect a repetitive pattern — same operation on 3+ pages/items') and names the required follow-up (wait_for_scripts) as well as the inline-vs-saved-name alternative. The agent knows both when to reach for this tool and what to do next.

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, description carries full burden. It mentions HTTP GET, any file type, returns absolute path, and path traversal blocking. However, lacks details on error handling, size limits, or overwrite 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?

Three sentences front-loaded with purpose, then general capability, then use case. No superfluous content.

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

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

No output schema, but return value is simple. Parameters well-documented. Missing error/edge-case info, but overall adequate for a file download tool.

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

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

Schema description coverage is 100%, but description adds value: notes path traversal blocked for filename, subdir auto-created. Provides usage hints beyond schema.

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

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

Clearly states 'Download a resource from a URL and save it to the local output directory.' This gives specific verb and resource, distinguishing it from all browser-interaction sibling tools.

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?

Explicitly says 'Use to persist crawl artifacts' and mentions security constraint. Provides clear context but does not explicitly state when not to use or alternative tools.

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

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

The description discloses the save location, file format, overwrite behavior, and relationship with run_script, providing sufficient transparency beyond the lack of annotations. No contradictions.

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?

Three sentences, front-loaded with the main action, no redundancy, each sentence serves a purpose.

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

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

The description is mostly complete for a save operation but lacks details on return values, error conditions, or confirmation of success. Given the absence of an output schema, this is a minor gap.

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

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

The description adds value beyond the input schema by specifying uniqueness and overwriting for 'name' and referencing 'script' parameter format from run_script, with schema coverage at 100%.

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 (persist/save), resource (script definition to disk at a specific path), and distinguishes from sibling tools like run_script and list_scripts by explaining the reuse purpose.

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

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

The description explains when to use (complex extraction patterns for repeated use) and mentions the alternative (use run_script to run saved scripts), though it does not explicitly state 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?

With no annotations, the description discloses key behaviors: returns base64 by default or saves to disk when save=true. It does not cover all edge cases (e.g., waiting for page load, animation side effects), but provides sufficient transparency for most use 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?

Two sentences, front-loaded with the core action, followed by essential advisory context. Every word earns its place; no redundancy.

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

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

Despite lacking an output schema, the description explains return types (base64 data or file path) and covers all capture modes and optional parameters, making the tool fully self-contained.

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%, but the description adds valuable aggregation: it summarizes the three capture modes (viewport, element, full page) and the distinction between base64 and file output, surpassing the individual parameter descriptions.

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

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

The description clearly states the tool's purpose: 'Capture a screenshot of the current page viewport, a specific element, or the full scrollable page.' It distinguishes from sibling tools by positioning it as a last resort after text-based tools, making the purpose unambiguous.

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

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

Explicitly advises to use 'as a LAST RESORT only after text-based tools (page_map, read_content, execute_js) have failed,' providing clear when-to-use and when-not-to-use guidance with named 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, description fully carries burden. It accurately states non-blocking nature and lists return values. No contradictory or omitted behavioral traits for a read-only status check.

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

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

Two concise sentences: first explains functionality and outputs, second gives usage directive. No redundant words, front-loaded with essential info.

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 a single parameter, no output schema, and low complexity, the description fully covers what the tool does, its return values, and usage context. No gaps.

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

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

Schema coverage is 100% and schema already describes script_id format and source. Description adds no extra parameter information beyond the schema, 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?

Clearly states the tool checks execution status of a script without blocking, and enumerates returned fields (state, step count, data, error). Distinguishes from sibling wait_for_scripts by mentioning non-blocking behavior.

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?

Explicitly advises using this tool to monitor long-running scripts between other actions, and directs to wait_for_scripts for blocking completion. Provides clear when-to and when-not-to guidance.

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

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

No annotations are provided, so the description carries the full burden. It informs that the tool returns updated page_state after scrolling and reflects lazy-loaded content, adding valuable behavioral context beyond the basic scroll action.

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

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

Three sentences, each serving a distinct purpose: what it does, what it returns, and when to use. No unnecessary words, efficient 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 2-parameter tool with no output schema, the description covers the action, return value, and usage scenarios adequately. It is complete for an agent to understand and use the tool correctly.

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

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

Schema coverage is 100%. The description adds practical guidance, e.g., pixel range '300–800 for a normal page scroll' and 'larger values for quickly reaching page bottom', which is helpful beyond the schema definitions.

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

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

The description clearly states it scrolls the page up or down by a specified pixel amount, a specific verb+resource. It distinguishes from sibling tools like click, navigate, and press_key by focusing on viewport manipulation.

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 provides explicit use cases: reveal below-the-fold content, trigger infinite scroll, navigate long pages. While not explicitly stating when not to use, the guidance is clear and contextually appropriate given the sibling set.

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?

Despite no annotations, the description fully discloses behavior: selection triggers page changes, returns page_state, fallback matching for custom dropdowns, and widen parameter effect.

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?

Four succinct sentences, front-loaded with purpose, no redundant information. Efficiently 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?

Covers return value, alternative usage modes, and parameter options. Missing error handling details but sufficient for common use cases given no output schema.

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

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

Schema coverage is 100%, so baseline 3. The description adds value by explaining the enumeration mode when all optional params omitted, which goes beyond individual parameter descriptions.

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

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

The description clearly states it selects an option from a native select or custom dropdown, and also describes the enumeration behavior. It distinguishes from sibling tools like click and fill_form.

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?

Explains when to use each parameter (value, label, index) and the enumeration use case. Does not explicitly exclude other tools but provides clear context.

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

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

No annotations are present, so the description carries the full burden. It discloses that the browser context is recreated, cookies and localStorage are preserved, desktop-class presets affect the real window, and it returns page_state. It also warns about the sub-agent limitation.

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 dense but each sentence adds a distinct fact: purpose, context recreation, preset behavior, preservation, custom vs preset usage, return value, and constraint. It is front-loaded with the main purpose and follows a logical order with no filler.

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

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

For a 6-parameter tool with no annotations and no output schema, it explains return value, side effects, and constraints. The only minor gap is not explicitly stating what happens to the current page (e.g., whether it reloads), though 'recreates the browser context' strongly implies it.

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 baseline is 3. The description adds meaning beyond the schema by explaining preset behavior ('Mobile presets emulate an exact viewport; desktop-class presets resize the real browser window...') and clarifies that 'desktop' imposes no size. It also gives guidance on choosing presets vs custom fields.

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

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

States a specific verb and resource: 'Switch browser device emulation between mobile and desktop modes.' There are no sibling tools with the same purpose, and the description clearly differentiates this from navigation, scrolling, and other browser action tools.

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?

Provides clear context for when to use preset names vs custom parameters, and distinguishes mobile vs desktop behavior (exact viewport vs real window resize). It also discloses a hard constraint ('Cannot be used while sub-agents are running'). Though it doesn't compare with alternatives, no sibling tool serves the same function.

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 explains the side effect (focus changes), the return value (tab count), the conditional page_indices field, and the page_state object with headings, landmarks, and links. It doesn't describe behavior for an omitted or out-of-range index, which is a small 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 two tight sentences: the first covers the action and return payload, the second covers when to use the tool. There is no filler and no repetition of schema details.

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

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

For a single-parameter tool, the description is quite complete: it states the behavior, the return shape, and the intended use cases. The notable omission is behavior when index is omitted or invalid, especially since the schema lists no required parameters.

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 describes the index as zero-based and tells the agent to use the tab count from previous responses, giving 100% schema coverage. The description reinforces the index-based switching but adds little 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 states the exact action ('Switch the browser focus'), the resource ('a different open tab'), and the selection criterion ('by its zero-based index'). This clearly distinguishes it from navigation siblings like navigate or go_back, which change or move through page history rather than reusing an already-open tab.

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

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

The description gives explicit use cases: 'access pages opened by link targets, popups, or forked sub-agents without re-navigating.' It conveys the right context for choosing this over navigate, though it doesn't explicitly name alternatives or state 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?

With no annotations provided, the description carries the full burden. It explains return behavior (page_state or completion signal), the effect of 'silent', and the mutually exclusive parameters. However, it does not specify the default timeout or behavior if neither 'selector' nor 'seconds' is provided, which is a minor gap.

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

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

The description is concise, consisting of three well-structured sentences. It front-loads the main purpose, then provides usage context, and finally details the return behavior. Every sentence adds value without redundancy.

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

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

Given the complexity (4 parameters, no output schema, no annotations), the description covers usage, parameter details, and return values well. However, it lacks explicit mention of default timeout or what happens if both 'selector' and 'seconds' are omitted, which 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?

Schema coverage is 100%, providing a baseline of 3. The description adds significant value beyond the schema by explaining each state enum value, clarifying the 'silent' parameter, and explicitly stating the mutual exclusivity of 'seconds' and 'selector'. This extra context earns a score of 5.

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

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

The description clearly states the tool waits for a DOM element to reach a specific state or pauses for a fixed duration. It uses specific verbs and resources, and distinguishes from sibling tools like 'wait_for_scripts' by focusing on DOM element states and timed pauses.

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

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

The description explicitly states when to use: 'Use after actions that trigger asynchronous page changes...'. It provides context for usage but does not explicitly mention when not to use or name alternatives, though the differentiation from siblings is implied.

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

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

No annotations provided, so description carries full burden. It mentions blocking behavior and return structure (JSON array with specific fields). However, it does not disclose timeout behavior, error handling, or what happens if scripts never finish. Acceptable but could be more thorough.

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

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

Two sentences, front-loaded with primary purpose, then details on return and optional behavior. No wasted words.

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

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

Given simple tool with one optional param and no output schema, description adequately covers purpose, usage, return shape. Lacks timeout or error handling info, but not critical for this tool's typical use.

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

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

Schema coverage 100% with only one param. Description adds behavioral nuance: omitting script_ids waits for all active scripts. This adds value beyond the schema's description of 'List of script IDs'.

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?

Clearly states it blocks waiting for script execution and returns results. Distinguishes from siblings like run_script (initiates) and script_status (check status without blocking). Also covers behavior when script_ids omitted.

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?

Explicitly recommends using after run_script to collect results. Implicitly suggests not using if scripts haven't been started. Could be improved by mentioning not to use if non-blocking check is needed.

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