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

The description is transparent about the audit scope by listing the exact checks performed. However, without annotations, it does not disclose whether the tool is read-only, whether it temporarily resizes the viewport (given the width parameter), or what format the results take. These are meaningful 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?

A single, front-loaded sentence uses a colon to introduce a compact list of checks. 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 definition clearly explains what the tool does and where it operates, but it omits any description of the output or result format. Since there is no output schema and no annotations, this missing information leaves an agent uncertain how to interpret the tool's response.

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

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

The input schema already documents the width parameter with 100% coverage, so the baseline is 3. The description adds no extra parameter guidance, but none is needed given the schema's clarity.

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

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

The description states a specific verb ('Run') and resource ('automated design and accessibility checks on the current page') and enumerates concrete checks (horizontal overflow, tap targets, WCAG contrast, alt text, text size, clipping). This level of specificity clearly distinguishes it from siblings like screenshot or read_console.

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 it ('on the current page') but does not explicitly provide when/when-not guidance or mention alternatives. It does not say how to choose between audit_design and check_responsive, which is a likely overlapping sibling.

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 to rely on, the description carries the burden of disclosing behavior. It explains that the tool takes screenshots at multiple widths, audits layout at each, and reports horizontal overflow, which is meaningful behavioral detail beyond the tool 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?

Two sentences with no filler. The core action is front-loaded, and the final sentence adds valuable domain knowledge about the most common responsive bug, making every word 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?

For a diagnostic tool with no annotations and no output schema, the description gives enough context to select and invoke it correctly: it explains the method, the purpose, and the key reported finding. It could be more explicit about prerequisites such as having a page open, but the default parameter values and schema descriptions cover invocation details.

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

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

Schema coverage is 100% and every parameter has a helpful description, so the baseline is 3. The tool description adds only general context like 'several widths' but does not enrich parameter meaning beyond what the schema already provides.

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

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

States the specific behavior: screenshots the page at several widths and runs a layout audit per width, with a concrete output of horizontal overflow detection. This clearly distinguishes it from sibling tools like screenshot and audit_design by tying the check to responsive breakpoint diagnostics.

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 positions this as 'THE core design check' and explains the diagnostic outcome: seeing exactly which breakpoint breaks. It gives clear context for when to use it, though it does not explicitly name alternatives or state when not to use it.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the primary effect (closing the browser and freeing resources), but does not mention irreversible session loss or whether calling it multiple times is safe. It is functional but not deeply 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?

Two short sentences with no filler. The action is front-loaded and the usage condition follows immediately. Every word contributes value.

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

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

For a zero-parameter terminal action, the description is largely complete: it states the action and the condition for calling it. It lacks only minor context such as idempotency or what happens to the existing session, which would make it 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 and 100% schema coverage, so the schema fully documents the inputs. The description adds no param details, but none are needed; baseline 4 applies.

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

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

States a specific action ('Close the browser') on a specific resource ('the browser') and adds the purpose ('free resources'). It clearly differs from the sibling inspection tools, which all perform read or interaction operations rather than ending the session.

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

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

Explicitly says when to call the tool: 'when the inspection is finished.' This provides clear contextual guidance. It doesn't discuss exclusions or alternatives, but no competing close-like sibling exists, so the guidance is sufficient.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It communicates that this is a read-only operation and that it returns rendered text, which is useful. However, it does not mention potential runtime caveats such as waiting for load, handling of empty selectors, or what happens if content has not loaded.

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

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

A single, front-loaded sentence delivers the core action, the resource, and the use case with no filler. Every word earns its place.

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

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

For a simple read-only tool with only two optional, fully documented parameters, the description provides sufficient context for an agent to decide when to call it. It could be slightly richer about return value format or edge cases, but nothing essential is missing.

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

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

Schema description coverage is 100%, so the schema already documents both selector and max_chars. The description adds no additional parameter-level semantics beyond the stated purpose, which is acceptable but not additive.

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 ('Read') and resource ('rendered text of the page'), and gives the purpose ('check copy, hierarchy, and that content actually loaded'). This clearly distinguishes it from visual or console-oriented sibling tools like screenshot, read_console, and audit_design.

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

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

The description states concrete use cases: checking copy, hierarchy, and whether content loaded. It does not explicitly name alternatives or say when not to use it, but the stated purposes make the appropriate context 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?

With no annotations, the description carries the full burden and does well: it reveals that the tool performs actions, returns newly triggered console errors, and warns about native dialogs that can block automation. It does not disclose failure modes or navigation side effects, but it provides meaningful behavioral context beyond the 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?

Three concise sentences, front-loaded with the core purpose, followed by the return value and a key caution. Every sentence earns its place with no repetition 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 tool is moderately complex and has no output schema, but the description covers intent, example actions, return behavior, and a critical pitfall. It does not spell out what happens on selector failure or navigation changes, but for its scope the description is close to complete.

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

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

Schema description coverage is 100%, so the schema already documents 'action', 'selector', and 'value' formats. The description adds context for why parameters are used but no new parameter-level detail; the baseline 3 is appropriate.

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

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

The description states a clear purpose ('Drive the page to reach a state worth inspecting') with concrete examples ('open a menu, submit a form, scroll to a section'). It distinguishes itself from the mostly observational sibling tools by emphasizing that it performs page actions rather than reading or capturing state.

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

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

The description clearly indicates when to use the tool: when the page needs to be manipulated into a state worth inspecting. It also gives an explicit exclusion ('Avoid elements that open native alert/confirm dialogs'). It does not name alternative sibling tools, but the context makes the action-versus-inspection split reasonably clear.

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

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

With no annotations, the description carries the transparency burden and does disclose the key side effects: opening a URL in the browser, starting console/network error capture, and returning title, HTTP status, and active engine. It also implies that switching engines reopens the URL, which is useful behavioral context. It does not cover persistent browser state or teardown, but sibling tools like close_browser make this less critical.

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

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

Two sentences with no filler. The first sentence front-loads the action and ordering; the second covers return values and the engine use case. Every sentence earns its place.

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

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

For a tool with no output schema and five parameters, the description covers the essential return values, side effects, and engine usage tip, and the schema documents all parameters. Minor gaps remain around repeated calls and whether previous browser state is replaced, but the description is sufficient for an agent to call the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds genuine extra meaning for the engine parameter by framing it as a way to compare rendering across engines, and it connects the tool's overall purpose to capturing console/network errors. This goes slightly beyond the schema's parameter descriptions.

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

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

The description uses a specific verb and resource ('Open a URL in the browser') and clearly adds a distinct capability ('start capturing console + network errors') that separates it from sibling tools like screenshot or read_console. The instruction 'Call this first' also identifies it as the entry-point navigation tool.

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

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

The description explicitly says 'Call this first,' which tells the agent when to use it relative to other tools. It also gives conditional context for the engine parameter ('re-open the same URL in a different browser engine and compare rendering'). It does not explicitly name alternatives or exclusions, but the ordering instruction provides clear usage guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. It reveals a stateful behavior: messages are captured since the last open_page, not live. It also clarifies that page errors are included. Minor gaps remain around whether the buffer is cleared or what happens before any open_page, but the core behavior is 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?

Two sentences, no wasted words. The first sentence states scope and resource; the second gives a practical diagnostic hint. Both sentences add value and the tool identity is front-loaded.

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

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

For a simple read tool with three optional, fully documented parameters and no output schema, the description provides enough context to call it correctly. It explains the resource, the time window, and a common use case. Return formatting is not described, but the absence of an output schema makes this a minor gap.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the schema. The description adds no parameter-level detail, but none is needed because level, limit, and pattern all have clear inline descriptions. 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 names a specific verb and resource: 'Read console messages and uncaught page errors.' It also specifies the temporal scope ('captured since the last open_page'), which distinguishes it from related tools like read_network_errors and get_page_text. This is immediately actionable.

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 diagnostic context: 'JS errors are the usual cause of a page that renders wrong' implies this tool should be consulted when a page renders incorrectly. It does not explicitly name alternatives or exclusions, but the context is strong enough to guide selection.

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

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

There are no annotations, so the description carries the full burden. It clearly discloses that the tool lists failed network responses and frames them as design-relevant, but it does not mention whether it requires a loaded page, whether it reads the current session only, or what side effects (if any) exist. This is a read-only listing tool, so the gap is moderate rather than severe.

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

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

The description is two sentences with no filler. The first sentence states the core action and result, and the second provides practical value. Every word earns its place.

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

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

For a one-parameter read-only listing tool, the description gives enough context to understand what the tool does and why it matters. It does not specify return format, ordering, or whether the network log is scoped to the current page, but the low complexity and simple schema make those omissions acceptable.

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

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

The input schema covers 100% of the single parameter with a default and a description ('Max entries.'). The tool description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('List') and resource ('failed requests and HTTP 4xx/5xx responses'), making the tool's purpose clear. It also adds a practical use case (catching missing fonts, images, and stylesheets) but does not explicitly differentiate from sibling tools like read_console.

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—when investigating silent design degradation from missing assets—but it does not provide explicit when-to-use or when-not-to-use guidance. It also does not mention alternative tools or conditions for choosing this over read_console or audit_design.

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

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

With no annotations, the description carries the full burden. It discloses the core action, a meaningful side effect ('saves a full-resolution PNG to disk'), and the return behavior ('returns its path'). It does not detail every behavioral nuance, but it covers the key operational facts.

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

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

Two sentences, front-loaded with the main action and purpose, followed by the side effect and return path. No wasted words.

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

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

Given no annotations and no output schema, the description compensates well by stating the action, purpose, side effect, and return path. It does not mention prerequisites like an open browser page, but that is reasonably implied by the tool set and sibling names.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already provides, but it does not need to because each parameter is already described clearly.

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

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

Description states a specific verb and resource ('Capture the current page as an image') and a clear purpose ('visually judge layout, spacing, and alignment'), which distinguishes it from text-, console-, and interaction-focused sibling tools.

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

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

It clearly implies when to use it — when visual layout and spacing judgment is needed — but does not explicitly name alternatives or state when not to use it. Sibling tools like check_responsive and audit_design overlap somewhat, so an explicit exclusion would help.

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