ReMCP

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the write/destructive nature is covered. The description adds no extra behavioral context beyond saying it applies a patch, which is essentially the same as the annotation. It doesn't mention dry_run or failure modes, but those are in the schema. Thus it meets the minimum but adds little beyond annotations.

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

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

Two concise sentences: the first states the primary use case, the second gives exclusions and alternatives. Every word earns its place, and the most important information is front-loaded.

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

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

With a full schema (100% coverage) and an output schema present, the description does not need to repeat parameter details. It provides sufficient context for when to use the tool and its alternatives. The only slight gap is that it doesn't mention the destructive nature explicitly, but that's covered by annotations. Overall, an agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description doesn't add any additional meaning about parameters (e.g., the relationship between path and patch, or device requirement). It only reinforces the tool's purpose, so baseline 3 is appropriate.

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

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

The description states a specific action: applying a unified diff with one or more hunks to one or more files. It clearly distinguishes itself from write_file and edit_block, making it unambiguous.

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

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

It explicitly tells when to use this tool (when you have a unified diff) and when not to (not for patch-shaped changes via write_file, prefer edit_block for exact text blocks). This is exemplary 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?

Annotations only declare it is a non-read-only, non-destructive, non-idempotent, closed-world call. The description adds real value beyond that: it clarifies what the operation does not affect (playback, recording) and warns that state should be inspected first to avoid redundant changes, which fits the non-idempotent hint.

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 followed by the exclusions. Nothing is redundant or padded.

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?

An output schema exists, so return values need no explanation, and the device parameter is fully documented. The description covers scope and the pre-check caveat; only explicit sibling routing is missing.

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

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

The single parameter has full schema coverage with a description pointing to list_devices. The description adds no parameter-level detail, so baseline 3 applies.

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

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

States a specific verb and resource: mute the paired computer system output. The scope qualifier ('system output') distinguishes it from audio_set_volume and audio_unmute, though it never names those siblings explicitly.

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?

Draws two explicit boundaries — it does not pause playback or record audio — and tells the agent to check the existing mute state first, which implies calling audio_status before muting. It stops short of naming the alternative tools outright.

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?

Annotations already declare readOnly=false, destructive=false, idempotent=false, so the safety profile is covered; the description adds genuinely new context: the change is immediate and audible, and it neither records nor transmits audio. It does not say what happens on an out-of-range or unsupported level (clamp vs error), which leaves one 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?

Two sentences, both earning their place: the action and its trigger first, then the immediate-effect and privacy scope. Nothing is padded or restated from the title.

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 an output schema, full annotation coverage and 100% schema descriptions, the definition carries what an agent needs to invoke it. The only shortfall is not stating the failure mode for unsupported levels or what status is returned on the device side.

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 'device' tied to list_devices ids and 'volume' documented as 0..100, so the baseline is 3. The phrase 'supported level' hints the device may reject or clamp values but adds no syntax or format detail beyond the schema.

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

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

The description names a specific verb and resource ('set the paired computer system output volume') plus the level semantics ('requested supported level'), so an agent can tell it apart from audio_mute/audio_unmute/audio_status by verb alone. It never names those siblings explicitly, so differentiation is implicit rather than stated.

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 opening 'Use this to...' frames the intent but gives no when-not conditions, no prerequisite (e.g. device must be paired/listed via list_devices), and no pointer to audio_mute when the goal is silencing rather than level-setting. Usage is implied by verb choice only.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the description's 'without changing the volume' largely restates them. The one genuinely additive point is 'without playing audio' (no audible side effect), but nothing is said about failure modes such as an unreachable or unpaired device.

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 tight sentences: the action and target come first, followed by a single negative constraint. No filler, 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?

With an output schema present and the sole parameter fully documented, the description need only convey scope and safety, which it does. It could add what happens when the paired device is offline, but that gap is minor for a read-only inspection tool.

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

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

Schema coverage is 100% and the single 'device' parameter already documents that it comes from list_devices. The description adds no further meaning to the parameter, 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?

States a specific verb ('inspect') and precise resource ('supported system output volume and mute state on a paired computer'), which an agent can immediately distinguish from the mutating siblings audio_set_volume, audio_mute and audio_unmute.

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 clause 'reads local audio settings without playing audio or changing the volume' implicitly routes the agent here for inspection rather than mutation. It stops short of naming the setter siblings explicitly as alternatives, which a 5 would require.

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?

Annotations declare a non-read-only, non-destructive mutation, and the description adds genuinely new behavioral context: audio may become audible immediately, which warns of a sudden-sound side effect. It also suggests a verification step. It stops short of stating any auth/pairing prerequisites beyond the schema's device reference.

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 the action and its immediate consequence front-loaded, no filler. "paired computer system output" is slightly redundant phrasing, but nothing is wasted.

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?

A simple one-parameter toggle with an output schema, so return values needn't be explained. The description covers purpose, trigger, and the key side effect; the only minor gap is any prerequisite about the device being paired/enabled.

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?

Only one parameter, and the schema already documents it at 100% coverage including the pointer to list_devices. The description adds nothing about the device argument, which is acceptable since the schema carries the burden.

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

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

States a specific verb (unmute) and resource (paired computer system output), so the operation is unambiguous and clearly the inverse of audio_mute. It doesn't explicitly name audio_mute or audio_status as siblings, but the intended action is unmistakable from the name/description pair.

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?

"on user request" gives a minimal trigger condition, and "verify volume if necessary" implies a follow-up check (presumably audio_set_volume or audio_status). No explicit when-not or named alternatives, so routing to the right sibling is left 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?

The description adds critical behavioral context beyond the annotations. It warns that the action 'may leave unsaved form data,' which alerts the AI to a potential data loss consequence not captured by the abstract `destructiveHint: false` annotation.

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 highly concise. It provides the action, the target, and the necessary risk disclosure in two focused sentences, placing the warning about data loss effectively.

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 highly complete. For a state-mutating tool, it covers the action, the scope (Chromium tab history), and the operational caveat (checking the state afterward), leaving the agent with all necessary context to use it safely.

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

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

The schema description coverage is 100%, meaning the schema defines all technical parameters. The description mentions 'selected Chromium tab,' which semantically informs the agent about the entity being acted upon but does not add new meaning to the parameters themselves.

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 'go back one page' and clearly identifies the resource ('history of a selected Chromium tab'). This is entirely distinct from siblings like browser_forward or browser_navigate_url.

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 operational guidance by stating the user must 'choose the tab first' and 'inspect the new page state afterward.' While it doesn't list explicit alternatives, the safety warning guides appropriate usage.

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?

Annotations already declare destructiveHint=true and openWorldHint=true, so the safety bar is lower, but the description still earns credit by naming concrete consequences — submitting forms, purchasing items, deleting data — which tells the agent exactly what irreversible side effects to guard against. It stops short of saying whether the click waits for navigation or accepts confirm dialogs.

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 tight sentences: the first front-loads what the tool does and its two targeting modes, the second carries the risk warning. No filler, though it could have folded in the browser_find prerequisite it hints at.

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 annotations covering the safety profile and an output schema present, the description only needs to convey purpose and risk, which it does. Missing only the explicit relationship to browser_find/browser_tabs for locating targets, which the schema descriptions partially supply.

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

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

Schema coverage is 100% and each parameter (selector, browser_text, device, target_id, timeout_ms) is documented in the schema itself. The description only echoes the selector/visible-text distinction already present in the schema, adding no format or precedence guidance beyond it, 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?

States a specific verb (click) plus resource (an element on the current Chromium page) and both targeting mechanisms (CSS selector or visible text). It distinguishes itself from generic click tools like ui_click/computer_click by scoping to the Chromium page and CSS selectors, though it never names those siblings explicitly.

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

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

Gives a precondition ("Inspect the tab and target first") and implies the element must already be verified, likely via browser_find, but never names browser_find, browser_snapshot or any alternative tool or the condition that would select them. Usage is implied rather than spelled out.

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?

Annotations already mark the tool destructive and open-world; the description adds useful context by calling it a 'powerful page-context escape hatch' and warning that 'page content is untrusted.' This reinforces safety without contradicting the annotations.

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

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

Two sentences deliver the usage rule, the alternatives, and a security warning with no filler. The most important scoping information is front-loaded.

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

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

Given the rich input schema, output schema, and annotations, the description covers what is needed for selection and safe invocation. It could add an explicit caution about arbitrary code execution potential, but the 'untrusted page content' warning largely covers this.

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 input schema fully documents all eight parameters. The description adds no parameter-level meaning, but the baseline of 3 applies because the schema carries the semantic burden.

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 role: executing JavaScript in the page when the named browser_* tools cannot express the operation. It distinguishes itself from siblings (browser_snapshot, browser_find, browser_action, browser_wait) by naming exactly what it is not for.

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 decision rule: use this only when the four listed browser tools cannot express the required operation or inspection and JavaScript is necessary. This clearly routes the agent between alternatives without ambiguity.

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?

Annotations already declare destructive=true, non-idempotent and open-world, so the safety profile is partly covered. The description still adds meaningful context beyond them: origin/selector/value validation and the fact that filling does not imply form submission, which is the key behavioral boundary an agent could otherwise get wrong.

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 use case and followed by the safety boundary. Nothing is redundant with the schema and no sentence could be removed without losing 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?

Output schema exists, so return values need no explanation, and annotations carry the mutation safety profile. What remains is minor: behavior on partial failure or whether existing field values are overwritten is not stated, though 'bounded operation' and the staleness notes imply fail-without-write semantics.

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

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

Schema description coverage is 100% and the schema itself explains selectors, expected_tag/expected_type staleness checks, the 1-20 field limit and device/endpoint/target_id resolution. The description adds only the 'verified fields' framing, so schema is doing 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?

States a specific verb and resource ('fill several verified form fields') plus scope ('one inspected Chromium page in a bounded operation'). It implicitly separates batch filling from single-field siblings like browser_type or browser_set_value via 'several', but never names 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?

'Use this to fill several verified form fields' gives the situation, and 'in one bounded operation' hints at batching rather than repeated single edits. However, no alternative tool is named and there are no explicit when-not conditions, so the routing decision remains 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?

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description adds genuinely useful behavioral context: a criterion is mandatory and an empty call is a misuse pattern. It stops short of describing result shape, but an output schema exists so that is acceptable.

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 tight sentences: purpose and criteria first, the mandatory-criterion constraint second, and the routing preference third. No filler and the most decision-relevant information is front-loaded.

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

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

With full schema coverage, rich annotations, and an output schema that carries return values, the description covers everything an agent needs to select and invoke this tool correctly. The key pitfalls (empty call, guessing selectors) are called out.

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

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

Schema description coverage is 100%, so the schema already documents all 10 parameters. The description only echoes the criterion parameters (selector/text/role) without adding format or usage detail beyond what the schema states, which is the baseline 3 case.

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

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

States a specific verb (locate) plus resource (visible web elements) and the three criteria it accepts (CSS selector, text, ARIA role), and notes the output value (reusable selectors/bounds). It also distinguishes itself from siblings by naming browser_snapshot for enumeration and browser_action for subsequent actions.

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 when-to-use ('when the user needs to locate visible web elements') plus a when-not ('use browser_snapshot, not an empty browser_find, to enumerate page structure') and an ordering preference ('Prefer this before browser_action rather than guessing selectors or coordinates'). Alternatives and the selecting condition are both spelled out.

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?

Annotations already declare readOnlyHint=false, destructiveHint=false and idempotentHint=false, so the agent knows this changes state but is not destructive. The description adds real value by clarifying that focus does not insert content, but it does not say what focusing actually does (keyboard focus vs scroll-into-view) or what happens if the element is absent or ambiguous. Adequate, 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?

Two tight sentences, front-loaded with the intended action and followed immediately by the exclusion and the redirect to the alternative. Zero 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 has an output schema and full parameter documentation, so return values and argument meanings are covered elsewhere. What remains the description's job — what the tool does, when to use it, what it does not do, and which sibling to use instead — is all present.

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

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

Schema description coverage is 100%, so all nine parameters are already documented in the schema, and the description only restates the selector/text targeting choice. Baseline 3 applies since the schema carries the parameter burden; the description adds no syntax, precedence, or targeting-edge-case 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?

Specific verb (focus) plus a precise resource (a specific existing Chromium page element), with both targeting mechanisms named (CSS selector or text). It also separates itself from the nearest sibling by stating 'prefer browser_find for an unknown target', so an agent can route between them without opening either schema.

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

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

Gives a clear use context ('before typing'), an explicit exclusion ('It does not enter content'), and names the alternative for the unknown-target case. It does not address overlap with other element-targeting siblings such as browser_scroll_into_view or browser_click, but the primary ambiguity is resolved.

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?

Annotations already declare openWorldHint and destructiveHint=false, but the description adds genuinely new traits: navigation history semantics and that it 'does not submit page forms,' which is meaningful for an agent deciding between forward navigation and a form-triggering 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?

Two sentences, no filler, with the primary action front-loaded and the precondition second. Nothing to cut.

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 an output schema and annotations present, the description covers the essentials. A minor gap is what happens at the end of history or on a page with no forward entry, but that is not required 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?

Seven parameters with 100% schema description coverage, including how device, target_id, title, and url_contains select the tab. The description adds nothing about parameters, so the schema carries the load — baseline 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?

States a specific verb+resource+scope: 'move forward one step in the history of a selected Chromium tab.' The mention of 'a previous backward navigation' implicitly distinguishes it from browser_back, though it never names the sibling outright.

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

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

Gives an implied precondition ('requires a previous backward navigation'), which tells the agent when the tool is valid, but never states when to avoid it or names browser_back/browser_navigate_url as 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?

The description reveals a critical behavioral trait—that navigation may discard unsaved page state. This is vital context that goes beyond the simple state changes hinted at in the annotations.

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

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

The description is highly efficient, front-loading the functional definition and immediately following it with a critical operational warning.

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?

It provides the necessary operational context (paired computer CDP session) and warnings about state loss, making it highly complete for a complex navigational 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?

With 100% schema coverage, the schema already defines the parameters well. The description is clear but adds minimal semantic value beyond what the input structure 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 clearly identifies the specific action (navigate) and the resource it acts upon (Chromium tab to a user-requested URL), distinguishing it from other sibling browser actions.

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 strong usage guidance by specifying that a target tab must be inspected or chosen beforehand, implying this tool is not for blindly opening URLs.

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 annotations already declare readOnlyHint=false, idempotentHint=false, and openWorldHint=true, so the non-safe, non-repeatable, external-reaching nature is covered. The description adds one genuinely new caveat ('URL is subject to browser security restrictions'), but says nothing about focus behavior, whether the new tab becomes active, or what happens on load failure.

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 zero filler, and the primary purpose is front-loaded ahead of the clarifying exclusion. Nothing could be removed without losing 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?

An output schema exists and annotations cover the safety profile, so the description needn't explain return values. But for an 8-parameter tool it leaves the presence of target_id, title, and url_contains — page-selection parameters that look irrelevant to opening a new tab — completely unaddressed, which is a real ambiguity an agent must resolve alone.

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 every parameter is already documented in the schema and the baseline is 3. The description only gestures at the url parameter's constraint and adds no meaning beyond what the schema provides for device, wait, timeout_ms, or endpoint.

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

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

States a specific verb and resource: 'open a specified URL in a new Chromium browser tab on the paired computer.' It also rules out the adjacent behavior with 'This does not navigate an existing tab,' which behaviorally separates it from browser_navigate_url, though it never names that sibling explicitly.

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

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

'Use this to open...' gives a clear triggering condition, and the exclusion of existing-tab navigation signals when not to reach for it. However, it stops short of naming the alternative tool (browser_navigate_url or browser_tabs) that the agent should pick instead.

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?

Annotations declare destructiveHint=true and idempotentHint=false, but the description earns credit by explaining why: Enter can submit forms, so a key press can have irreversible effects. The instruction to validate focus and intent is genuine behavioral context beyond the annotation flags. It stops short of explaining how the target tab is resolved when target_id/title are omitted.

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 zero filler, and the risk warning is front-loaded right after the core action. Nothing to trim.

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 100% schema coverage, an output schema, and destructive/open-world annotations already in place, the description covers what an agent needs to call it responsibly. The one residual gap is how a key is routed when neither target_id nor title is supplied and multiple tabs exist.

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 every parameter including key, device, target_id and title is already documented in the schema. The description reinforces 'current inspected Chromium tab' as the default target, but adds no syntax, format, or selection-precedence details beyond the schema. Baseline 3 applies when 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 names a specific verb and resource ('send an explicit keyboard key or shortcut to the current inspected Chromium tab') and gives concrete examples (Enter, Escape). It is clear what the tool does, but it never names browser_type or keyboard as the adjacent siblings, so the agent must infer the boundary itself.

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 a warning about validation ('Enter can submit forms; validate focus and user intent first') which implies cautious usage, but there is no explicit guidance on when to use this versus browser_type (text entry) or the generic keyboard tool. The 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is known. The description adds real value beyond them by warning that unsaved form state may be lost and directing verification via snapshot — an important caveat not encoded in any annotation or schema field.

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 zero filler; the caveat about unsaved form state and the verification hint follow immediately after the action, and the cache option 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?

An output schema exists and annotations cover safety, so the description needn't explain returns. It covers the action, the main risk, and a verification step; only minor gaps remain (no explicit sequencing constraints for wait vs. snapshot) for an 8-parameter tool.

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

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

Schema description coverage is 100%, so every parameter (device, target_id, title, url_contains, ignore_cache, wait, timeout_ms) is already documented. The description only echoes the target-identification idea ('identified tab') and the cache bypass ('optionally bypassing cache'), adding no format or selection-precedence detail beyond the schema.

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

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

States a specific verb and resource (reload an identified Chromium tab) plus the optional cache-bypass variant, so an agent can distinguish this from browser_navigate_url or browser_snapshot without reading the schema.

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

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

Gives clear context for use ('reload an identified... tab') and points to a concrete follow-up (browser_snapshot to verify the resulting page). It does not name an explicit when-not or an alternative tool for the case where reload is the wrong choice, so it stops 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?

The description adds a key behavioral trait by stating that the action 'changes the viewport only.' This manages the agent's expectation regarding page content mutation or state change, adding value beyond what annotations provide.

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 uses two highly efficient sentences. The first defines the action and scope, while the second provides the critical selection logic for the agent 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?

Given the complexity of the input schema (11 parameters and multiple ways to identify targets), the description provides the essential meta-logic needed to correctly select this tool over its similar scrolling siblings.

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?

While the schema coverage is 100%, the description adds conceptual value by categorizing the operations—either moving by a 'bounded amount' (deltas) or by 'direction' (wheel/enum)—helping the agent structure the input intent.

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 scrolls an identified tab by a bounded amount or direction. Crucially, it differentiates itself from the sibling tool, browser_scroll_into_view, by specifying the scope of its 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?

It provides an explicit comparison and guideline: use this tool for bounded movement or direction change, and use scroll_into_view only when a specific target element must become visible.

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

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

Annotations already declare destructiveHint=false and openWorldHint=true; the description reinforces non-destructiveness by stating it does not click or change values, which is genuinely additive. It does not disclose failure behavior (element not found, timeout), whether it waits for visibility, or why readOnlyHint is false for a scroll 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?

Two short sentences, front-loaded with the action and immediately followed by the scope boundary. No filler or redundancy.

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

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

With an output schema and full annotation coverage, the description only needs to carry intent and scope, which it does. The one residual gap is behavior on failure or non-visible targets, minor given the structured data available.

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

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

Schema coverage is 100%, so all nine parameters (device, endpoint, target_id, timeout_ms, title, url_contains, etc.) are already documented. The description only echoes selector/text targeting, adding no syntax or selection guidance beyond the schema; baseline 3 is appropriate.

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

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

States a specific verb (scroll into view) and resource (a Chromium page element), plus the two targeting mechanisms (selector or visible text). It is distinguishable from browser_scroll in principle, but the description never names browser_scroll or ui_scroll_into_view, so the sibling boundary must be inferred.

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 second sentence provides a useful negative scope ('does not click the element or change its value'), which implicitly rules out browser_click and browser_set_value. However, there is no explicit guidance on when to choose this over browser_scroll, ui_scroll_into_view, or browser_find.

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 annotations already disclose that this is destructive, non-idempotent, and open-world, so the description only needs to add useful context. It does that by warning that selection can trigger dependent form updates, which is a meaningful behavioral trait beyond the annotations.

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

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

The description is two tightly written sentences with no wasted language. The core action is front-loaded, followed immediately by the key safety precondition and side-effect warning.

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 full schema coverage, rich annotations, and an output schema, the description supplies the most important missing behavioral caveat about dependent form updates. It is nearly complete, though it could further clarify native-select-only boundaries versus custom controls and alternatives.

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

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

Schema description coverage is 100%, so the schema already documents all ten parameters thoroughly. The description mentions selector and option verification, but adds no syntax or format details beyond what the schema provides, making the baseline score of 3 appropriate.

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

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

The description states a specific verb and resource: selecting an option from a native HTML select control on an inspected Chromium page. The phrase 'native HTML select control' clearly distinguishes this from sibling tools like browser_click, browser_type, or browser_set_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?

It gives a clear usage context and a precondition: verify the selector and valid option first. However, it does not explicitly name alternatives or say when not to use this tool, such as for custom dropdowns that are not native HTML selects.

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?

Annotations already flag destructive, non-idempotent, open-world writes. The description adds genuinely new context: interaction is 'guarded DOM' rather than synthetic keystrokes, and changing the field 'can trigger page events' (change/blur handlers) - a side effect an agent must anticipate. It does not discuss failure modes or permissions, hence not a 5.

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

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

Two sentences, front-loaded with purpose and immediately followed by the operational caveat; there is no filler or restatement of the title.

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 an output schema and fully documented parameters, the description only needs to convey purpose, prerequisite, and side effects - which it does. Some gap remains around target/page selection across the 10 params, but the schema covers those.

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 selector, value, device, target_id, timeout_ms and the text/browser_text overload. The description only hints at 'selector' and 'value' without adding format or precedence guidance, 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?

States a specific verb and resource ('set a specific Chromium form field value') and contrasts the mechanism with keystroke typing, which implicitly separates it from browser_type. It stops short of naming that sibling or browser_fill_form, but the action 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?

'Use this to ... rather than individual keystrokes' implies when this tool is preferable to browser_type/browser_fill_form, and 'Inspect the page and selector first' gives a prerequisite. However, no sibling is named and no explicit when-not condition is 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=true. The description adds real value beyond them by bounding the blast radius — it mutates browser emulation state only, not the host display. It does not say whether the viewport persists across navigations or resets, which would be the next useful fact.

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 tight sentences with no filler, and the primary action is front-loaded before the clarifying scope note. Every clause earns its place.

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

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

With an output schema present and full parameter documentation, the description only needs to convey purpose and scope, which it does. The one gap is device/target selection semantics — whether the viewport applies to the whole device session or a single tab — which the agent must infer from parameters.

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

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

Schema description coverage is 100%, so every parameter (device, width, height, mobile, device_scale_factor, target_id, endpoint, timeout_ms) is already documented in the schema. The description only echoes the width/height/mobile fields, adding no format or constraint detail beyond the structured data. Baseline 3 applies.

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

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

States a specific verb and resource ('change an inspected Chromium tab viewport width, height and optional mobile scale') and scopes it by purpose ('for responsive testing'). The clause 'changes browser emulation, not the host monitor resolution' crisply separates it from display/window tools such as window_resize.

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 use case is clear: responsive-testing viewport emulation on an inspected tab. It does not name an explicit alternative or when-not condition (e.g., use window_resize for the real window), so it stops 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?

Annotations already declare readOnly/idempotent/non-destructive/open-world, so the safety profile is covered. The description still adds non-obvious behavior: a selector may be temporarily centered for capture and the original scroll position is restored before return, plus the stale/mismatched diff_from fallback to a full snapshot. It stops short of describing pagination or output size limits, so not a 5.

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

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

Front-loaded with the use case, then workflow, then sibling comparison and the scroll caveat. Dense but every sentence carries distinct information; slightly long for a tool whose params are already fully documented.

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 an output schema present, rich annotations, and 100% schema coverage, the description only needs to supply selection/workflow guidance, which it does thoroughly, including the one side effect (temporary scroll adjustment) an agent would otherwise not anticipate.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds operational meaning beyond the schema for diff_from (reuse the prior snapshot_id to get changed/removed nodes, stale input degrades safely) and the selector/include_screenshot pairing (center-and-report viewport bounds). Other params (device, endpoint, max_nodes) rely on the schema.

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

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

States a specific verb and resource ('inspect a web page structurally through CDP accessibility'), and names the sibling it is not ('Prefer it over desktop ui_snapshot for page content'), so an agent can distinguish it from ui_snapshot and computer_snapshot without opening a schema.

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

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

Gives explicit when-to-use rules for the key optional params: reuse the last snapshot_id as diff_from after each step, fall back to a full snapshot when unavailable, and add include_screenshot=true only when final pixel/layout verification is needed. The alternative (desktop ui_snapshot) and the condition selecting it are spelled out.

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?

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so safety is covered. The description adds real context beyond that: the endpoint is loopback-only, it enumerates debuggable Chromium pages, and the returned target_id/title/url feed subsequent browser calls. It omits failure modes (no browser running, connection refused), which keeps it at 4.

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, zero waste, front-loaded with the usage condition followed by the mechanics and the downstream payoff. Nothing redundant with the schema or annotations.

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?

An output schema exists, so return values need not be spelled out, and the description correctly points at what to do with them. For a 6-param discovery tool it is nearly complete; only error/timeout behavior is unaddressed.

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 title/device/endpoint/target_id/timeout_ms/url_contains. The description only alludes to target_id/title/url as return values, adding no filtering syntax or default behavior beyond the schema. Baseline 3 applies.

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

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

States a specific verb (lists) and resource (debuggable Chromium pages) plus the scope of the source (loopback-only CDP endpoint). An agent can distinguish this from siblings like browser_snapshot or browser_new_tab purely from the description.

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 gives the triggering condition: 'when starting CDP browser automation and the target page or tab is not already unambiguous,' and explains that the returned ids scope later browser tools. It doesn't name competing tools (e.g. browser_find, browser_new_tab) or exclusions, so it stops 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?

Annotations already flag destructiveHint=true and openWorldHint=true, but the description adds real context the annotations don't carry: text entry may overwrite existing content unless cleared is considered, and there is explicit guidance against entering sensitive data into an untrusted page. It does not explain focus/selector prerequisites or failure behavior, keeping it short of a 5.

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

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

Two short sentences, front-loaded with the action and followed by the safety caveat. No filler and nothing that repeats the schema.

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

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

With an output schema, full parameter descriptions, and annotations covering safety, the description supplies the remaining human-level context: verified page, origin confirmation, sensitive-data avoidance. The one missing piece for a 10-parameter, heavily-siblinged tool is any signal about how it differs from browser_set_value or browser_fill_form.

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 every one of the 10 parameters is already documented at the property level. The description only echoes the 'clear existing text' concept and the idea of a target field; it adds no syntax or selection guidance beyond the schema, 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?

States a specific verb and resource: entering user-provided text into a verified Chromium page field, with optional clearing. Clear and actionable, but it never distinguishes itself from nearby siblings such as browser_set_value, browser_fill_form, type_text, or computer_type, so an agent can't tell from the description alone which typing tool to pick.

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

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

Gives a use condition ('enter user-provided text into a verified Chromium page field') and a safety precondition ('Confirm the origin and field first'), but names no alternatives and no when-not-to-use case relative to the many sibling input tools. Usage is implied rather than routed.

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?

Annotations already declare destructiveHint=true and openWorldHint=true, so the definition's added value is the disclosure that "the page may receive the file contents" — an exfiltration/data-flow warning an agent would not infer from the flags alone — plus the instruction to verify path and origin beforehand. It stops short of stating reversibility or permission requirements.

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

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

Two sentences, with the action front-loaded before the safety caveat, and no filler. The second sentence is dense but each clause (path, origin, target input, page receives contents) carries distinct 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?

With 9 parameters but full schema coverage and an output schema present, the description need not explain fields or returns. It covers the two things structured data cannot: the risky side effect on the remote page and the need to verify target/origin first. Minor gap on how failures or timeout behavior surface.

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 device, selector, path, paths, target_id and timeouts are already documented in the schema. The description refers to the file path and target input generically and adds no format, mutual-exclusivity (path vs paths), or selector-selection detail beyond structured data.

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

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

States a specific verb and resource: attaching a user-authorized local file to a Chromium file-input element. That distinguishes it from browser_type/browser_fill_form, which set values rather than transfer local file contents, though it does not name those siblings explicitly.

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?

"Check the exact file path, site origin and target input first" and "an inspected ... element" imply the precondition of inspecting the page via browser_find/browser_tabs before calling, which the schema reinforces. However, there is no explicit when-not guidance or direct routing to an alternative tool for non-file-input cases.

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?

Annotations already declare readOnly/idempotent/openWorld/non-destructive safety, so the burden is low. The description adds genuine mechanism context: it is event-driven (proof of a state transition) rather than heuristic polling or fixed sleeps, and it distinguishes itself from browser_evaluate for JS predicates. It still doesn't disclose failure/timeout behavior (what happens when the condition never holds), which is the main residual gap for a blocking 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 tight sentences, front-loaded with the triggering situation, then the explicit exclusion/alternative. No filler and no repetition of schema 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?

An output schema exists and schema coverage is 100%, so return-value explanation is unnecessary, and the annotations cover the safety profile. The description covers when-to-use and the sibling alternative well; the only meaningful omission is the timeout/failure semantics of a blocking wait, which matters for correct agent orchestration.

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 carries the parameter documentation burden. The description names the condition values that map to the schema's enum but adds no format, default, or interaction detail (e.g. how condition gates selector/text/value requirements) beyond what the schema encodes. 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 frames the tool as proof-of-condition waiting for navigation/actions and enumerates the six condition types (selector/text/URL/load/navigation/network-idle), which distinguishes it from sibling action tools. However, it never states the core verb+resource directly ('wait until a condition holds'), phrasing everything as usage guidance, so the agent has to infer the purpose from the condition list plus the title.

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

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

Explicitly states when to use it (after navigation or an action that must be followed by proof of selector/text/URL/load/network-idle), what NOT to use instead (fixed sleeps or screenshot polling), and routes JavaScript predicates to browser_evaluate. Both the positive trigger and the alternative path are named.

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?

Goes well beyond the annotations: failure semantics ('stop at the first failed step'), the 12-second execution bound, the irreversible-remote-change risk from an explicit click, and the privacy rule 'never echo field values'. These are behavioral facts an agent cannot get from readOnlyHint/destructiveHint alone, and they are consistent with destructiveHint=true.

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

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

Front-loaded with the usage trigger, then constraints, then failure behavior; four dense sentences with no filler. Sentences are long and pack multiple rules each, which costs a bit of scanability.

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?

An output schema exists and annotations carry the safety profile, so the description only needs to cover scope, limits and failure handling — which it does completely: size bound, time bound, banned operations, stop-on-first-failure, and data-handling rule.

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 steps array, action enum, fields guards and timeout_ms are already fully documented. The description adds only framing value — 'guarded' hints at expected_tag/expected_type and '1–12' restates maxItems — without explaining value/text/condition semantics beyond the schema.

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

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

States a concrete verb and resource: a batched 'sequence of 1–12 guarded DOM actions and bounded waits on one inspected Chromium page'. The batching bound implicitly separates it from the atomic browser_click/browser_fill_form/browser_wait siblings, though no sibling is named explicitly.

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

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

'Use this for an explicitly requested sequence' sets the triggering condition, and the exclusions (no arbitrary JavaScript, no file upload, no origin switch, no implicit submit) effectively route the agent to browser_evaluate, browser_upload and browser_navigate_url. Alternatives are described by capability rather than by name, so it stops 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds the key consequence beyond that: the removal is irreversible and destroys the current contents. It still doesn't mention confirmation requirements or error behavior when the target device is offline.

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 filler, and the primary usage trigger is front-loaded before the irreversibility warning.

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?

An output schema exists and the single parameter is fully documented, so the description only needs to convey purpose, trigger, and destructiveness — all of which it does. Nothing an agent needs to call this correctly is missing.

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

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

Single 'device' parameter is fully documented in the schema, including its dependency on list_devices, and the description adds nothing further. Baseline 3 applies when schema coverage is 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?

States a specific verb ('clear') plus resource ('paired computer clipboard'), which cleanly separates it from sibling tools clipboard_read and clipboard_write. An agent can identify the operation without opening the schema.

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

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

'On user request, for example after handling sensitive copied text' gives a concrete triggering scenario. It does not explicitly name alternatives (e.g., use clipboard_write to overwrite instead) or state when not to use it, 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?

While annotations cover technical safety (readOnlyHint: true), the description adds critical behavioral context about the data itself ('Clipboard contents may be sensitive') and ethical guidelines ('do not send them to unrelated sites').

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 concise and perfectly structured: first, it states the functional purpose, and second, it immediately follows up with crucial safety and behavioral constraints. Both sentences are necessary.

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) and highly annotated. The description provides all necessary context regarding the tool's purpose, safety profile, and appropriate usage, leaving no ambiguity for the agent.

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%. The parameter `device` is fully detailed in the input schema itself. Therefore, the description adds no meaningful semantic value beyond the required baseline when structured data is complete.

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 defines the function ('inspect the current clipboard text') and the domain ('on a paired computer'). Given the extensive sibling list, this is highly specific and distinguishes it from write or clear operations.

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 a perfect trigger condition ('when the user asks to inspect the current clipboard text'). Crucially, it also provides strong usage restrictions regarding data sensitivity and when to use it ('read them only when needed').

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?

Annotations already flag destructiveHint=true; the description earns credit by specifying exactly what gets destroyed ("overwrites the previous clipboard contents") and by clarifying scope ("does not itself paste or submit data"). It stops short of stating device availability/auth requirements or error behavior on an offline device.

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 action and followed by the key behavioral caveat. No padding, though the second sentence bundles two ideas (overwrite, no paste) that could be slightly sharper.

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?

Output schema exists so return values need not be explained, the parameters are fully documented, and the description covers the essential safety caveat (overwrite) plus the non-paste semantics for an operation on a remote device. Enough 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 coverage is 100%, with both device and text fully documented in the schema, so baseline 3 applies. "user-authorized text" adds a mild constraint nuance but no format, size, or device-targeting detail beyond the schema.

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

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

States a specific verb and target (place text on the paired computer clipboard) plus the downstream goal (pasting into an application), which distinguishes it from pure input tools like type_text or keyboard. It doesn't name its nearest siblings clipboard_read/clipboard_clear, so sibling differentiation is only partial.

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

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

"Use this to place user-authorized text..." gives an implied usage context and "does not itself paste or submit data" implicitly rules out pasting workflows. However, no alternative tool is named and there is no explicit when-not guidance, so selection versus clipboard_clear or type_text is left to inference.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds real behavioral context beyond that: the operation is additive rather than replacing, and it should be preceded by confirming the target and current selection. It omits what happens on duplicate/already-selected items 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?

Two tight sentences with zero waste: the additive semantics come first, then the precondition. Nothing is repeated from the title or schema.

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

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

For an 18-parameter tool, the schema and output schema cover targeting and return values, and annotations cover safety, so the description's job is the selection semantics — which it does well. It could have clarified that it applies to native accessibility targets rather than browser/OCR paths, given the many targeting options.

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% across 18 parameters, so the schema carries the parameter burden and baseline is 3. The description only loosely gestures at identification ("identified ... item") and target confirmation, adding nothing about the id/label/target fields or the coordinate/OCR fallbacks.

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

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

States a specific verb and resource ("add an identified native list or tree item") plus the key effect ("to an existing multi-selection without replacing the other selected items"). That additive semantics implicitly separates it from computer_select and computer_multi_select, though neither sibling is named.

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

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

"Use this to add ... without replacing the other selected items" gives clear selection context and a prerequisite ("Confirm the target and current selection first"). It stops short of naming the alternative tools or stating 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?

Annotations already declare destructiveHint=true and non-idempotency; the description earns credit by concretizing what that means — clicks can submit forms, activate buttons, or change data. It does not address permissions, focus/activation side effects, or failure behavior, keeping it short of a 5.

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

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

A single tight sentence, front-loaded with purpose followed by the consequence warning and the targeting preference. No filler, though the sentence is long and could have been split for scannability.

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 18 optional parameters, an output schema, and rich annotations, the description is adequate but thin: it doesn't explain the precedence among its many targeting modes (id vs label vs selector vs ocr_text) or when this tool is correct versus the overlapping ui_click/pointer_click siblings.

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 rich per-parameter descriptions (including the auto target resolution order), so the baseline is 3. The description only echoes the coordinate-vs-semantic distinction already spelled out in the x/y/id/target fields, adding no new parameter meaning.

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

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

States a specific verb and resource: click a native desktop control or screen coordinate on a paired computer. Scope is clear, but with near-duplicate siblings like ui_click, pointer_click, and browser_click in the set, it never explicitly says how it differs from 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?

"After inspecting the current UI" gives a usable precondition, and "use a semantic target when available" implies preferring element targeting over coordinates. However, that preference is expressed as parameter selection within this tool, not as routing guidance against ui_click/pointer_click, which an agent must still guess between.

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?

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so the safety profile is known. The description adds the genuinely useful note that collapsing can hide information required for the next step, which explains the destructive hint in practical terms, but says nothing about what happens when the target is already collapsed, and nothing about permissions or side effects on selection/focus.

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 the action up front and the caution immediately after; nothing is wasted. Minor deduction because the caution's phrasing ('information needed for the next action') is slightly abstract for an operational instruction.

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?

An output schema exists and annotations are rich, so return values and safety need not be re-explained. But for a 17-parameter tool with an enum target and multiple fallback strategies, the description gives no indication of which target types are valid for collapse or how it behaves when the element is not expanded, leaving a real 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% across all 17 parameters, each with its own documentation, so the schema carries full param meaning. The description contributes no guidance on which targeting mode (id, label, coordinates, ocr_text, selector) is preferred for collapse, so baseline 3 applies.

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

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

States a concrete verb (collapse) and concrete resources (expanded tree item, menu, disclosure control), which is more specific than the sibling name computer_expand alone. It does not distinguish itself from the near-duplicate ui_collapse or from computer_toggle, which could also collapse a control, so an agent still has to guess which of the three to call.

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?

'Inspect the target first' gives a precondition, and 'avoid hiding information needed for the next action' gives a caution about when not to collapse. However, it never names an alternative or says when computer_expand, ui_collapse, or computer_toggle should be chosen instead, leaving the selection decision implicit.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false and openWorldHint=true. The description reinforces this with concrete consequence language ('dropping can move files or change application state') and adds a verify-endpoints-first prerequisite that annotations cannot express — genuine added context, though it says nothing about failure modes, permissions, or what happens on an aborted drag.

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 tight sentences, zero filler, with the action framing front-loaded before the risk note. 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?

An output schema exists and annotations cover the safety profile, lowering the bar. However, for a 26-parameter destructive gesture tool with two distinct targeting modes, the description omits how to specify source and destination consistently, leaving an agent to infer valid parameter combinations that the schema does not enforce via required fields beyond 'device'.

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% across 26 parameters, so the schema carries the burden and a baseline 3 applies. The description adds the useful framing that endpoints may be semantic elements or raw screen coordinates, but never names the corresponding parameter pairs (from_id/to_id vs from_x/to_x/from_y/to_y), hold_ms/duration_ms gesture timing, or the target mode selector.

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 (drag-and-drop / selection gesture) and scope (between native desktop elements or screen coordinates), which is much clearer than the bare tool name. It does not distinguish itself from close siblings such as drag_drop, pointer_down/pointer_move/pointer_up, or computer_select, so an agent cannot rule those out from the text alone.

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?

"Confirm the source and destination first" implies a precondition, and the warning about consequences hints at when caution is needed. But there is no explicit guidance on when to pick this over drag_drop or a manual pointer_down/move/up sequence, and no statement of what 'verified' means or how to verify.

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?

Annotations already disclose destructiveHint=true and openWorldHint=true, so the description does not need to repeat safety warnings. It meaningfully adds that expansion 'reveals child controls' and 'may trigger application-side effects depending on the target,' which is useful behavioral context beyond annotations, though it stops short of detailing what those effects might be.

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 waste, front-loading the core action before adding the behavioral caveat. 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?

Given the rich schema (100% coverage), output schema, and annotations, the description provides enough purpose and side-effect context for an agent to call the tool correctly. It could better acknowledge the multi-target capabilities shown in the schema (browser, OCR, coordinates) rather than focusing only on native controls, but it is largely 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 all 17 parameters. The description adds no parameter-specific meaning, leaving baseline 3 appropriate for a definition whose 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 states a specific verb ('expand') and names concrete resources ('native tree item, menu or disclosure control'), so the core action is clear. It does not differentiate from sibling tools like ui_expand or computer_collapse, leaving the agent to infer which expand variant to use.

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 'Use this to expand' provides implied guidance but offers no explicit when-to-use/when-not-to-use conditions and no alternatives. The agent must infer that this is the right tool from context alone.

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?

Annotations declare readOnlyHint=false and destructiveHint=false; the description adds meaningful behavioral context by clarifying that focusing is non-activating (no typing/button activation), which resolves ambiguity about side effects. It doesn't cover return values, but the output schema exists.

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 tightly worded sentences with zero waste, and the primary action is front-loaded ahead of the limitation caveat.

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 17-parameter tool with an output schema and full schema coverage, the description supplies the essential behavioral framing. It doesn't explain target-type tradeoffs in depth, but structured fields fill that gap.

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

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

Schema coverage is 100%, so all 17 parameters are already documented in the schema. The description adds no parameter-level detail beyond 'semantic target', leaving the schema to carry the burden. Baseline 3 is correct.

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

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

States a specific verb and resource ('bring an identified native desktop control into focus'), which implicitly distinguishes it from browser_focus and window_focus by specifying 'native desktop control'. It doesn't explicitly name those siblings, so differentiation is inferred rather than stated.

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?

Clear context: 'before typing or interacting with it' establishes the when, and 'Prefer a current semantic target' gives selection guidance. The caveat 'focusing alone does not type text or activate a button' rules out misuse, though no siblings are named as 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?

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, but the description adds genuine context beyond them: that invoking can submit forms, change application state, or trigger irreversible actions, and explicitly that it does not run shell commands or page JavaScript. This scoping of side effects is useful and non-redundant.

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 tight sentences: usage trigger, prerequisite resolution step, then behavioral risks and non-goals. Front-loaded and free of filler, though the caveat clause is slightly dense.

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?

An output schema exists so return values need no explanation, and annotations cover the safety profile. The description supplies the trigger, the resolution prerequisite, and side-effect scope, leaving only parameter-selection heuristics unaddressed despite 17 parameters.

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

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

Schema description coverage is 100% across all 17 parameters, so the schema already documents id, name, role, target, label, etc. in detail. The description adds no parameter-level guidance (e.g., which of id/name/label/coordinates to prefer), so the baseline 3 is appropriate.

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

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

States a specific verb (activate/invoke) and resource (native desktop accessibility control on a paired computer), with concrete examples (menu item, button). The 'paired computer' framing distinguishes it from the local ui_invoke sibling, but no sibling is named explicitly, so differentiation is inferred rather than stated.

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

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

Gives clear when-to-use ('when the user asks to activate an identified native desktop accessibility control') and a prerequisite workflow ('Resolve the intended control from a recent computer_snapshot or ui_find first'). It does not name alternatives such as computer_click, computer_toggle, or computer_select, so an agent must infer the boundary from the verb alone.

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?

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true. The description usefully reinforces that 'individual edits can change application data' and urges verification before applying, but it omits batch-critical behavior: edit ordering, partial-failure semantics, and whether the batch is atomic.

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 use case followed by the safety instruction. Every clause earns its place with no filler.

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

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

An output schema exists, so return values need not be explained, and annotations cover the destructive/non-idempotent profile. For an 18-parameter destructive batch tool, though, the description should address what happens when one edit's target is missing or fails mid-batch, since that determines whether the agent should split edits or retry.

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%, including full documentation of the nested edits object fields (method, clear, label, etc.), so the baseline is 3. The description adds only the notion of a bounded batch and pre-identified targets; it does not clarify selection precedence among id/app/pid/name/role or the meaning of the top-level parameters for a multi-edit action.

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: a bounded batch of native accessibility edits on already identified desktop controls. 'Batch' and 'native accessibility' make the purpose clear, though it never names the single-edit siblings (computer_set_value, computer_type, ui_set_value) it is distinct from.

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

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

'Use this for a bounded batch' establishes when the tool applies, and 'Verify each requested change and target before applying' adds a safety precondition. However, it gives no explicit when-not guidance or alternatives for single edits, browser form fills, or UI elements that still need identification via ui_snapshot/ui_find.

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?

Annotations only declare readOnly=false, destructive=true, idempotent=false, openWorld=true, which tells an agent almost nothing about real consequences. The description supplies the useful mitigating fact that selection alone does not open or delete files, plus the staleness constraint implied by "fresh snapshot" and the "verified" qualifier suggesting target resolution can fail. It could go further on what happens to targets that no longer resolve.

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 tight sentences, purpose first then constraint, with no restatement of the title or schema. Nothing could be removed without losing 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?

The tool is complex (18 params, 7 target modes, open-world, destructive-flagged) yet the description is two sentences; an output schema exists so return values need not be explained, and the schema is fully documented, which lowers the burden. Still, target-resolution behavior and failure modes for stale or non-matching targets are left entirely to inference.

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

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

Schema description coverage is 100% and every one of the 18 parameters is already documented in-schema, so the baseline applies. The description only gestures at the `targets` array ("identified targets") and adds no extra semantics about how id/label/name/role are combined for matching or how the top-level target enum interacts with per-target fields.

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

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

"Select multiple verified native desktop items as one semantic accessibility operation" gives a specific verb (select), an explicit cardinality (multiple), and the mechanism (native accessibility), which distinguishes it from single-item computer_select/ui_select. It stops short of naming those siblings directly, so differentiation is inferred rather than stated.

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?

"Supply identified targets from a fresh snapshot" is a real precondition (element ids/labels must come from ui_snapshot/ui_find). However, there is no guidance on when to use this versus computer_add_to_selection, computer_select, or the ui_* equivalents, which is the main routing ambiguity among the ~15 selection-related siblings.

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