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 transparency. It describes what the audit checks but does not disclose whether the tool is read-only, modifies the page, or returns specific results. The absence of side-effect disclosure and return format leaves a significant transparency gap.

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

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

The description is a single, front-loaded sentence that begins with the action and resource, followed by a concise list of audited items. Every word contributes to the meaning, with no redundancy or filler.

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

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

This is a simple zero-parameter tool, so the description is mostly adequate, but it omits what the audit actually returns (e.g., a list of violations, scores, or a pass/fail report). Since no output schema exists, this missing return-value detail is a notable gap. Usage guidance relative to sibling tools is also missing.

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

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

The tool has zero parameters and the input schema is an empty object, so schema coverage is trivially 100%. The description appropriately implies no inputs are required. Per the baseline for zero-parameter tools, no additional parameter explanation is needed.

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

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

The description clearly states a specific action ('Run an accessibility audit') and identifies the resource (the current page). It enumerates concrete checks (alt text, labels, headings, roles), which also distinguishes it from sibling tools like a11y_tree or a11y_query that serve different inspection purposes.

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

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

The description implies when to use the tool (to audit the current page for accessibility issues) but does not explicitly contrast it with alternatives like a11y_tree or a11y_query. It offers no exclusions or guidance on when not to use it, so guidance is only implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'search', which implies a read operation, but does not specify return format, whether it requires an active connection, or any side effects. Lacking these details leaves significant ambiguity for a tool with no output schema.

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

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

The description is a single, concise sentence that efficiently conveys the tool's purpose without any wasted words. It is front-loaded with the verb and resource.

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

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

Given the simplicity of the tool (2 optional params, high schema coverage), the description adequately covers what the search criteria are. However, since there is no output schema or annotations, the absence of any mention of return values or behavioral nuances leaves the description only partially complete.

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

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

The schema already provides clear descriptions for both parameters, so the baseline is 3. The description adds the 'and/or' semantics, indicating that name and role can be used together or individually, which is not explicitly stated in the schema. This is a meaningful addition.

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

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

The description clearly states a specific action ('Search') and a specific resource ('the accessibility tree'), with precise criteria ('by role and/or accessible name'). This differentiates it from siblings like a11y_tree (which likely returns the full tree) and a11y_audit (which likely audits), even without naming them.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention scenarios, exclusions, or the existence of more appropriate tools for full-tree retrieval or auditing. The agent must infer usage from 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 burden of behavioral disclosure. It explains that the tool returns the accessibility tree, which implies a read-only operation, and adds the helpful 'what screen readers see' framing. However, it doesn't disclose potential side effects, output format, or scale of the result (e.g., whether hidden elements are included or if the tree can be very large).

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

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

The description is a single, well-structured sentence that front-loads the action ('Get'), names the resource, and adds a clarifying parenthetical. Every word is necessary and there is no wasted content.

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

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

For a simple read-only tool with two optional, well-documented parameters, the description gives the essential purpose and a helpful analogy (screen reader view). It doesn't describe the output format, but the term 'accessibility tree' strongly implies the output structure, and the schema covers the parameters. It is nearly complete, missing only an explicit note on the return representation.

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

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

The input schema already provides 100% coverage with descriptions for both parameters (depth and maxDisplay). The tool description itself adds no additional parameter semantics beyond what the schema documents, so the baseline of 3 applies.

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

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

The description uses a specific verb 'Get' with a clear resource 'accessibility tree' and scope 'for the current page'. It also clarifies the meaning with '(what screen readers see)', which distinguishes it from sibling tools like a11y_audit (which evaluates accessibility) and a11y_query (which likely queries specific nodes).

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

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

The description clearly implies when to use the tool: when you need the full accessibility tree as screen readers perceive it. It provides context but does not explicitly mention alternatives or exclusion cases. Although it doesn't say 'use this instead of a11y_query', the distinct phrasing and the sibling list make the use case apparent.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states only the action 'Connect' without mentioning prerequisites like Chrome running with --remote-debugging-port, whether the connection persists, or what happens if called when already connected. This is a significant gap for a tool that establishes a stateful connection.

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

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

The description is concise, consisting of two sentences. The first sentence states the purpose directly, while the second provides actionable sourcing guidance. Every word earns its place, with no redundant or filler content.

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

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

For a simple one-parameter tool, the description is minimally adequate, but it omits crucial context such as the need for Chrome to be running with remote debugging enabled and the tool's role as a prerequisite for other CDP operations. Given the absence of annotations and output schema, more guidance would improve completeness, though the tool's simplicity keeps it from being severely deficient.

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

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

The input schema fully documents the single parameter wsUrl with type and example, so the schema already provides high coverage. The description adds a helpful hint about where to obtain the URL but does not introduce additional semantic meaning beyond what the schema offers. Thus, a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Connect') and resource ('Chrome instance via WebSocket URL'), making the tool's purpose immediately clear. It also distinguishes itself from sibling tools like discover_targets or fetch_* by focusing on establishing the connection itself. The mention of where to obtain the URL adds further specificity.

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

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

The description provides clear context on when to use this tool by telling the agent where to find the wsUrl (from /json/version or an existing connection). This implies a prerequisite but does not explicitly name alternatives or exclusion criteria, such as using discover_targets to locate targets first. Overall, the usage context is clear but not exhaustive.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states what it returns but does not mention edge cases (e.g., elements without a background), the exact return format, or any potential side effects. This is minimal transparency for a tool with no annotation support.

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

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

The description is a single sentence that is front-loaded with the action ('Get background colors...') and includes a relevant use case. Every word earns its place, with no filler or unnecessary 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 simplicity (one parameter, no annotations, no output schema), the description covers the basic purpose and parameter. However, it lacks details about the return format (e.g., which font properties are returned) and does not address overlap with sibling tools like css_fonts. Adequate but with clear gaps.

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

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

The schema provides a description for the single parameter 'selector' with 100% coverage, so the description does not need to add parameter details. The baseline of 3 applies because the schema fully documents the parameter, and the description adds 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 uses the specific verb 'Get' and clearly identifies the resource: background colors and font info for an element. It also adds the use case 'useful for contrast checking', which distinguishes it from other CSS tools that return broader style information.

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

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

The description provides a clear context for when to use the tool (contrast checking), which implies its primary use case. However, it does not explicitly mention alternatives or when not to use it, so it stops short of a perfect score.

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

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

No annotations are provided, so the description carries the full burden. It communicates a read-only 'get' operation, but gives no details about return format, behavior with invalid selectors, or whether computed values update live. It adds minimal behavioral context beyond the verb itself.

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

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

The description is a single sentence, front-loaded with the action and resource, and contains zero wasted words. It immediately communicates both the core capability and the optional filtering behavior.

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 simple tool with only two parameters, but there is no output schema and no annotations. The description omits the return shape (e.g., a map of property names to values), which the agent may need to plan subsequent steps. It is acceptable but not fully complete for a tool without an output schema.

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

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

Schema description coverage is 100%, with both 'selector' and 'properties' fully documented in the schema. The description only rephrases the optional property filtering ('Optionally filter to specific properties') without adding new semantic details, so the baseline 3 applies.

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

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

The description uses a specific verb+resource: 'Get computed CSS styles for an element.' The term 'computed' clearly distinguishes this tool from sibling rule-inspection tools like css_matched_rules and css_background_colors, making the purpose immediately 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 provides no guidance on when to use this tool versus alternatives. It does not mention css_matched_rules or other style-related tools, nor does it specify contexts (e.g., after layout changes) where computed styles are preferred. Usage context is entirely absent.

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

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

Without annotations, the description carries the full burden. It discloses that tracking is ongoing until css_coverage_stop is called, and that the result identifies unused rules. It doesn't mention whether calling start again resets tracking, but for a simple start tool this is adequate.

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

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

Two short sentences that are front-loaded with the action and provide the follow-up step. No wasted words.

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

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

For a simple start tool with no parameters and no output schema, the description fully explains the tool's role and how to complete the flow. It's complete.

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

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

The tool has zero parameters, so the description has nothing to add. Per the scoring baseline for 0-parameter tools, this is solid.

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 'Start tracking CSS rule usage' with a specific verb and resource. It also names the complementary stop tool, distinguishing it from sibling tools like css_computed_style. 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?

The description instructs to browse around after starting and then call css_coverage_stop, giving a clear usage workflow. It doesn't explicitly name alternatives or exclusions, but the start/stop pairing is self-evident.

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

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

With no annotations provided, the description must fully disclose behavior. It states the action and output, but omits side effects like whether tracking data is cleared, whether starting coverage is required, or the report format. This leaves significant behavioral gaps.

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

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

The description is a single concise sentence that front-loads the action. Every word is informative, with no redundancy or filler.

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

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

For a simple zero-parameter stop command, the description adequately covers the core function. However, the lack of an output schema and absence of details about the report's structure or post-action state mean it is not fully complete.

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

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

The tool has zero parameters, so the schema provides nothing to explain. The description adds meaning by clarifying what the tool accomplishes, meeting the baseline for no-parameter tools.

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 stops CSS coverage tracking and retrieves a report of used vs unused rules. It is specific and distinguishes itself from sibling tools like css_coverage_start.

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

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

The description implies a workflow (stop tracking after starting) but does not explicitly mention when to use this tool, prerequisites, or alternatives such as css_coverage_start. It leaves the usage context to be inferred.

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 correctly implies a read-only inspection via the verb 'Get', but does not disclose the return structure, whether the element must be rendered, or any potential failure modes. It adds value beyond the schema but leaves several behavioral aspects uncovered.

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

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

The description is a single, tightly written sentence that front-loads the verb and resource, then clarifies with the parenthetical. Every word contributes, and there is no fluff.

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

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

The tool is simple with one parameter, but there is no output schema and no mention of the return format (e.g., array of font names, objects with font details). The description explains what is retrieved but not what the tool actually returns, leaving a gap in contextual completeness.

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

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

Schema coverage is 100% with the 'selector' parameter fully described in the input schema. The description adds no additional parameter semantics, so it rests at the baseline of 3.

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

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

The description uses the specific verb 'Get' with a clear resource ('actual fonts used to render an element') and adds a crucial distinction from just 'font-family'. This effectively differentiates it from sibling tools like css_computed_style and css_matched_rules, making the 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?

The description clearly implies the use case: when you need the actually loaded fonts rather than the declared font-family. It provides context but does not explicitly name alternatives or state when not to use this tool, falling short of a full 'when/when-not' guideline.

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 does not explain whether the forced pseudo-states are temporary, how to reset them, if there are side effects, or what happens if the selector doesn't match an element. This is a significant gap for a tool that modifies visual state.

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

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

The description is a single, front-loaded sentence that exactly states the function and purpose. Every word earns its place, with no fluff or repetition.

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

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

For a two-parameter tool with no output schema, the description is minimally adequate but lacks behavioral transparency (e.g., what happens after forcing states, how to undo). It also doesn't explain any constraints, such as whether the selector must be currently present. A more complete description would cover these points.

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

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

Schema coverage is 100%, with both 'selector' and 'pseudoClasses' documented. The description's examples of pseudo-classes overlap but don't fully enumerate the enum values. It adds no extra syntax or meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states the tool's function: forcing pseudo-states on an element, with concrete examples (:hover, :focus, :active). This specific verb+resource distinguishes it from sibling CSS inspection tools like css_computed_style or css_matched_rules.

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

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

The phrase 'for testing' provides clear context for when to use this tool (during testing). It doesn't explicitly mention alternatives or exclusions, but the intended use case is evident. A slightly stronger guideline would name alternative approaches, but this is sufficient.

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

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

With no annotations, the description carries the full burden. 'Get' clearly implies a read-only operation, and listing the types of rules returned provides useful behavioral context. However, it does not explicitly state non-destructiveness or any potential limitations.

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

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

One concise, front-loaded sentence with no waste. Every word contributes meaning, and the structure is immediately 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 simple one-parameter getter with no output schema, the description sufficiently explains what is returned. It could add a note about read-only behavior or selector matching specifics, but overall it is complete enough for this low-complexity tool.

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

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

The schema already fully documents the only parameter 'selector' with a clear description. The tool description adds no additional meaning beyond what the schema provides, and schema coverage is 100%, 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?

Uses the specific verb 'Get' and clearly identifies the resource: all CSS rules matching an element. Enumerates the rule categories included (inline, matched, inherited, pseudo-elements), which differentiates it from sibling tools like css_computed_style or css_background_colors by scope.

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

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

No guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or situations where another tool like css_computed_style or css_force_pseudo would be more appropriate.

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

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

No annotations are provided, so the description carries the burden of explaining the tool's behavior. It clearly states that the tool lists media queries, which is a read-only, non-destructive operation. However, it doesn't disclose any additional behavioral details such as output format or scope limitations beyond 'across all stylesheets', which is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word earns its place, and it is immediately clear what the tool does.

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

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

The tool is simple with no parameters and no output schema, so the description carries the burden of telling the agent what to expect. The statement 'list all media queries used across all stylesheets' is complete for a simple list operation, but it could speculatively mention the output structure or note that it returns a list of query strings. It is adequate for the low complexity, hence a 4.

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

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

The tool has zero parameters, so the baseline for this dimension is 4. The description adds no parameter meanings since none exist, and there is no need for compensation. The input schema is trivially covered at 100%.

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

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

The description uses a specific verb ('list') and clearly identifies the resource ('all media queries used across all stylesheets'). It distinguishes itself from sibling CSS tools by focusing specifically on media queries, which none of the siblings do directly.

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

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

Usage is implied by the description: an agent would use this tool when needing to inspect media queries. However, there is no explicit guidance on when to use this versus alternatives, nor any exclusions or prerequisites. This is minimal but acceptable for a simple, self-explanatory tool.

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

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

The phrase 'live modification' conveys that changes apply to the current page state, which is a useful behavioral detail given the lack of annotations. However, it does not disclose side effects, persistence, handling of multiple matching selectors, or preconditions, leaving significant gaps for a mutation tool.

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

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

The description is a single, clear sentence that front-loads the action and resource. It is appropriately sized without unnecessary verbosity, achieving high efficiency even though it could benefit from more contextual detail elsewhere.

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

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

For a simple tool with three well-documented parameters and no output schema, the description covers the core action and the live-modification aspect. However, it lacks important edge-case information such as behavior with non-existent selectors or multiple matches, making it minimally adequate but incomplete.

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

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

The input schema already provides complete descriptions for all three parameters (selector, property, value), so the description adds no semantic value beyond the schema. The baseline score of 3 applies because schema coverage is 100% and the description does not introduce ambiguity.

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

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

The description clearly identifies the action (Set) and the resource (a CSS property on an element), with 'live modification' specifying the runtime nature. This distinguishes it from read-only siblings like css_computed_style and css_matched_rules.

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

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

No guidance is provided on when to use this tool versus alternatives such as css_computed_style or css_force_pseudo. The description only states what it does, leaving the agent to infer appropriate usage from context, with no exclusions or alternative tool mentions.

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, but 'Disconnect from Chrome' merely restates the tool name without disclosing side effects, such as whether in-flight commands are cancelled, whether the connection is closed gracefully, or whether the tool is idempotent.

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

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

The description is a single, front-loaded sentence with no padding or redundancy. It is maximally concise and appropriate for a simple disconnect action.

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

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

For a simple zero-parameter, no-output tool, the description is minimally adequate, but it omits the operational impact (e.g., that subsequent CDP commands may fail until reconnect) and does not mention the connection lifecycle, leaving a gap in completeness.

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

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

The input schema defines zero parameters, and the description adds no parameter information. Per the rubric, a baseline of 4 is appropriate for a tool with no parameters.

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

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

The description 'Disconnect from Chrome' uses a specific verb and resource, clearly indicating the tool's action. It implicitly distinguishes itself from the sibling connect_cdp, though it does not explicitly name the alternative.

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

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

No guidance is provided on when to use this tool versus alternatives. While the sibling connect_cdp suggests a pairing, the description itself does not state the lifecycle context or any exclusions.

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

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

With no annotations, the description carries full burden. 'List' implies non-destructive read-only behavior, but it doesn't explicitly state that, nor does it mention any prerequisites like Chrome needing to be started with --remote-debugging-port or that it returns a list with target metadata. It's adequate but minimal for a simple 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?

Two short sentences, front-loaded with the action and purpose. No unnecessary words. The structure efficiently communicates both what and why.

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 optional params and no output schema, the description covers the key output hint (WebSocket URL) and purpose. It doesn't detail the exact response structure, but the hint is sufficient for an agent to know what to extract. Missing error handling or host/port specifics are minor given schema defaults.

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% (host and port both have descriptions in the schema). The description adds no extra parameter details beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb 'List' with a clear resource 'Chrome debugging targets'. It distinguishes itself from siblings like connect_cdp and fetch_enable by specifying it's a discovery operation to find WebSocket URLs.

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 tells the agent when to use it: 'Use this to find the WebSocket URL to connect to.' This implies it should be used before connect_cdp, providing clear context. However, it does not explicitly mention alternatives or when not to use it, but that's less critical for a discovery 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 states the core behavior (clearing overrides and resetting to defaults), which is transparent about the main effect. However, it does not disclose any side effects, reversibility, or what happens if no overrides are active, leaving some gaps for a tool that performs a global reset.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently communicates the action and outcome, making it easy for an agent to parse and act upon.

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 (zero parameters, no output schema), the description is complete. It states exactly what the tool does and what resets to defaults. No additional context is necessary for an agent to invoke it correctly.

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

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

The tool has zero parameters, so the schema provides no information. The description compensates by clearly explaining the tool's action, which gives context that the schema cannot. Baseline for 0 params is 4, and the description fully covers the intended semantics.

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

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

The description uses a specific verb ('Clear') and resource ('all emulation overrides'), and specifies the result ('reset to defaults'). It clearly distinguishes this from sibling tools like emulate_device or emulate_geolocation, which set individual overrides, whereas this one resets everything.

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

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

The usage is implicitly clear: use this when you want to remove all emulation overrides at once, as opposed to setting them individually with sibling tools. However, it does not explicitly mention alternatives or provide a 'when not to use' statement, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic action ('throttle CPU') but omits important behavioral traits such as whether the throttle persists, how to reset it, or any side effects on ongoing performance. The description adds no context beyond what is obvious from the name.

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

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

The description is a single, concise sentence that is easily parsed and front-loaded. It is appropriately sized for a tool with one parameter, but some additional context about usage or effects would be beneficial without making it verbose.

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

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

Given the absence of annotations and output schema, the description is too minimal to be complete. It does not explain how the throttling is applied or removed, nor does it mention any dependencies on other tools (e.g., emulate_clear_all). The description only covers the basic purpose, leaving the agent without enough context to use the tool safely in a session.

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

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

The input schema fully describes the 'rate' parameter with a description and range, so the schema coverage is 100%. The tool description does not add any parameter-specific semantic detail, but the baseline of 3 is appropriate because the schema does the heavy lifting.

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

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

The description uses a specific verb and resource ('Throttle CPU') and clearly states the purpose ('to simulate slower devices'). It distinguishes itself from sibling emulation tools like emulate_device or perf_cpu_profile_start by focusing on CPU throttling.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of when throttling should be applied, how long it lasts, or how it relates to other emulation tools like emulate_clear_all. The description implies usage but does not give any conditional or exclusionary context.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether this tool overrides existing emulation, how it interacts with 'emulate_clear_all', or whether setting 'mobile' affects touch behavior. For a mutation tool, this lacks essential side-effect context.

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

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

The description is a single, front-loaded sentence with a parenthetical that efficiently enumerates the metric categories. Every word earns its place with no redundancy.

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

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

The tool itself is simple, and the schema fully documents parameters. However, given the lack of annotations and the many sibling emulation tools, missing guidance on when to clear or how custom settings stack with others leaves the agent to infer behavior. It is minimally acceptable but not complete.

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

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

With 100% schema description coverage, each parameter (width, height, mobile, deviceScaleFactor) is already well-defined. The description adds only a high-level grouping (viewport size, scale, mobile mode) without new details, matching the baseline of 3.

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

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

The description uses a specific verb 'Set' with a clear resource 'custom device metrics' and lists the key dimensions (viewport size, scale, mobile mode), which distinguishes it from sibling tools like 'emulate_device' that likely target predefined devices.

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 word 'custom' implies use when predefined device emulation is insufficient, but there is no explicit guidance on when to use this versus alternatives like 'emulate_device' or how it interacts with other emulate_* tools. No exclusions or alternative naming are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that it toggles dark mode affecting prefers-color-scheme, but does not disclose whether the setting is persistent, how it interacts with other emulation tools, or how to reset it. For a tool that likely mimics a system preference, this is insufficient context.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It effectively communicates the core purpose in minimal space, making it appropriately sized.

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

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

For a simple tool with one boolean parameter and no output schema, the description adequately states the primary function. However, it lacks context about persistence, reset behavior, and relationship to other emulation settings, which would help the agent understand the full impact of the tool. Given the tool's simplicity, this is a minor gap.

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

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

The input schema fully covers the 'enabled' parameter with the description 'Enable dark mode', and the tool description adds no further details about the parameter's semantics. Since schema coverage is 100%, the description does not need to compensate; however, it also does not enhance parameter understanding beyond what the schema already provides.

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

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

The description uses the specific verb 'Toggle' with the resource 'dark mode' and cites 'prefers-color-scheme', clearly distinguishing it from sibling emulation tools like emulate_reduced_motion or emulate_timezone. It conveys the exact behavior and scope.

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

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

The description does not specify when to use this tool versus alternatives, discuss prerequisites, or provide exclusions. The intended use is only implied by the name and the mention of prefers-color-scheme, leaving the agent to infer when to apply it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states what is emulated (viewport, DPR, user agent, touch) but does not explain whether the emulation overrides existing settings, persists across sessions, or can be reverted. The presence of sibling tools like emulate_clear_all suggests important behavioral context that is missing.

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

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

The description is a single sentence, front-loaded with the main action, and contains no unnecessary words. It efficiently conveys the tool's scope and effect.

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

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

The tool is simple with only one parameter and no output schema, so the description covers its core purpose well. However, it lacks important behavioral context about how the emulation interacts with other emulation settings, whether it clears prior configuration, and how it can be reverted. Given the absence of annotations, this is a notable gap.

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

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

The input schema has 100% coverage with an enum and a minimal description ('Device preset to emulate'). The tool description adds meaning by explaining that choosing a device will apply correct viewport, DPR, user agent, and touch, which is beyond what the schema provides. This extra context justifies a score above the baseline of 3.

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

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

The description clearly states the tool's purpose with a specific verb ('Emulate') and resource ('specific device'), and enumerates the concrete aspects it configures (viewport, DPR, user agent, touch). This distinguishes it from sibling tools that target individual emulation aspects, such as emulate_user_agent or emulate_custom_device.

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

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

The description implies usage by listing the comprehensive set of device properties, which suggests it is the preferred tool for full-device emulation as opposed to single-property emulators. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide any exclusions or conditions.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'Fake', without addressing whether the override persists, how to revert it, or any side effects on the current page or session. This is insufficient for a state-changing tool.

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

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

A single, compact sentence: 'Fake the browser's geolocation to any coordinates'. Every word serves a purpose, with no filler or repetition.

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

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

For a simple tool with no output schema and no annotations, the description should at least mention resetting behavior or the need to clear the override (e.g., via emulate_clear_all). The current description is too thin for an agent to confidently use it in a real session without additional context.

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

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

Schema description coverage is 100%, meaning latitude, longitude, and accuracy are already well-documented. The description adds no meaningful parameter details; 'any coordinates' merely echoes the schema's latitude/longitude ranges. Baseline 3 is appropriate because the schema carries the load.

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 ('Fake'), the resource ('browser's geolocation'), and the target ('any coordinates'). It is specific enough to distinguish from sibling tools like emulate_timezone or emulate_user_agent, which reference different browser features.

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

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

No guidance is provided on when to use this tool, prerequisites, or how it interacts with sibling tools such as emulate_clear_all. The description simply states what it does, leaving the agent to infer usage from the name.

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

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

With no annotations, the description alone must convey behavior. 'List all available' explicitly indicates a non-destructive, read-only operation that returns a complete set of presets. No side effects, prerequisites, or other behavior need disclosure for a simple list tool.

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

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

The description is a single, front-loaded sentence that states exactly what the tool does with no filler or redundant words. Every word earns its place.

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

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

Given the tool's simplicity (0 parameters, no output schema) and its role among emulation siblings, the description is fully complete. It answers what the tool lists, for what purpose, and no further detail about return format or side effects is necessary.

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

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

The tool has zero parameters and schema description coverage is 100% (vacuously). Per rubric, baseline for 0 params is 4, and the description does not need to explain parameter semantics. It adds no extra param info, but none is required.

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 'List all available device presets for emulation' uses a specific verb ('List') and a clear resource ('available device presets for emulation'), making it distinct from sibling tools like emulate_device which actually applies a preset, or emulate_custom_device which defines custom ones.

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

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

The description clearly implies a listing/read-only context for selecting presets when using emulation tools, and there are no exclusions or alternatives mentioned. While it does not explicitly say 'use before emulate_device', the context is clear and no closer sibling exists for this purpose.

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

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

No annotations are provided, so the description must carry the behavioral burden. It states the core behavior ('Override the browser's locale') and adds the testing context. However, it does not disclose scope, persistence, or reset behavior, which would be valuable for an emulation tool.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It efficiently communicates the tool's purpose.

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

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

The tool is simple (one parameter, no output schema), and the description covers its core function. While it could mention side effects or limits, the description adequately supports the tool given its simplicity and sibling context.

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

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

The input schema fully describes the locale parameter with format examples (100% coverage). The description does not add parameter details, but the schema already handles this, 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 uses a specific verb ('Override') and resource ('browser's locale'), with a clear purpose ('for i18n testing'). It is distinct from sibling emulation tools such as emulate_timezone or emulate_user_agent.

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

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

The description clearly implies usage for i18n testing, framing the tool's context. It does not explicitly mention alternatives or when not to use it, but the context is clear enough.

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

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

No annotations exist, so the description must disclose behavioral traits. It states it toggles a preference, implying a state change, but does not explain persistence, effect on the page's CSS media feature, or any side effects. Minimal 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 a single short sentence, front-loaded, and contains no filler. It is maximally concise.

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

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

For a simple one-boolean tool, the description states the core action but lacks usage context, behavioral details, and return behavior. It is minimally complete but leaves gaps, especially without annotations.

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

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

The schema describes the single 'enabled' boolean parameter with full coverage, and the description's title essentially repeats that meaning. No additional parameter semantics are provided beyond the schema, so baseline 3 applies.

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

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

The description uses a specific verb 'Toggle' and names the resource 'reduced motion preference', clearly distinguishing it from sibling emulation tools like emulate_dark_mode or emulate_device. It is unambiguous what this tool does.

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

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

The description provides no guidance on when to use this tool, when not to use it, or how it relates to sibling emulation tools. There is no mention of accessibility testing contexts or alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely restates the tool's name and provides no information about side effects, scope, persistence, or whether the override affects all contexts. The phrase 'override' implies mutation, but there is no detail on how the browser timezone is changed or how it can be reset.

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

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

The description is a single sentence and is appropriately concise without any filler. However, it is so brief that it sacrifices useful behavioral and usage context. Still, for what it includes, it is well structured and front-loaded.

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

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

Given the tool's simplicity (one parameter, no output schema, clear schema documentation), the description is minimal but not fully complete. It lacks usage guidance, behavioral transparency, and any context about when to apply timezone emulation. The schema covers parameters, but the description does not help the agent understand the tool's role relative to siblings or its side effects.

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

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

The input schema has 100% coverage for the single parameter timezoneId, including an example list of IANA timezone IDs. The description adds no additional semantic meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description 'Override the browser's timezone' uses a clear verb (override) and specific resource (browser's timezone), distinguishing it from sibling tools like emulate_geolocation or emulate_locale. It does not explicitly call out the distinction, but the resource is specific enough to avoid confusion.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not state that it is for testing timezone-dependent behavior, nor does it mention any prerequisites or exclusions. Sibling tools like emulate_locale and emulate_geolocation exist, but the description does not clarify when timezone is the appropriate choice.

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

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

With no annotations provided, the description carries the full burden. It only says 'Toggle touch emulation' and does not disclose effects on input events, whether it overrides device emulation, or any state changes beyond the obvious. No side effects or limitations are mentioned.

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

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

The description is a single, concise sentence with no filler or redundant information. It is front-loaded with the action and resource, making it easy to scan. Every word earns its place.

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

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

This is a simple tool with two well-documented parameters and no output schema. However, the description lacks context about how touch emulation interacts with other emulation features, when it should be enabled, or what the impact is. It is minimally sufficient but leaves gaps for a newcomer.

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

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

Schema coverage is 100% with each parameter having a clear description, so the baseline is 3. The tool description adds no additional parameter meaning beyond what the schema already provides, but it does not need to since the schema is self-explanatory.

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 'Toggle touch emulation' clearly identifies the action (toggle) and the resource (touch emulation), distinguishing it from other emulate_* siblings like emulate_device or emulate_geolocation. It is not a tautology, but it could be more explicit about setting enabled state rather than toggling.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, interaction with other emulation tools, or scenarios where touch emulation is needed. The description is purely declarative with no contextual advice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('override') but does not mention persistence, reversibility, interaction with other emulation settings, or side effects. This is insufficient for an agent to understand the tool's runtime behavior.

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

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

The description is a single, direct sentence with no unnecessary words, making it very concise. However, it is extremely brief and could have included additional useful context without becoming verbose, so it does not earn a perfect 5.

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

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

Given the large set of sibling emulation tools and the absence of annotations, the description is too minimal to provide complete context. It does not explain how this tool fits into the emulation workflow, whether it can be reset, or what to do if multiple emulations are active. Without output schema, it also omits return value expectations.

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

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

The input schema has 100% description coverage for all three parameters (platform, userAgent, acceptLanguage), so the schema already explains each parameter. The tool description adds no extra parameter-level information beyond what the schema provides, hence the baseline score of 3.

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

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

The description 'Override the browser's user agent string' uses a specific verb ('override') and a clear resource ('browser's user agent string'), making it distinct from sibling tools like emulate_device or emulate_locale. It unambiguously states what the tool does.

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

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

There is no guidance on when to use this tool versus alternatives such as emulate_device, which may also affect the user agent. The description provides no context, prerequisites, or exclusions, leaving the agent without direction on selecting this tool.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It only states the purpose and gives examples, but does not mention side effects (e.g., persistence, impact on rendering), how to reset (though 'none' is in the schema), or any limitations. The schema's 'none (reset)' hint is not repeated in the description, leaving the description thin on behavioral traits.

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

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

The description is a single sentence, front-loaded with the action, and contains no unnecessary words. It is maximally concise while still conveying the core purpose.

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

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

For a tool with one parameter, a fully documented schema, and no output schema, this description is largely sufficient. It covers the purpose and leaves parameter details to the schema, though it could briefly mention the reset option or that this affects the rendering view, but that is not critical given the schema's completeness.

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

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

The schema provides 100% coverage with a detailed description for the single 'type' parameter, including enum meanings and reset behavior. The description adds only a high-level summary ('color blindness, blurred vision') that is already embedded in the schema, so it adds minimal value 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 the tool's function with a specific verb ('Simulate') and resource ('vision deficiencies'), and the parenthetical examples distinguish it from sibling emulation tools like emulate_device or emulate_geolocation. It conveys exactly 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?

Usage is implied by the name and description: use this when you need to simulate vision deficiencies. However, there is no explicit guidance on when to prefer this over alternatives or mention of accessibility testing contexts, so it remains at the implied level.

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 states the action and optional modifications but does not disclose behavioral traits such as what happens if the request is not paused, whether modifications are merged or replaced, side effects, or error conditions. This is a significant gap for a mutation-like tool.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core action and optional parameters. Every word earns its place, with no redundancy or filler.

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

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

The description is minimally complete for a simple continuation tool, but it lacks workflow context (e.g., needing a paused request from fetch_enable or fetch_list_paused) and behavioral details. Without annotations or output schema, an agent may need to rely on sibling tool names or the schema to fully understand usage, leaving clear gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description adds the context of 'paused request' and 'optionally', but it does not provide meaning beyond the schema's parameter descriptions, which already say 'Override URL', etc. The description paraphrases the schema without adding new details.

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 'Continue' with a clear resource 'a paused request' and explicitly lists optional modifications (URL, method, headers, body). This distinguishes it from sibling tools like fetch_fulfill and fetch_fail, which handle paused requests differently.

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

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

The description implies usage for resuming a paused request with optional overrides, but it does not explicitly state when to use this tool over alternatives like fetch_fulfill or fetch_fail, nor does it mention prerequisites like enabling fetch interception. The context is clear but not contrasted with 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 full responsibility for disclosing behavior. It only states the basic action without any details on side effects, idempotency, or impact on existing intercepted requests. This is a significant gap for a mutation-style tool.

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

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

The description is a single short sentence with no fluff, but it essentially restates the tool name ('disable' + 'request interception'). It is concise but adds minimal value beyond the name, so it doesn't fully earn 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 has no parameters, no output schema, and no annotations, the description is arguably sufficient for a simple toggle. However, with many sibling tools in the fetch lifecycle (fetch_fulfill, fetch_fail, fetch_continue), a bit more context on how this disable interacts with those would improve completeness.

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

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

The tool has zero parameters, so per instructions the baseline is 4. The description adds no parameter information (and none is needed), but the empty schema already covers all 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 action ('disable') and the resource ('request interception'), making it easy to understand what the tool does. It also effectively distinguishes itself from sibling tool fetch_enable, which does the opposite.

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

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

The description implies usage context—use this when you want to turn off request interception—but does not explicitly state when to use it compared to alternatives like fetch_enable or fetch_continue. No when-not-to-use guidance is provided.

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

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

With no annotations, the description carries full burden but only restates the core behavior. It fails to disclose that enabling interception pauses matching requests, requiring subsequent continuation/fulfillment actions. This is a significant behavioral 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?

One concise sentence with no fluff. The key action and optional parameter are front-loaded, making it easy to scan.

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

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

Given no annotations and no output schema, the description should explain the lifecycle: interception pauses requests and requires handling via sibling tools. It also lacks any mention of how to stop interception, making the tool incomplete in context.

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

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

Schema coverage is 100%, so the schema already documents each field. The description adds 'URL patterns' context but does not meaningfully exceed what the schema provides; it is essentially 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 uses a specific verb ('Enable') and resource ('request interception'), immediately distinguishing it from sibling tools like fetch_disable. The addition of 'Optionally specify URL patterns' clarifies the scope of the operation.

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

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

No explicit when-to-use guidance is given. It does not mention that this should be used before fetch_continue/fulfill/fail, nor does it note fetch_disable as the way to turn off interception. The 'Optionally specify' phrase is about parameters, not 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. It states the core action (fail the request) but does not mention side effects, irreversibility, errors if the request isn't paused, or whether the request is aborted on the network level. For a mutation tool, this is insufficient context.

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

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

The description is a single, compact sentence that conveys the essential action without any redundant words or filler. It is appropriately sized for the tool's simplicity.

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

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

The tool is simple with fully documented parameters, so the description doesn't need to explain return values (no output schema). However, it lacks guidance on when the request is paused and how to obtain the requestId, and it doesn't clarify the outcome relative to sibling tools. Given the absence of annotations, the description feels slightly thin for safe usage.

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

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

The input schema provides 100% coverage with clear descriptions for both parameters ('Request ID from paused request' and the error reason enum). The description adds no additional parameter meaning, 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 'Fail a paused request with an error' uses a specific verb ('fail') and resource ('paused request'), clearly distinguishing it from sibling tools like fetch_continue and fetch_fulfill. The meaning is immediately apparent with 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?

The description implies usage—when you want to fail a paused request—but provides no explicit guidance on when to use this tool vs alternatives like fetch_fulfill or fetch_continue. No exclusions or prerequisites beyond 'paused request' are mentioned.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It states the tool responds with a custom/mock response, but it does not disclose side effects like the request being removed from the paused queue or the operation being irreversible. This is adequate but not fully transparent.

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

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

The description is a single sentence that directly captures the tool's purpose without extraneous wording. It is front-loaded and easy to parse.

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

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

With 4 parameters, no annotations, and no output schema, the description is minimal. It does not explain how to obtain the requestId or what happens after fulfillment, leaving some contextual gaps for an agent. However, the schema supplies parameter details, so the description is not wholly inadequate.

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 any parameter-level meaning beyond what the schema already provides, so it remains at baseline.

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

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

The description clearly states the action (respond), the resource (a paused request), and the nature (custom/mock response). This distinguishes it from sibling tools like fetch_continue (continue with original response) and fetch_fail (fail the request).

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

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

The description gives clear context: use this tool when there is a paused request and you want to provide a custom response. It does not explicitly mention alternatives or exclusions, but the scenario is well-defined.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It states 'Get', implying a read-only operation, but does not explicitly mention whether the request remains paused or if the body is available only once. It provides some context by specifying 'paused request' but lacks depth on side effects or failure modes.

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

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

The description is a single, front-loaded sentence that directly states the action and scope. Every word contributes, with no fluff or repetition.

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

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

For a simple tool with one parameter and no output schema, the description is adequate: it names the action, the target (response body), and the necessary condition (paused at Response stage). It does not explain the broader fetch workflow (e.g., fetch_enable), but that is not required for a standalone getter.

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

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

The schema covers the only parameter (requestId) with a description 'Request ID from paused request', so schema coverage is 100%. The tool description adds little beyond that, only reinforcing that the request must be paused. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('response body of a paused request'), with a clear qualifier ('at Response stage'). This distinguishes it from sibling tools like fetch_continue or fetch_fulfill, which modify or continue the request, and fetch_list_paused, which lists them.

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

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

The description implies it is used when a request is paused at the Response stage and you need its body. It does not explicitly exclude alternatives, but the context is clear, and no other tool names are needed. The 'at Response stage' qualifier provides clear 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?

There are no annotations, so the description bears full responsibility for behavioral disclosure. It explains the core function but does not mention whether the operation is read-only, what the response format looks like, or any side effects. For a listing tool, users might expect information about pagination or the structure of returned requests, which is absent.

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

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

The description is a single, concise sentence that immediately states the tool's purpose. It is front-loaded with the action and object, contains no filler, and every word earns its place.

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

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

Given the tool's simplicity (no parameters, no output schema, no annotations), the description is largely complete. It clearly captures what the tool does. However, it could be enhanced by noting that it returns a list or that it is non-destructive, but the lack of such details is not critical for this simple tool.

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

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

The tool has zero parameters, and the schema coverage is 100% (empty properties). The baseline for 0 params is 4, and the description does not need to explain parameters since there are none. It adds no parameter-specific information, but none is required.

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

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

The description clearly states the tool's function with a specific verb ('List') and resource ('paused/intercepted requests'). It distinguishes itself from sibling tools like fetch_continue and fetch_fulfill, which perform actions on requests rather than listing them.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or scenarios where another fetch_* tool would be more appropriate. The tool name is self-explanatory, but the description offers no explicit when-to-use 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the start behavior and the need to call stop later. It does not disclose potential side effects (e.g., performance overhead), statefulness (e.g., what happens if called twice), or what the profiling session produces. This is a significant gap for a tool that initiates a resource-intensive operation.

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

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

The description is extremely concise, consisting of two short sentences. It front-loads the primary purpose ('Start CPU profiling') and provides a necessary follow-up instruction. Every word earns its place with no unnecessary elaboration.

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

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

Given no parameters and no output schema, the description covers the basic start/stop workflow. However, it lacks information about what happens after profiling stops, how results are obtained, or any caveats about the profiling session. It is adequate for a simple start tool but leaves gaps about return values and side effects.

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

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

The tool has zero parameters, so the baseline score is 4. The description does not need to explain parameter semantics, and the schema correctly shows an empty properties object. There is no additional parameter detail required.

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 ('Start CPU profiling') with a specific verb and resource. It also distinguishes itself from its sibling perf_cpu_profile_stop by indicating the start of a paired workflow. However, it does not specify the scope of profiling (e.g., current page or entire browser), so it is clear but not fully exhaustive.

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: perform the actions to profile, then call perf_cpu_profile_stop. This clarifies the intended workflow and pairing with the stop tool. It does not mention alternative tools or when not to use it, but the workflow context is sufficiently clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool stops profiling and returns results, but does not mention potential errors if no profiling is active, side effects, or whether the operation is reversible.

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

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

The description is a single, concise sentence that conveys the essential action and output without any wasted words.

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

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

For a zero-parameter tool with no output schema, the description is largely sufficient. It tells the user what the tool does and what it returns. However, it could be more complete by mentioning that it should be called after starting profiling, though this is implied by the sibling tool name.

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

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

The tool has zero parameters and schema coverage is 100%, so the schema fully describes the interface. The description does not need to add parameter details, and the baseline of 4 is appropriate.

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

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

The description clearly states the action (stop CPU profiling) and the outcome (get results with top functions by CPU time). It distinguishes itself from sibling tools like perf_cpu_profile_start.

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

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

The description implies usage as the counterpart to perf_cpu_profile_start, but it does not explicitly state when to use it or mention alternatives. There is no direct guidance on prerequisites like having started profiling first.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It does not mention side effects (e.g., execution pause, resource usage), what the snapshot contains, how results are returned, or any permissions required. The tool is described as a simple action but lacks detail on what happens after invocation.

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

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

The description is a single, front-loaded sentence with no wasted words. It directly states the action and purpose, making it easy to scan and understand.

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

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

For a tool with no parameters, no output schema, and no annotations, the description conveys the core purpose but leaves out critical context for an agent: what the snapshot output looks like, whether it's a file path, data object, or saved state, and what to do after taking it. It is minimally viable but not fully complete.

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

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

There are zero parameters, and the schema is empty (100% coverage). The description adds no parameter-specific details because none are needed. With no parameters, the baseline is 4 per the guidance, and the description adequately fulfills the role by explaining what the tool does.

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 ('take a heap memory snapshot') with a clear resource ('heap memory') and a stated purpose ('find memory leaks'). This clearly distinguishes it from sibling tools like perf_cpu_profile_start (CPU profiling) and perf_metrics (general metrics).

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

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

The phrase 'to find memory leaks' provides clear context for when to use this tool. However, it does not explicitly mention alternatives or exclusions, such as using CPU profiling for performance issues instead. Still, the purpose inference is strong enough to guide an agent.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns current runtime metrics and gives examples, but it does not specify the output structure, confirm that it is a read-only snapshot, or mention any prerequisites like an active CDP session. The word 'current' implies a snapshot state, but behavioral traits are not fully disclosed.

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

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

The description is a single sentence that leads with the action and object, then parenthesizes relevant examples. It is concise, front-loaded, and every word earns its place, with no filler or repetition.

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

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

The tool is simple with no parameters and no output schema. The description covers the main function and lists several metric types, but it omits the exact return format (e.g., JSON object keys) and uses 'etc.' to imply additional metrics. For a zero-param tool, this is reasonably complete, though not fully detailed.

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?

This tool has zero parameters, so there is no parameter schema to clarify. The description correctly implies that no inputs are needed. According to the rubric, a tool with 0 parameters receives a baseline of 4, and the description does not need to add parameter-specific semantics.

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

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

The description uses the verb 'Get' with a specific resource ('current runtime performance metrics') and enumerates examples (DOM nodes, event listeners, layout counts, JS heap) that clearly distinguish it from sibling tools like perf_web_vitals or perf_cpu_profile_start. This is specific and unambiguous.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like perf_web_vitals or perf_cpu_profile_start. The context of 'runtime performance metrics' is clear, but there are no exclusions or references to alternatives, so the agent must infer usage from the name and examples.

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

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

With no annotations provided, the description carries the full burden. It clearly states this is a 'Get' operation returning specific metrics with ratings, indicating a read-only behavior. However, it does not disclose details like whether the data is lab or field based, whether a page load is required, or how errors are handled. More context would improve transparency.

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

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

The description is a single, tightly packed sentence with no redundant words. It front-loads the action and lists the key outputs immediately, making it highly concise and well-structured.

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

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

Given the tool's simplicity (no parameters, no output schema), the description adequately specifies what is returned (metrics and ratings). It could mention the exact output format or any preconditions, but for a no-input getter, it is reasonably complete. It does not explain abbreviations, but they are standard web terminology.

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

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

The tool has zero parameters, so the schema already fully covers this aspect. The description adds no parameter semantics because none exist, matching the baseline for a no-parameter tool.

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

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

The description uses a specific verb 'Get' and identifies a precise resource: Core Web Vitals with the exact metrics (LCP, CLS, FCP, TTFB) and rating categories (GOOD/NEEDS IMPROVEMENT/POOR). This clearly distinguishes it from sibling tools like perf_metrics or CPU profile tools.

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

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

The description implies its use case: when Core Web Vitals are needed. However, it does not explicitly mention when to prefer this over alternative sibling tools such as perf_metrics, nor does it state any exclusions or prerequisites. Guidance is implied but not spelled out.

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