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 explicitly states 'Side effects: none (read-only)', the prerequisite of an active Chrome tab, and the return type (base64 encoded image). It also clarifies the full_page behavior. This is exceptionally transparent for a tool without annotations.

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

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

The description is compact yet structured with clear labels (Side effects, Prerequisites, Returns, Alternatives). Every sentence earns its place, and there is no filler or repetition beyond a minor but acceptable mention of base64 in the first and Returns sentences.

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

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

This is a mutating? no, read-only tool with no output schema and no annotations. The description covers side effects, prerequisites, return value, common use case, and alternatives. For a screenshot tool with 5 optional parameters and no output schema, this is complete enough for an agent to call it correctly and interpret the result.

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

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

Schema description coverage is 100% with each parameter already providing defaults, constraints, and interactions. The description adds no new parameter-level meaning beyond what the schema states—it only mirrors full_page behavior and mentions base64 output. Per the rubric, baseline 3 applies when the schema does the heavy lifting.

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

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

The description uses a specific verb ('Captures') and resource ('visual representation of the current page viewport or entire page'), and states the output as a base64 encoded image. It also explicitly names alternatives (inspect_dom, get_performance_metrics), making the tool's unique purpose clear.

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

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

The description explicitly states when to use the tool ('Use this to visually verify UI state, layout, or rendering') and provides alternatives with their specific use cases ('inspect_dom for raw HTML structure', 'get_performance_metrics for rendering metrics'). It also notes the prerequisite of an active Chrome tab, giving clear operational context.

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

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

With no annotations provided, the description carries the full burden of disclosure. It clearly lists side effects (page navigation, form submission, DOM state change), prerequisites (visibility), and the return value (click coordinates). This is comprehensive and does not contradict any structured data.

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

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

The description is three purposeful sentences, front-loaded with the main action and side effects, with no filler or repetition. Every sentence contributes 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?

The description covers purpose, side effects, prerequisites, alternatives, and return value. With no output schema, it explains what to expect (click coordinates). For a click tool, this is complete; 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 baseline is 3. The description does not add new meaning to the parameters themselves; the only extra context, the selector mutability constraint, is already present in 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 states a specific action ('triggers a native mouse click'), identifies the resource ('DOM element identified by CSS selector'), and notes the effects ('click handlers and form submissions'). It also distinguishes from siblings by naming alternatives like fill_input and evaluate_js.

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 lists the intended use cases (buttons, links, checkboxes) and names the alternative tools for text input and complex interactions, giving clear routing. It also mentions the prerequisite that the element must exist and be visible.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly describes side effects (destructive for secondary instances, special handling for 'default') and the return format (structured JSON with instance_id and removal status). No behavioral aspect is left undocumented.

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 thorough yet every sentence serves a purpose: core action, side effects, return value, usage context, and alternatives. It is front-loaded with the primary verb and resource, and the logical progression aids comprehension without any 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?

This tool has nuanced behavior (different outcomes for default vs. other instances) and no output schema, yet the description covers all necessary context: side effects, return structure, when to use it, and alternatives. An agent can invoke it correctly without needing additional information.

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

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

The schema description covers 100% of the single parameter, including the critical difference between 'default' and other instances. The description does not add parameter-level detail beyond the schema, so a baseline score of 3 is appropriate. The contextual reinforcement in the description is helpful but redundant with the schema.

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

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

The description clearly states the action: 'Closes and stops the specified Chrome instance by id.' It also distinguishes itself from siblings by naming alternatives like stop_chrome and close_tab, so an agent can immediately understand what this tool does that others do not.

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 guidance: 'Use this to free resources used by sessions created with open_instance.' It also lists alternatives with their distinct purposes, making it unambiguous when to call this tool versus stop_chrome or close_tab.

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 disclosure burden. It discloses side effects (destructive, removes tab from registry, closes in Chrome, active tab handling) and return value structure. This is comprehensive and goes beyond minimal requirements.

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

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

The description is structured logically: purpose, side effects, prerequisites, return, usage, alternative. It is appropriately sized with no redundant sentences, and the core purpose is front-loaded.

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

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

For a tool with two parameters (one required) and no output schema, the description explains the return value, side effects, and usage guidance sufficiently. It also integrates with sibling tool context, making it complete for an agent to invoke correctly.

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

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

Schema description coverage is 100%, so the schema itself fully documents both parameters. The description adds some context (e.g., prerequisite of tab existing) but does not provide additional parameter-level semantics beyond what the schema already states, aligning with the baseline of 3.

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

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

The description states a specific verb and resource ('Closes a specific tab by its registered Tab ID') and differentiates from sibling tools like 'close_instance' by explicitly naming it as an alternative. This makes the tool's purpose unmistakable.

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

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

It clearly indicates when to use the tool ('Use this to clean up tabs you no longer need'), states prerequisites ('the tab must exist (see 'list_tabs')'), and names the alternative ('close_instance' to stop a whole Chrome instance). This explicitly guides selection 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?

With no annotations, the description carries the full burden. It discloses side effects (may modify DOM, state, trigger network requests), prerequisites, return behavior (JSON-serializable values, error on promise rejection), and context requirements. This is comprehensive, though it omits details like potential CSP restrictions or permission scopes, leaving 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 dense but every sentence earns its place: purpose, side effects, prerequisites, return, usage, and alternatives. It is well-structured and front-loaded with the core purpose, though the inclusion of both prerequisites and usage could be slightly streamlined without losing 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?

For a side-effect-capable tool with no annotations or output schema, the description covers all essential aspects: what it does, side effects, prerequisites, return format, error handling, and distinctions from siblings. It does not go into error specifics or permission nuances, but it is sufficient for an agent to invoke it correctly in most scenarios.

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

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

Input schema coverage is 100%, with each parameter documented. The description adds minimal extra meaning: it mentions that promises are awaited, but the schema already states this. It does not elaborate on tab_id or instance_id beyond what the schema provides, so the baseline 3 applies as the description relies on the schema for parameter semantics.

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

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

The description clearly states the tool's action — "Executes arbitrary JavaScript code in the page context" — with a specific resource (JavaScript) and context (page). It immediately distinguishes its purpose from read-only inspection and UI interaction by naming alternatives, ensuring an agent can identify its niche.

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 guidance: "Use this for dynamic inspection, DOM manipulation, complex interactions" and lists concrete alternatives ('inspect_dom' for read-only queries, 'click_element' for UI interactions). It also states prerequisites (active Chrome tab, script context must allow execution), giving clear when-to-use and when-not-to-use conditions.

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

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

With no annotations provided, the description carries the full burden and handles it well: it discloses side effects ('read-only by default; can modify state if expression includes mutations') and prerequisites. It could go further (e.g., error behavior, impact on debugger state) but is transparent about the key behavioral traits.

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

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

The description is efficiently structured: purpose, side effects, prerequisites, return info, and alternatives are each covered in one sentence without repetition. Though slightly long, every sentence adds value and the key information is front-loaded.

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

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

Given the tool's moderate complexity, the description covers purpose, side effects, prerequisites, return type, and alternatives. Without an output schema, it explains what the result contains ('type and value'). It doesn't elaborate on error messages or handling, but the essential information for correct invocation is present.

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 parameters are well-documented. The description adds semantic context that the schema lacks, such as 'in call frame scope' and access to local/closure variables, clarifying what the expression can reference and the evaluation context. This goes beyond the baseline.

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

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

The description clearly states a specific verb ('Evaluates') and resource ('JavaScript expressions within the scope of a paused call frame') and distinguishes itself from siblings like 'evaluate_js' and 'step_over'. It also gives a concrete use case ('inspect variables and call stack during debugging'), making its purpose unmistakable.

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

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

Explicitly mentions the prerequisite ('requires debugger to be paused at a breakpoint with active call frame') and names alternatives with reasoning ('evaluate_js' for global scope, 'step_over' to advance without evaluation). This provides clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden and meets it. It discloses side effects (modifies DOM value, triggers input/change events), prerequisites (element exists, visible, input/textarea/contenteditable), and return type (success confirmation). This is thorough behavioral disclosure.

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 well structured and efficient: opening action, side effects, prerequisites, return, usage, alternatives. Every sentence provides distinct value with 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?

For a 4-parameter tool with no output schema, the description fully covers what the tool does, when to use it, behavioral side effects, prerequisites, and return value. It is complete enough for an agent to select and invoke it correctly without ambiguity.

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 each parameter has a detailed description already. The tool description adds only general context ('CSS selector', 'input/textarea/contenteditable') already present in the schema. Baseline 3 is appropriate since the schema handles parameter semantics.

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

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

States a specific verb ('focuses', 'inserts text') and resource ('input field via CSS selector'), and explains the native input simulation with event triggering. It distinguishes itself from siblings by naming evaluate_js and click_element as alternatives.

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

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

Explicitly states when to use: 'Use this to populate form fields, search boxes, text areas.' It also gives clear alternatives and their distinguishing conditions: evaluate_js for direct value assignment without events, click_element to focus manually.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It openly states the side effect of 'clear' (emptying cache after return), the prerequisite, and the return format. It does not mention potential errors or failure modes, but it sufficiently discloses the critical behaviors an agent needs to know. The absence of annotations makes this transparency valuable.

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 well-structured and front-loaded with the primary purpose. It flows logically through side effects, prerequisites, returns, usage, and alternatives. Every sentence contributes meaningful information, with no redundancy or fluff. It is concise 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?

Given the tool's moderate complexity (4 params, no output schema), the description covers all essential aspects: what it does, side effects, prerequisites, return format, and use cases. An agent can correctly invoke this tool based solely on the description and schema. There are no obvious gaps that would lead to misuse.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds context about the 'clear' side effect, which clarifies its parameter's behavior, but does not elaborate on other parameters (tab_id, instance_id, level_filter) beyond what the schema already states. The added value is marginal, so 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 verb 'Retrieves' and the resource 'cached console messages', list specific log levels and exceptions. It distinguishes itself from sibling tools like get_network_logs by specifying console messages. The usage context ('debug script errors, monitor page health') further clarifies its 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 provides clear prerequisites ('requires an active Chrome tab') and explicit use cases, but does not explicitly state when not to use it or directly compare to sibling tools. It mentions external alternatives (DevTools Console, error logging services) but excludes no sibling tools, leaving some ambiguity about when to prefer this over get_network_logs or similar. However, the context is still 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?

With no annotations provided, the description correctly bears the full burden. It discloses 'Side effects: none (read-only cache access)', notes the 'EXPERIMENTAL' status, and explains the return format. It could additionally mention behavior on empty results or error conditions, but for a read-only cache tool, the provided transparency is 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?

The description is compact, front-loaded with the experimental warning and core purpose, then covers side effects, prerequisites, return format, use cases, and alternatives. 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?

Despite having no output schema and no annotations, the description covers purpose, usage, side effects, prerequisites, return structure, and alternatives. For a read-only tool with clear schema documentation, this is complete enough for an agent to decide when and how to use it correctly.

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

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

The schema describes all parameters with constraints, defaults, and interactions (100% coverage). The description adds no additional parameter-specific semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states 'Retrieves unhandled CDP events from domains not covered by specialized listeners', specifying the verb, resource, and scope. It explicitly contrasts with siblings like get_network_logs and get_console_logs, making the tool's purpose unambiguous and distinct.

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 usage guidance: 'Use this to see Target, Debugger, or other domain events' and names alternatives, including specific sibling tools. It also mentions prerequisites (active Chrome connection with send_cdp_command or custom domain listeners), giving clear conditions for when to use the 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 carries the full burden. It discloses the destructive side effect of 'clear' (empties cache), prerequisites ('requires active Chrome tab with network monitoring enabled'), rate limits ('none'), and return format. This exceeds typical transparency and directly addresses potential risks and operational constraints.

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 well-structured with a clear progression: purpose, side effects, prerequisites, return info, parameter highlights, rate limits, usage, and alternatives. It is somewhat lengthy but every sentence adds value; no fluff. Front-loading the main purpose aids quick comprehension.

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 9 parameters, no output schema, and no annotations, the description covers side effects, prerequisites, return type, usage, and alternatives. It does not detail the exact JSON structure of the returned array, but given the include_details flag and the schema's description of fields, it is reasonably complete. A slight gap is the lack of error conditions or behavior when prerequisites are unmet.

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

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

Schema coverage is 100%, so all nine parameters are already described in detail. The description reiterates some parameter behaviors (e.g., current_navigation_only default and retention, include_details default) but adds no new information beyond the schema. Thus baseline 3 applies.

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

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

Description opens with a specific verb-resource pair: 'Retrieves intercepted HTTP/REST requests and WebSocket frames from network activity cache with filtering.' This clearly distinguishes it from sibling tools like get_console_logs or get_performance_metrics. It also mentions the cache context and filtering, 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?

Explicit usage scenarios are given: 'Use this to audit API calls, debug network issues, inspect WebSocket traffic.' Alternatives are named (DevTools Network tab, HAR export), though they are external rather than sibling tools. It does not explicitly state when not to use it vs other tools, but the scenarios and alternatives provide adequate guidance.

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

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

With no annotations provided, the description discloses key behavioral traits: it explicitly notes 'Side effects: none (read-only snapshot)' and 'Prerequisites: requires an active Chrome tab'. It also specifies the return format. This is strong coverage, though it doesn't mention what happens if no active tab exists or whether there are rate limits, which are minor gaps.

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

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

The description is structured logically: purpose, side effects, prerequisites, returns, usage, alternatives. Each sentence adds value and information is front-loaded. It is slightly longer than necessary but 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?

Given the tool's simplicity (2 optional parameters, read-only, returns JSON), the description is fully complete: it explains the return structure with examples, includes side-effects and prerequisites, and gives usage guidance. An agent can call this tool correctly without any further information.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (tab_id and instance_id). The description adds no additional nuance beyond the schema's existing explanations. With full schema coverage, the baseline of 3 is appropriate; the description does not need to compensate much.

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 captures runtime performance metrics (JS heap size, DOM node count, layout timing) and explicitly distinguishes it from 'profile_page_performance' which does detailed tracing. It identifies both the verb and resource precisely, making it unambiguous among siblings.

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

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

It explicitly states when to use the tool ('monitor memory usage, detect memory leaks, or profile performance') and names the alternative ('profile_page_performance' for detailed tracing, plus browser DevTools Performance tab). This provides a clear decision pathway without needing to inspect other tool definitions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states side effects are none (read-only), prerequisites require an active Chrome tab with loaded DOM, and describes the return format as full HTML or snippet with context markers. This is strong coverage. It stops short of 5 because it omits potential failure cases (e.g., no match, invalid tab) or rate limits, but for a read-only inspection tool this is nearly complete.

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 three sentences with no extra fluff. The main purpose is front-loaded, followed by side effects, prerequisites, returns, usage, and alternatives. Every sentence earns its place, and the structure is logical 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 a tool with 5 parameters, no output schema, and no annotations, this description covers the essential context: purpose, usage, safety (read-only), prerequisites, and return behavior. The mention of context markers gives a clue about the snippet format. It could be more explicit about error handling or edge cases (e.g., no match for query), but overall it is sufficiently complete for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so the schema already documents each parameter. The description adds value by clarifying the two operational modes: full HTML when query is omitted, and contextual snippet with markers when query is provided. This maps directly to the query, before, and after parameters and gives the agent a higher-level understanding. It does not duplicate parameter details but adds conceptual grouping.

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 retrieves the complete HTML document or a contextual snippet around a search query. It specifies the exact action (retrieves) and resource (HTML/snippet), and explicitly differentiates from alternatives by naming them (evaluate_js, capture_screenshot). This leaves no ambiguity about what inspect_dom does.

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

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

The description gives explicit use cases: inspect page structure, find elements by text, verify rendering. It also names specific alternatives and the conditions that select them (complex DOM queries → evaluate_js, visual verification → capture_screenshot), providing clear when-to-use and when-not-to-use guidance.

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

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

No annotations are provided, so the description carries full burden. It discloses 'Side effects: none (read-only registry snapshot)' and specifies the return format as a JSON array with field names. This is transparent about behavior and output, exceeding the minimum for a tool without annotations.

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

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

Two sentences with no wasted words. The purpose is front-loaded, followed by side effects, return format, usage guidance, and an alternative. 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?

For a simple list tool with no parameters and no output schema, the description is complete: it covers purpose, side effects, return format, and how to use it with other tools. An agent can confidently invoke this 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?

Tool has zero parameters, so schema coverage is 100% (trivially). Baseline for 0 params is 4. The description doesn't discuss parameters, but none exist; it compensates by explaining output fields, which is outside parameter semantics.

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

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

The description clearly states the tool lists all running or registered Chrome instances, with a specific verb and resource. It also names an alternative (list_tabs) to differentiate scope, so an agent can distinguish it without opening 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?

Explicitly states when to use this tool ('discover instance_ids before passing instance_id to other tools') and names list_tabs as an alternative for a different scope. Provides clear usage context and 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?

The description explicitly discloses side effects ('none (read-only registry snapshot)') and describes the fallback behavior when no tabs are registered, including the note in the response. With no annotations provided, this fully carries the behavioral transparency burden and exceeds it by explaining return structure and special cases.

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

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

The description is structured with distinct sections (purpose, side effects, returns, fallback, usage, alternative) and front-loads the core purpose. It is slightly verbose but every sentence adds unique, relevant information, so no waste.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description covers return format (active_tab_id, tabs array, note), side effects, fallback behavior, usage guidance, and alternatives. 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?

The single parameter (instance_id) is already fully described in the schema (100% coverage), and the description adds no additional semantics beyond the schema's mention of omitting it for the default instance. It does tie the parameter to discovering Tab IDs, but that's purpose rather than parameter meaning, so a baseline 3 is appropriate.

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

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

The description states a specific verb ('Lists'), resource ('all tabs'), and scope ('in the specified Chrome instance'), and explicitly distinguishes itself by noting it returns Tab IDs for use with other tools, making it unambiguous against siblings like list_instances and 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?

It clearly states when to use the tool ('to discover Tab IDs before passing tab_id to other tools') and provides an explicit alternative ('list_instances' for enumerating instances), enabling proper routing without inference.

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

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

No annotations are provided, so the description carries full responsibility. It discloses side effects (destroys current page state, discards unsaved work), auth requirements (same-origin policy, credentials for restricted URLs), rate limits (none), and return type (confirmation). It also notes prerequisites and possible local restrictions. This is comprehensive behavioral disclosure.

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 moderately long but each sentence serves a purpose: purpose, side effects, prerequisites, return, auth, rate limits, usage, and alternative. It is front-loaded with the core purpose and structured logically. Minor redundancy (e.g., mentioning 'loading new page content' and 'change the current page') slightly reduces conciseness, but it remains efficient.

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

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

The tool has no output schema and only one required parameter, but the description covers all key aspects an agent needs: prerequisites, side effects, auth, rate limits, return type, and alternative usage. Given the schema's richness, no critical information is missing.

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

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

Schema description coverage is 100%, and the schema already provides detailed semantics for each parameter (e.g., URL constraints, tab_id omission, instance_id omission). The tool description adds no additional parameter context beyond what the schema offers, so the baseline of 3 applies.

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

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

The description states a specific action (navigates), resource (current Chrome tab), and objective (to a specified URL). It explicitly names the alternative 'reload' for refreshing, distinguishing it from navigation. The function is unambiguous and clearly separates from siblings like reload, switch_tab, and close_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 explicitly says 'Use this to change the current page' and lists the alternative 'reload' for refresh. It also states prerequisites (active Chrome tab, valid URL) and clarifies that the URL must be accessible, with local-only restrictions possible. This gives clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries the full burden and does so well: it discloses side effects (separate Chrome process, own profile directory and remote-debugging port), a prerequisite failure mode (rejected under --user-profile due to Chrome's singleton lock), and the return shape.

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?

Purpose is front-loaded, then side effects, prerequisites, returns, usage, and alternatives in a logical order. It is dense but nearly every clause carries information; minor compression is possible in the parameter section.

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 purpose, when-to-use, alternatives, side effects, prerequisites, and return values with no output schema present. Everything an agent needs to decide and call correctly is present.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema: it explains what WEBGL_SOFTWARE does (forces SwiftShader for GPU-less environments) and the default/rationale for headless. Proxy and label mapping to instance_id are largely covered by 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?

States a specific verb and resource ('Opens a new independent Chrome instance') and distinguishes it from the sibling 'open_tab', which creates tabs within an existing instance. The 'independent' qualifier sets the scope precisely.

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 it ('to isolate browsing sessions, cookies, proxies or WebMCP contexts') and names the alternative ('open_tab' for additional tabs within an existing instance). It also states a prerequisite rejection condition (--user-profile mode).

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?

Since no annotations are provided, the description fully discloses behavior: it mentions side effects (creates a tab, registers ID, stays open until close_tab), lazy instance launch, and the exact return structure (tab_id, target_id, url, label). This goes beyond the schema and gives the agent a complete mental model.

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 well-structured, front-loading the purpose and then detailing side effects, return values, usage, and alternatives. It is slightly verbose but every sentence contributes meaningful information without redundancy, earning a solid 4.

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 (3 optional params, no output schema, 30+ siblings), the description is complete: it covers what, why, when, side effects, return format, and differentiation from related tools. An agent has everything needed to call it correctly.

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

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

The schema already covers all parameters at 100%, but the description adds value: url defaults to 'about:blank', label must be unique, and instance_id derives from open_instance/list_instances with an 'omit for default' guidance. This enriches the agent's understanding beyond raw schema types.

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: 'Opens a new tab in the specified Chrome instance.' It names the specific resource (tab) and the action (open), and differentiates itself from siblings by explicitly mentioning 'navigate' and 'list_tabs' as alternatives with different purposes.

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

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

The description explicitly states when to use this tool: 'Use this to work with several pages in parallel while keeping their CDP state isolated per tab.' It also provides clear alternatives: 'navigate' for altering the active tab and 'list_tabs' for enumerating existing tabs, giving an agent precise routing 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 explicitly discloses the destructive side effect ('reloads the current page (destructive of unsaved state)'), prerequisites, and the return value. This is more than sufficient for an agent to understand the tool's behavior and risks.

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 well-organized into distinct clauses: purpose, side effects, prerequisites, return, usage, and alternatives. Every sentence provides essential information without redundancy, and the primary purpose is front-loaded. It is efficient despite covering multiple aspects.

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 there is no output schema, the description compensates by stating the return value ('confirmation of debugger enablement and page reload'). It covers prerequisites, side effects, usage, and alternatives, leaving no critical operational detail missing. For a tool with only optional parameters and clear behavior, this is complete.

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

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

Schema description coverage is 100%, meaning both parameters (tab_id and instance_id) are already fully described in the schema. The description adds no additional parameter-specific meaning, so it meets the baseline expectation but does not exceed it.

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

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

The description clearly states the specific action: 'Enables the debugger and injects a breakpoint at the first statement of any script loaded after reloading the page.' It also distinguishes itself from siblings by explicitly naming alternatives, so an agent can immediately tell it apart from set_breakpoint and pause_on_exceptions.

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 states when to use the tool ('Use this to debug script execution from the page load.') and provides alternative tools with their different purposes ('set_breakpoint' for targeting specific scripts/lines, 'pause_on_exceptions' for exception-based pausing). It also mentions the prerequisite of an active Chrome tab, giving complete usage context.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure, and it does so thoroughly. It states side effects: 'may temporarily disable cache ('disable_cache' defaults to false); impacts page memory/CPU.' It also mentions prerequisites: 'requires an active Chrome tab' and background bandwidth usage. It discloses the return format: 'JSON with vitals, blocking time, and top 5 long tasks.' This is comprehensive for a tool with no annotations.

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

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

The description is compact and well-structured. It front-loads the primary purpose, then efficiently covers side effects, prerequisites, return format, usage scenarios, and alternatives in a few sentences. Every clause contributes meaningful information—no filler or redundancy.

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

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

Despite having 5 parameters and no output schema, the description covers everything an agent needs to call the tool correctly: what it does, when to use it, side effects, prerequisites, return structure, and parameter interactions. The parameter details are in the schema, so the description compensates well for the lack of an output schema by specifying the JSON contents.

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

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

Schema coverage is 100%, so the schema already documents each parameter. However, the description adds meaningful interaction context beyond the schema: e.g., 'when true with action='reload', simulates cold start; cache restored after profiling' for disable_cache, and 'use 3000-5000 for typical pages' for duration_ms. This adds value beyond the schema's basic 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: 'Records a performance trace of page execution, calculating Core Web Vitals (FCP, LCP, DCL, Load) and identifying Long Tasks (>50ms blocking).' It specifies a concrete action (records), resource (performance trace), and the specific metrics, which distinguishes it from sibling tools like get_performance_metrics that likely fetch existing metrics rather than record a fresh trace.

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 usage context: 'Use this to optimize performance, identify bottlenecks, measure cold starts.' It also names alternatives: 'Alternatives: browser DevTools Performance tab, real user monitoring (RUM).' This tells the agent when to use it and what other approaches exist, though it doesn't explicitly state when NOT to use it, which is a minor gap.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly mentions destructive side effects (discards unsaved changes, clears dynamic DOM), prerequisites (active Chrome tab), and the return value (reload confirmation). This is thorough and leaves nothing hidden.

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 front-loaded with the main action, then covers side effects, prerequisites, return, usage, and alternatives in a logical order. Each sentence adds unique value without redundancy, and the total length is appropriate for the information conveyed.

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 two optional parameters and no output schema, the description covers everything an agent needs: what it does, side effects, prerequisites, return type, usage scenarios, and alternatives. Nothing essential is missing.

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

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

The schema provides full descriptions for both parameters (tab_id and instance_id) with 100% coverage, so the description doesn't need to add more. The baseline of 3 is appropriate because the description adds no parameter-specific information beyond what the schema already explains, but the schema fully documents them.

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

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

The description states a specific verb (reload) and resource (current page), and adds context by noting it discards unsaved changes and re-fetches resources. It explicitly distinguishes itself from siblings by naming navigate (for different URL) and pause_on_load (for debugging reload), so an agent can clearly tell it apart.

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 guidance: 'Use this to refresh page content or reset to initial load state.' It also names alternatives with conditions ('navigate' to load a different URL, 'pause_on_load' to debug reload execution) and states a prerequisite (requires an active Chrome tab). This is complete usage 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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It clearly states side effects (modifies debugger state, breakpoint deleted), prerequisites, and return value (confirmation of removal). It does not detail error cases beyond the schema's note on failure, but for this tool that is 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?

The description is concise but comprehensive, front-loading the action and then covering side effects, prerequisites, return, usage, and alternatives in a logical order. No fluff, every sentence adds value. Slightly verbose for a simple tool, but well-structured.

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

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

Given the tool's simplicity, the absence of an output schema, and the full coverage of parameters by the schema, the description covers all necessary context: what it does, when to use it, side effects, prerequisites, and return. It does not mention potential errors beyond the schema's note, but that's not critical for this operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters, including breakpoint_id ('Unique identifier of the breakpoint', constraints, interactions). The description does not add additional parameter-specific meaning beyond reinforcing that breakpoint_id comes from set_breakpoint, which is already in the schema. Baseline 3 is appropriate.

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

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

The description clearly states the specific verb 'Removes' and the resource 'breakpoint' by its ID. It distinguishes itself from siblings by explicitly naming set_breakpoint and resume as alternatives, making it unambiguous which tool to pick.

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 when-to-use guidance ('Use this to clean up breakpoints or disable debugging at specific locations') and names concrete alternatives with their purposes. The prerequisites to call it are also stated (active, paused session with breakpoint ID from set_breakpoint).

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 so: it declares destructive side effects (terminates the Chrome process and all open tabs, closes the debugging connection, other instances unaffected) plus a prerequisite (CHROME_PATH or chrome in PATH) and the return shape. This is exactly the behavioral context an agent needs before calling a destructive 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?

Front-loaded with the core action, then labeled sections (Side effects, Prerequisites, Returns, Alternatives, Parameters) that make it scannable. It is long, but almost every sentence carries distinct information; only the parameter restatement overlaps with the schema.

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 destructive tool with no annotations and no output schema, the description covers side effects, prerequisites, return value, usage triggers, and alternatives. An agent has everything needed to call it correctly and safely.

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

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

Schema coverage is 100% and the schema itself documents all three parameters in depth, including the closed-set constraint on 'features' and the proxy URL format. The description largely restates this (closed feature set, default instance) rather than adding new syntax or interaction detail, so baseline 3 applies.

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

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

States a specific verb and resource ('Stops and restarts the Chrome instance'), names the targeting parameter and the default-instance fallback, and distinguishes itself from siblings by naming 'reload' and 'navigate' as alternatives. An agent can tell exactly what this does without opening the schema.

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

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

Explicitly enumerates when to use it ('reset browser state, apply proxy settings, enable experimental browser capabilities, recover from crashes') and when to prefer alternatives ('reload' to refresh, 'navigate' to load new content). Nothing is left to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states side effects ('advances code execution until next breakpoint or completion'), prerequisites, and the return confirmation. It does not mention whether the operation is reversible or if it alters breakpoints, but the core behavioral impact (execution resumes) is clearly disclosed. This is more than adequate for the tool's purpose.

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 well-structured. Each sentence delivers distinct value: the action, side effects, prerequisites, return, usage guidance, and alternatives are all clearly separated. It front-loads the core function and keeps the description to four sentences without redundancy.

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

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

For a tool that simply resumes a debugger, the description covers all essential aspects: what it does, conditions for use, what to expect as a result, and alternatives. There is no output schema, but the description's return statement ('confirmation of resume command') suffices. An agent has everything needed to call this tool correctly.

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

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

The input schema provides 100% coverage for both parameters (tab_id and instance_id) with clear descriptions. The tool description does not add new parameter semantics, but none are needed since the schema already explains them. Baseline of 3 is appropriate here.

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: 'Continues full execution of the debugger from current breakpoint.' It uses a specific verb ('continues') and resource ('full execution of the debugger'), and explicitly distinguishes itself from single-step alternatives, making it easy for an agent to differentiate from siblings like step_over.

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

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

The description explicitly says when to use it ('Use this to continue program flow after inspection') and names alternatives ('step_over' or 'step_out' for single-step execution). It also states the prerequisite: 'requires an active, paused debugger session.' This leaves no ambiguity about when to select this tool over others.

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 and discloses a side effect ('modifies DOM scroll position (observable but reversible)'), a prerequisite, and a return value. This is useful transparency, though it does not go into edge cases like element-not-found failure or lazy-loading 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?

Four concise sentences front-load the primary action, then cover side effects, prerequisites, return value, use case, and alternatives with no wasted words. Every sentence earns its place.

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

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

For a six-parameter tool with no output schema or annotations, the description gives enough context to use it correctly: purpose, modes, side effects, return confirmation, and relevant alternatives. It could add more about failure modes, but the schema covers parameter-level behavior comprehensively.

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 parameter schema already provides 100% coverage with detailed descriptions for each parameter, so the baseline is 3. The description adds a useful high-level mapping of pixel offset, pages, and selector to the underlying parameters, but does not add meaning beyond what the schema already documents.

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

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

The description clearly states a specific verb and resource ('Scrolls the page') and enumerates the three distinct modes: pixel offset, viewport pages, and element selector. It also distinguishes itself from sibling tools by naming click_element and evaluate_js as alternatives.

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

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

The description explicitly says when to use this tool ('navigate within long pages or bring elements into view') and names alternatives with their purpose ('click_element' for click-triggered scroll, 'evaluate_js' for custom scroll logic). It also provides a prerequisite: requires an active Chrome tab with content.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states 'Side effects: none (read-only query)' and discloses prerequisites and return format. While it doesn't cover auth or rate limits, for a read-only search tool these are less critical; the description covers the key behavioral traits sufficiently.

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 well-structured with clear sections (action, side effects, prerequisites, return, usage, alternatives). Each sentence adds value with no redundancy. It front-loads the primary action and logically groups related information, making it easy for an agent to parse.

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

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

The description covers all essential context for an agent to correctly invoke the tool: what it does, prerequisites, side effects, return format, and alternatives. Since there is no output schema, the return format explanation is critical and provided. 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 already documents all three parameters in detail. The description does not add extra parameter-level semantics beyond what the schema provides; it focuses on usage context, which is not part of parameter semantics. 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 verb ('searches'), the resource ('all cached script sources'), and the result ('matching locations with line and column numbers'). It also distinguishes itself from siblings by naming alternatives and placement guidance, leaving no ambiguity about what the tool does.

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

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

Provides explicit when-to-use guidance ('Use this to locate code before setting breakpoints'), clearly states prerequisites ('scripts must have been parsed and cached'), and names two specific alternatives with conditions for selecting them. This fully routes the agent to the correct tool selection.

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

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

With no annotations, the description fully discloses behavioral traits: side effects ('may modify page state, DOM, or trigger navigation'), auth restrictions (local-only for Page.navigate), and the experimental nature. It clearly states the raw return format. This is exactly what a high-risk tool needs.

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 every sentence earns its place: experimental warning, purpose, side effects, auth, prerequisites, return type, and usage guidance. Front-loaded with the 'EXPERIMENTAL' warning and purpose. No filler or repetition.

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

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

Given the tool's complexity (raw CDP, safety, auth, prerequisites) and lack of output schema, the description covers all necessary context: what it does, when to avoid it, side effects, auth, prerequisites, and return format. Nothing an agent needs to safely and correctly invoke it is missing.

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

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

Schema coverage is 100% for all 4 parameters, so the baseline is 3. The description reinforces constraints (e.g., 'Page.navigate URLs subject to local-only restrictions') but does not add meaning beyond what the schema already provides. It mentions the JSON format for params, but the schema says the same. No extra semantic value.

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

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

The description clearly states the verb 'sends' with the resource 'raw Chrome DevTools Protocol (CDP) commands' and explicitly frames it as 'for advanced use cases not covered by specialized tools.' It distinguishes itself from siblings by naming alternatives (navigate, click_element, evaluate_js) and stating when it should not be used.

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 only when specialized tools inadequate' and directly lists alternative tools. It also states prerequisites (knowledge of CDP protocol, active Chrome connection) and auth caveats (local-only restrictions for Page.navigate). This is comprehensive routing advice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers side effects ('modifies debugger state (breakpoint added until removed)'), prerequisites, and return value. While it doesn't mention edge cases like duplicate breakpoints or persistence across navigations, the disclosed side effects and prerequisites are substantive and helpful for an agent deciding to call or not.

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

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

The description is compact and well-structured: two core sentences plus an alternatives sentence. It front-loads the purpose, then side effects, prerequisites, return, and usage guidance. No fluff—every sentence earns its place, and the alternatives are efficiently listed.

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 7 parameters and no output schema or annotations, the description provides the essential context: purpose, side effects, prerequisites, return, and alternatives. It doesn't detail parameter relationships or error states, but the schema handles parameter specifics. The description is sufficiently complete for an agent to decide on invocation, though a note on persistence or failure handling would push it to 5.

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% per context signals, so the baseline is 3. The description does not add any parameter-specific details beyond the schema; it only mentions the return value, not the parameters themselves. Since the schema already thoroughly explains each parameter with constraints and interactions, the description adds no extra semantic value for parameters, hence a 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 opens with a clear verb and resource: 'Sets a debugger breakpoint at a specific location, pausing execution when reached.' It names the exact action and resource, and distinguishes itself from siblings by explicitly mentioning alternatives like 'pause_on_load' and 'search_scripts', making the tool's 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 explicitly states when to use: 'Use this to debug specific code paths,' and provides alternatives with conditions: 'Alternatives: ''pause_on_load'' for early script execution, ''search_scripts'' to find scripts by pattern.' It also states prerequisites (active tab, script loaded), giving clear guidance on when it can and should be used.

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 disclose side effects ('advances debugger execution state'), prerequisites ('requires an active, paused debugger session'), and return value. However, the internal contradiction in the alternatives line undermines the clarity of the behavioral contract.

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

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

The description is front-loaded and has a logical structure (action, side effects, prerequisites, returns, usage). The alternatives sentence is clunky and contains an error, which makes the text less clean than it could be.

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 prerequisites, side effects, return type, and use case, which is mostly sufficient for a simple debugging action. But the contradictory alternative guidance leaves unresolved ambiguity about when and how to select this tool versus a step-into 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%, so the schema sufficiently documents tab_id and instance_id. The description adds no parameter-specific meaning, but per baseline it does not need to.

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 opening sentence clearly states the tool's action: executing the current line without entering function calls and pausing at the next line. However, the later alternatives line says 'step_over enters functions', which introduces confusion and slightly blurs the primary definition.

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

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

The description explicitly says 'Use this to skip function internals' and names resume and evaluate_on_call_frame as alternatives. But it also lists 'step_over' as an alternative that 'enters functions', which is both not an alternative and contradicts the tool's own behavior, potentially misleading an agent about tool selection.

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

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

With no annotations provided, the description carries the full burden and does so excellently. It discloses destructive side effects (kills the process, closes tabs, loses unsaved data), scope (only that instance, others keep running), prerequisites (instance must be running), and return value (success confirmation). This is comprehensive and prevents surprises.

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 longer than strictly necessary but every sentence carries relevant information: action, side effects, prerequisites, return, use cases, and alternatives. The core action is front-loaded, and the text is well-structured. While verbose, it is not wasteful, earning a 4.

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 destructive tool with no output schema, the description covers all essential context: what it does, side effects, scope, prerequisites, return value, when to use, and alternatives. An agent has everything needed to call it correctly and anticipate consequences. 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 coverage is 100% for the single parameter (instance_id), and the description repeats the same information ('selected by instance_id', 'default instance when omitted'). No additional semantic meaning is added beyond the schema, so a baseline of 3 is appropriate.

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

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

The description states a specific action (gracefully terminates) on a specific resource (Chrome instance identified by instance_id), and clearly distinguishes itself from sibling tools like restart_chrome and close_instance by naming them and their different purposes. The purpose 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?

Explicitly states when to use ('clean up resources, prevent zombie processes, or end a debugging session') and lists alternatives with conditions ('restart_chrome' to restart, 'close_instance' to also remove from registry). This provides clear routing for the agent.

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

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

With no annotations provided, the description carries full disclosure burden. It clearly states side effects (becomes default target, brings to foreground when activate is true), prerequisites (tab must exist, with pointer to list_tabs), and return format (structured JSON with active_tab_id and foreground status). This is thorough and accurate.

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?

Each sentence delivers distinct information: action, side effects, defaults, prerequisites, return value, usage guidance, and alternatives. It is front-loaded with the core action and avoids filler. Though slightly long, every clause earns its place.

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

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

Given the tool's complexity (side effects, defaults, prerequisites, return), the description covers everything an agent needs: what it does, why to use it, what changes state, and what to expect in response. No output schema exists, so the return description is essential and provided.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema: it explains that tab_id becomes the default for subsequent calls, and that activate defaults to true and controls foregrounding. This enhances understanding of each parameter without redundancy.

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 ('Switches') and a clear resource ('active default tab to the specified Tab ID'). It also differentiates from sibling tools by explaining that unlike passing tab_id directly, this changes the default target, and names alternatives like list_tabs. No ambiguity.

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

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

Explicitly says when to use it: 'before interacting with a different page without repeating tab_id on every call.' Also gives the alternative: 'pass tab_id directly on an individual tool call to address a tab without switching.' Provides both use case and exclusion, which is complete guidance.

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