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 discloses side effects (changes system window focus, switches active tab viewport) and explicitly states non-effects (does not reload or alter DOM). This is thorough and accurate, going beyond a generic 'activates a tab' statement.

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

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

The description is well-structured with clear section headers (Side effects, Usage guidelines, Args, Returns). Each sentence adds value; nothing is redundant. It is front-loaded with the core action and side effects before diving into usage and parameters, making it easy to parse quickly.

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

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

Given the tool's moderate complexity and lack of annotations, the description covers all necessary context: what it does, side effects, when to use/avoid, parameter details, and return behavior. The presence of an output schema (though not shown) is complemented by the description's explicit note about error messages. 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 0%, so the description must compensate. It provides detailed semantics for both parameters: 'tab_id' is explained as an exact identifier from 'list_tabs' with fallback behavior, and 'url_pattern' is described as a regex pattern with an example. This adds meaningful context that the raw schema (types and defaults only) lacks.

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

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

The description opens with a specific verb and resource: 'Bring a target browser tab to the front and focus its window.' It immediately distinguishes itself from sibling tools by explicitly noting that TabPilot tools work off-screen without stealing focus, so the agent can clearly identify when to use this tool versus others.

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 'When to use' and 'When NOT to use' sections are explicit and actionable. It names concrete scenarios (observation, screenshots) and explicitly forbids use before reading/interacting, listing the alternative tools. This leaves no ambiguity about when to invoke this tool.

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

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

With no annotations, the description carries the full burden; 'Report' signals a read-only diagnostic operation and the sentence spells out the three things it returns (backend, capabilities, tab count). It does not explicitly state 'does not modify browser state', but the report semantics make side effects unlikely, and an output schema exists for return details.

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 efficient, front-loaded sentence covers the operation and its outputs 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 zero-parameter diagnostic tool with an output schema available, the description plausibly covers everything needed to call it. It does not explain the meaning of 'what it can do' in detail, but that detail belongs to the output schema, so the gap is minor.

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 parameter burden is minimal; per the baseline for 0 params, no parameter-level documentation 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 names a concrete action (report) and resource (backend connection, capabilities, tab count), making the tool's purpose clear. It stops short of a 5 because it does not explicitly contrast with siblings such as list_tabs, which overlap on the tab-count aspect.

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 context is implied by the status-reporting wording: call it to check the active backend, its capabilities, or the number of tabs. However, there is no explicit guidance about when to prefer it over list_tabs or when its capabilities report is relevant, so the agent must infer the trigger.

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 burden and does it well: it discloses scrolling, a real CDP mouse event at the element's center, and the resulting effect on mousedown-only widgets. It does not mention failure modes or default-tab behavior, but the core side effects are 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 compact, front-loaded with the action and key behavioral caveat, and then lists each parameter in a scannable block. No sentence is redundant.

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 parameter list is well covered and an output schema exists, so return values are not needed. However, all parameters are optional and the description never says which tab is used when tab_id and url_pattern are absent, nor what happens if no locator is supplied. That is a clear gap for an agent choosing arguments.

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 0%, and the description compensates by explaining all five parameters, including detailed text-matching semantics and the role of nth. It could be stronger on how tab_id, url_pattern, and the active tab interact when omitted.

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

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

The description opens with a clear verb and object ('Click an element') and adds the concrete behavior of scrolling it into view. It does not explicitly differentiate this from sibling tools such as eval_js or fill, so it falls short of a 5.

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

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

The CDP note implies this tool is for genuine mouse interactions, but the description never says when to prefer it over an alternative or when not to use it. Usage context is implied rather than stated.

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 disclosing side effects. It only says 'Close a tab' and adds a uniqueness constraint, but doesn't state that closing is irreversible, whether the active tab can be closed, or how browser state changes. This is insufficient for a destructive browser 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 compact and front-loaded; 'Close a tab' is the first sentence and the Args block is terse. Every line earns its place and no redundant schema information is repeated.

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

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

For a simple two-optional-parameter tool with an output schema, the core mechanics are present, but key selection details are missing: whether tab_id and url_pattern are alternatives or cumulative, and what happens if no tab or multiple tabs match. An agent could invoke it correctly in the common case but lacks full error and selection 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?

With 0% schema description coverage, the parameter lines add necessary semantics: tab_id is 'Exact tab id' and url_pattern is 'Regex matched against tab URLs' with 'Must identify one tab.' This goes beyond the schema's bare property titles, though it doesn't specify whether the two parameters are mutually exclusive or can be combined.

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

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

The opening sentence 'Close a tab' names a specific action and resource, and the action is clearly distinct from sibling tools like open_tab, activate_tab, and list_tabs. It tells an agent exactly what operation this tool performs.

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

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

The description gives no explicit when/when-not guidance or alternative routing. It relies on the tool name and the closing verb to imply usage, but it never states, for example, to prefer this over navigating away or activating another tab. This is implied usage rather than explicit guidance.

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

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

It usefully discloses that the expression's value (not a return statement) is returned, that Promises are awaited, and that results are JSON. With no annotations, though, it never states that running arbitrary JS in a tab can mutate the page or mentions auth/error behavior, leaving the side-effect profile implicit.

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 definition is front-loaded with the core action, then adds return-value semantics, a targeted anti-usage note, and a compact Args list. Every sentence carries actionable information and none pad the text.

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

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

For a 4-parameter eval tool with no annotations, the description covers purpose, all args, JSON return, promise handling, and token-aware routing. It is only slightly incomplete in not calling out that eval can change page state or what happens with missing/invalid tab targets, but the output schema removes the need to explain return shape.

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 0%, so the Args section is the only semantic source, and it defines all four params beyond their titles. 'url_pattern: Regex matched against tab URLs' and 'timeout_ms: Per-call timeout' are genuinely new; only the relationship between tab_id and url_pattern is left unspecified.

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

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

The opening sentence names a specific verb (Run) and resource (JavaScript expression in a tab) and states the result format (JSON). It also clearly distinguishes this from read_tab/query_dom by warning against using it for DOM text dumps.

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 gives an explicit when-not with named alternatives: 'Do not use this to dump document.body.innerText — read_tab and query_dom answer those questions for a fraction of the tokens.' This is model-level routing guidance, not just a feature list.

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 behavioral transparency burden. It discloses a key behavioral trait: the value is set so React, Vue, and jQuery notice the change, rather than merely assigning a property. It also transparently describes the clear and press_enter behaviors, though it does not cover broader side effects like possible form submission or navigation.

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

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

The description is well organized with a front-loaded purpose, supported element types, and a clean Args list. Each line adds useful information and there is 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?

The description covers most aspects well, but the tab-selection mechanism is ambiguous: tab_id and url_pattern are described individually, yet it is not stated what happens if both are omitted or how they interact when both are provided. Given there are no annotations and seven parameters, this is a meaningful gap for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. Every parameter is given a meaningful one-line explanation: selector is a CSS selector, url_pattern is a regex against tab URLs, nth is 0-based, etc. This adds substantial value beyond the bare schema titles.

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

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

The description opens with a specific verb and resource: 'Set a form field's value' and explains the framework-aware behavior. It also lists the exact element types it supports, distinguishing it from siblings like click or select_option.

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

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

It provides clear context by stating the supported field types (text inputs, textareas, contenteditable, checkboxes, radios) and even notes value conventions for checkboxes/radios. However, it does not explicitly mention alternatives or exclusions such as dropdowns, where select_option would be 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the critical implementation detail that rows must be clicked in separate tasks with a delay, warns of the React batching failure mode if looped, and advises adjusting delay_ms to 150-250 if rows stay blank. It also mentions verification after filling, which is valuable 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?

The description front-loads the purpose in the first sentence, then gives a concise but essential behavioral warning, followed by a compact Args list. Every sentence adds operational value and there is no redundant repetition of schema information.

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

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

For a complex 8-parameter browser automation tool with no schema descriptions and no annotations, the description covers all parameters, the key failure mode, and the verification step. An output schema exists, so not describing return values is acceptable; the description is sufficiently complete for correct invocation.

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

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

Schema description coverage is 0%, and the description compensates by documenting all 8 parameters with meaningful semantics. It explains defaults (rows defaults to needing answering, only_unanswered defaults true), negative column index behavior, and the relationship between question_index and scan_matrix, plus concrete delay guidance.

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

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

The description opens with a clear specific action: 'Answer a matrix/grid question one row at a time, then verify the result.' It names the resource (matrix/grid) and method (answer one row at a time), and distinguishes it from generic fill/click tools by its row-by-row verification behavior.

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

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

It provides clear context: the tool addresses matrix/grid questions, rows are clicked in separate JavaScript tasks with a delay, and question_index comes from scan_matrix. It warns against looping due to React batching, giving concrete conditions when to raise delay. However, it does not explicitly name alternative tools or state when not to use this tool, 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, the description carries the burden of behavioral disclosure. It states the operation is to list tabs, implying a read-only action, but does not explicitly confirm no side effects or mention any permissions or failure conditions. The description is adequate but not rich in behavioral detail.

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

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

The description is concise and well-structured: a single main sentence followed by a parameter explanation. It is front-loaded with the core purpose and has 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 description explains what is returned and the filter behavior. Since an output schema exists, return value details are not required. It does not mention whether all windows are included or any prerequisites, but for a simple list tool this is minor. Overall, an agent can invoke it correctly with the given information.

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

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

Schema coverage is 0%, so the description must compensate. The 'Args' section fully explains the url_pattern parameter: it is optional, expects a regex, and filters results by URL match. This adds significant meaning beyond the schema's type-only definition.

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

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

The description clearly states the verb 'List', the resource 'open tabs', and explicitly enumerates the returned fields (ids, titles, URLs). This distinguishes it from sibling tools like activate_tab or read_tab without needing to reference 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 given on when to use this tool versus alternatives. It does not mention that this is useful for obtaining tab IDs before activation or reading content, nor does it exclude any scenarios. The sibling list is provided but the description does not reference 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 must carry the behavioral disclosure burden. It clearly states the mutating action and explains wait_for_load and the url_pattern matching semantics. However, it does not disclose failure behavior, side effects on the current document, or whether navigation can be cancelled.

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

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

The description is compact and front-loaded with the core behavior, followed by a concise parameter list. It earns its space, though the url_pattern line could be more explicit about how the regex affects navigation.

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 four-parameter navigation tool with no annotations even though an output schema exists, the description covers the main behavior and parameter semantics. It lacks guidance on how tab_id relates to url_pattern or how to obtain a valid tab_id, which an agent would likely need when selecting the tool.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining each parameter in plain terms. It clarifies that url is absolute, tab_id must be exact, url_pattern matches the current URL, and wait_for_load controls waiting. The role of url_pattern is slightly ambiguous but still adds meaning beyond the bare schema.

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

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

The description states a specific action ('Point an existing tab at a new URL') with a clear resource and scope. 'Existing tab' differentiates this from sibling open_tab, which creates a new tab.

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

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

The phrase 'existing tab' implies the tool is for navigating an already-open tab, but it does not explicitly mention when to use it instead of open_tab, activate_tab, or read_tab. No alternatives or exclusions are named, so usage 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, the description carries the behavioral burden and does so well: it discloses that a new tab is created, an id is returned, activate controls foreground/background placement, and wait_for_load blocks until the document finishes loading. This goes beyond the bare operation implied by 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?

The description is front-loaded with the core behavior and return value, followed by a compact, clearly labeled Args list. Every sentence earns its place; there is no filler or redundant restatement of the tool name.

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 three-parameter browser tool, the description is complete: it states the required URL, explains both optional booleans, and names the return value, while an output schema exists for the exact return structure. Error handling is not described, but it is not essential for correct invocation here.

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 no property descriptions (0% coverage), but the description's Args section documents all three parameters: url requires an absolute URL, activate means 'bring to front,' and wait_for_load means wait for document load. The description fully compensates for the missing schema-level 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 states a specific verb-resource pair: 'Open a URL in a new tab and return its id.' This clearly distinguishes it from sibling tools like navigate (implied current tab), activate_tab, and close_tab, and includes the key return value.

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

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

Usage is implied by the action itself: use this when you want to open a URL in a new tab. However, the description gives no explicit guidance about when to prefer open_tab over navigate, activate_tab, or other siblings, and offers no exclusions or alternative 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 carries the behavioral disclosure burden. It communicates read-only intent via 'Inspect' and 'instead of reading the page', and it details behavior like truncating text and skipping non-rendered elements. It does not explicitly state 'does not modify the page' or cover rate/auth limits, but for a DOM inspection tool the implication is strong enough.

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

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

The description is well structured: a one-line purpose, a sentence on when to use it, then a compact Args list. Every sentence contributes, and the most important scoping guidance is front-loaded before parameter details.

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

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

The description covers all parameters, usage, and output fields, and the output schema exists to specify return values. However, the relationship between tab_id and url_pattern is not fully specified (what happens if both or neither are provided), which leaves a small gap for correct invocation in multi-tab scenarios.

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

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

Schema description coverage is 0%, so the parameter explanation is critical. The Args section explains all seven parameters with meaningful semantics: url_pattern is 'Regex matched against tab URLs', attrs defaults to a useful attribute set, text_max truncates text, and visible_only skips non-rendered elements. This exceeds 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?

Description opens with a specific verb and resource: 'Inspect specific elements' and enumerates the kinds of data returned (tag, text, attributes, size, visibility). It also distinguishes this from reading the whole page by stating it is for particular elements such as form fields and buttons, which separates it from siblings like read_tab.

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

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

Explicit usage guidance is present: 'Use this instead of reading the page when the question is about particular elements — form fields, buttons, error messages, option lists.' This names the alternative (reading the page) and the triggering condition, so an agent can decide when to call it.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: conversion to markdown, size capping, mode-specific output (readable strips boilerplate, text, html), and link handling. It also mentions the max_chars default. It does not cover error cases or permissions, but for a read-only operation, this is reasonably 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 compact and well-structured: a one-sentence purpose followed by a clean list of arguments with brief but informative explanations. Every sentence contributes value, and the most important usage guidance (selector use) is embedded in the parameter list without bloat.

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 that an output schema exists, the description does not need to detail return values. It covers all six parameters, gives selection guidance between tab_id and url_pattern, and explains the mode and capping behavior. It could mention prerequisites like needing an active tab or what happens if no tab matches, but overall it is quite complete for a read tool.

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

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

Schema description coverage is 0%, and the description fully compensates by explaining each parameter: tab_id, url_pattern, mode, selector, max_chars, and include_links. It adds semantics beyond the schema, such as 'Prefer url_pattern', 'Defaults to the server's --max-chars', and what 'readable' mode does. This is thorough parameter documentation.

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

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

The description opens with a clear verb and resource: 'Read a tab's content, converted to markdown and capped in size.' This distinguishes it from siblings like list_tabs, query_dom, and eval_js, which have different purposes. It is specific enough that an agent can immediately understand what the tool does.

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

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

The description offers internal usage tips, such as 'Prefer url_pattern' for selecting between tab_id and url_pattern, and advises using the selector because it is 'the cheapest way to keep a read small and on-topic.' However, it does not explicitly contrast with sibling tools like query_dom or eval_js, leaving the when-not-to-use-this-tool guidance implied rather than explicit.

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. The word 'List' implies a read-only scan, and it adds context about surfacing unanswered rows and row indices, but it does not explicitly state side-effect behavior, error conditions, or whether any navigation occurs.

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

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

The description is compact and front-loaded: purpose in the first sentence, usage directive second, and a terse parameter list. 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 3-optional-parameter scan tool with an output schema, the description covers purpose, usage context, and parameter meanings. It leaves minor ambiguity about how tab selection resolves when both tab_id and url_pattern are omitted, but the output schema handles return-value details.

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

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

Schema description coverage is 0%, but the description defines all three parameters with meaningful distinctions: tab_id as exact ID, url_pattern as regex, and selector as an override. It does not explain precedence or interactions between the optional parameters, so it is not a perfect 5.

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

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

The description opens with a specific verb and resource: 'List the matrix/grid questions on a page and which rows are unanswered.' It clearly identifies what the tool returns and distinguishes it from fill_matrix by naming fill_matrix as the follow-up action.

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

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

It gives explicit when-to-use guidance: 'Call this before fill_matrix to see the shape of the question and to confirm the row indices.' This tells the agent the intended context, though it does not discuss alternatives or when not to use it.

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

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

With no annotations, the description carries the full burden and does so well. It discloses side effects (saving to disk), behavior for background tabs, headless operation, the CDP dependency, and the remote-client condition for return_image. This goes well beyond the minimum.

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

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

The description is front-loaded with the core behavior, followed by a concise, well-structured argument list. Every sentence adds useful information, and there is no filler or repetition of schema defaults.

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 8 parameters, no annotations, and no output schema, the description is remarkably complete. It covers capture modes, format, quality, selection targeting, filename labeling, and the return_image behavior, giving an agent everything needed to invoke it correctly.

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

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

Schema description coverage is 0%, but the Args block meaningfully explains all 8 parameters beyond their schema titles: url_pattern is a regex on tab URLs, full_page captures the scrollable page, quality is ignored for PNG, and return_image defaults based on remote/client context. The description fully compensates for the schema gap.

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

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

The description opens with a specific verb and resource: 'Capture a tab and save it to disk.' It also clarifies the tool's unique value versus browsing siblings by noting it works headless and for non-frontmost tabs, which sets it apart from read_tab or query_dom.

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 on when to use it: capturing evidence, including on servers, and notes the CDP backend requirement. It does not explicitly name alternatives or exclusions, but the usage context is unambiguous enough for an agent to select 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?

There are no annotations, so the description carries the burden of behavioral disclosure. It does disclose a key behavior: if the element turns out to be a React-Select widget, the tool 'says so' and directs the caller to select_option_ui. It also implies multi-select behavior. It could add more about error handling or side effects, but it is well beyond a bare description.

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

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

The description is compact and front-loaded. The main purpose is in the first sentence, followed by usage-specific notes and then a clean, scannable Args list. Every line adds necessary information without redundancy.

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

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

For a 6-parameter interaction tool with zero annotation coveragetingham, the description covers the tool's purpose, the distinguishing alternative, how to handle multi-select, and all parameter meanings. The presence of an output schema means return values do not need to be explained in the description. Nothing essential for correct invocation appears to be 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 0%, so the description must explain the parameters, and it does: selector, values, tab_id, url_pattern, by, and nth each receive an explanation that goes beyond the schema's property names. The descriptions are concise and meaningful, especially 'by' and 'nth'.

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 ('Choose option(s)') on a specific resource ('native <select> or a Select2 widget'), and explicitly distinguishes itself from select_option_ui for React-Select style widgets. This makes its purpose immediately clear and differentiates it from the relevant sibling.

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 names the alternative (select_option_ui) and gives the precise condition for using it: when the element is a React-Select style widget with no underlying <select>. It also notes that multiple values should be passed for multi-select, providing direct 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 provided, the description carries the full behavioral burden. It discloses that the tool opens the menu, waits for it, and clicks the option, and explains the asynchronous constraint. It also mentions the timeout for menu appearance, which is valuable behavioral context beyond a simple 'select' action.

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

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

The description is front-loaded with the core purpose and immediately explains why the tool behaves as it does. The Args list is compact and each line earns its place by clarifying a parameter. There is no redundant 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 largely complete for a 6-parameter UI-driving tool: it explains the mechanism, the parameters, and the waiting behavior. Since an output schema exists, return-value details are not required. It could be slightly stronger by mentioning failure modes or when to prefer a native select alternative, but it is sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it does by documenting all six parameters. Each parameter gets a concise functional explanation, such as 'control_selector: CSS selector for the control that opens the menu' and 'option_selector: Override the option selector if the defaults miss.' This adds real meaning beyond the bare schema titles.

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

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

The description states a specific verb and resource: 'Choose an option in a React-Select / Headless UI dropdown by driving its UI.' It also distinguishes this tool from native select handling by explaining that these dropdowns have no <select> to set, making the purpose clear relative to sibling tools like select_option.

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 for when to use the tool: for React-Select / Headless UI dropdowns that cannot be set via a native <select>. It explains the UI-driving approach and why a single JavaScript call will not work, but it does not explicitly name alternative tools or state when not to use it.

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

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

With no annotations, the description carries the full burden. It discloses polling behavior, timeout, interval, failure mode ('Fails with what it last saw'), and the two mutually exclusive modes. It does not mention side effects (likely none) or whether it throws on timeout vs. returns a sentinel, but the core behavioral contract is well covered.

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

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

The description is compact and front-loaded: the core behavior is in the first sentence, followed by a tight parameter list. Every line adds information; there is no filler or repetition of schema defaults.

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

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

For an 8-parameter tool with no annotations and 0% schema coverage, the description covers the main usage modes, parameters, and failure behavior. It does not specify the return value format, but the presence of an output schema mitigates that gap. It also does not clarify precedence when multiple filters (selector, predicate, tab_id, url_pattern) are combined, which is a minor completeness 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 0%, so the description must compensate, and it does. It explains the meaning of selector, state, text, predicate, tab_id, url_pattern, timeout_ms, and poll_ms, including the minimum poll interval and the text/state dependency. It does not document the output/return value, but an output schema exists, so that is not required here.

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

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

The description opens with a precise verb and resource: 'Poll until a condition holds, then return.' It clearly distinguishes this from sibling tools like query_dom or read_tab by framing it as a waiting/synchronization operation rather than a read. The failure behavior ('Fails with what it last saw') adds useful 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 explains the two main polling modes (selector+state vs. predicate) and gives a concrete example for predicate. It does not explicitly name sibling alternatives or state when not to use it, but the context makes the usage scenario clear: wait for a condition before proceeding. A short exclusion note (e.g., 'for one-shot DOM checks use query_dom') would push this to 5.

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