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

Annotations only declare openWorldHint, so the description carries the load and does: per-step output framing ('## step <n>: <tool>'), images retained, skipped-step listing on failure, truncation behavior with the exact cut marker, and the no-nesting rule. These are non-obvious traits an agent could not infer from the schema.

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

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

Front-loaded with the core capability, then failure and truncation semantics, with no filler. A few phrases are compressed to the point of ambiguity — 'the rest is shared' and 'a cut step ends with' require a second read.

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 no output schema, the description correctly explains the return framing and truncation, which is the right thing to cover. It leaves open whether batched steps share session state and how errors from an individual step are surfaced when stop_on_error is false.

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

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

Schema coverage is 0%, yet the description defines both parameters: steps as [{tool, args}] with a 50-item ceiling, and stop_on_error with its default (true) and concrete effect (remaining steps listed as skipped). This fully compensates for the undocumented 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 with scope: 'Run up to 50 tool calls sequentially in one call.' The meta-tool nature is immediately distinguishable from every browser-action sibling (click, navigate, snapshot), and the step shape is shown inline.

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 sequential, single-call framing plus the 'cannot nest' restriction gives clear context for when this applies, and stop_on_error's default defines failure handling. It stops short of naming an explicit alternative (e.g. issuing calls individually or in parallel) or stating when not to batch.

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

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

With only openWorldHint in annotations, the description adds meaningful behavior: it lists actionability waits (visible, stable, enabled, not covered) and describes the effect summary including navigation, tabs, dialogs, downloads, alerts, and console errors. It still leaves some behavioral details such as force overrides to the schema, but it substantially carries the disclosure burden.

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 dense sentences with no filler. The action and target forms are front-loaded, followed by auto-wait behavior and return summary, which is an efficient structure.

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?

There is no output schema, so it is useful that the description summarizes return effects and actionability behavior. However, for an 8-parameter tool it omits usage guidance and leaves several parameters unclarified, making it adequate but with clear gaps.

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

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

Schema description coverage is moderate at 63%, and the schema already documents target, tab, force, snapshot, and timeout_ms. The description restates target forms and explains the return summary, but does not add meaning for count, button, or modifiers, so parameter semantics remain only adequate.

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 target', and enumerates accepted target forms (ref, coordinates, selector). It does not explicitly distinguish itself from siblings like hover or drag, so it is clear but lacks sibling differentiation.

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

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

The description gives no when-to-use or when-not-to-use guidance, no prerequisites, and no alternatives. The only implied usage is that it clicks a target, which is not enough to route an agent between click and related tools.

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 readOnlyHint/openWorldHint; the description adds genuinely new behavior: a 500-entry buffer created at tab creation, an exact return format string with timestamp and source location, and the fact that clear empties the buffer after reading. That last point is a side effect worth knowing and is not covered by 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?

Front-loaded with what the tool returns and then packed with the format and per-flag semantics; almost no waste. The clauses are dense and semicolon-chained, but each 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?

No output schema exists, so the description supplies the return shape and cap itself; with zero required parameters and no nested objects, the only thing an agent needs to call it is covered here or in the schema. Nothing material is missing.

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

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

Schema coverage is only 40%, and the description compensates by explaining three of the five parameters: level's enum semantics (notably that 'warning' includes warnings and errors), pattern as substring or /regex/, and clear's after-read behavior. Only limit and tab are left to the schema, which already documents both.

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 pair: console messages and uncaught page errors for a tab, with the buffer origin (tab creation) and cap (500) made explicit. It is clearly distinct from the sibling network tool, though it never names a sibling to differentiate against.

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 debugging use case is implied rather than stated, and there is no explicit guidance on when to reach for console instead of network, evaluate, or dialog. What guidance exists is per-parameter (what level and pattern mean), not situational.

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 provide openWorldHint, so the description carries most of the burden; it discloses useful behavior (alerts auto-accepted, text answers a prompt, accept vs dismiss). It omits failure behavior when no dialog is pending, whether a dismissal loses form data for beforeunload, and whether the call blocks.

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 with the action and target front-loaded, followed by the prompt-text and auto-alert caveats. 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?

There is no output schema, and the description covers the key semantics (action, text, which dialog types) for a low-complexity tool. A note on the no-pending-dialog case would close the remaining 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 33% (only 'tab' is documented), so the description compensates by explaining that 'text' answers a prompt, which the schema leaves bare. The accept/dismiss enum is self-describing; the active-tab default is already in the schema.

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

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

States a precise verb pair (accept or dismiss) and a specific resource (pending JS dialog: confirm, prompt, beforeunload) on a tab. No sibling tool in the list covers dialog handling, so the agent can identify it unambiguously.

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 'Alerts are auto-accepted' is real when-not-to-use guidance, telling the agent not to call this for alert dialogs. It also clarifies that text only matters for prompts. It stops short of saying when a dialog appears (e.g., after click/type) or what happens if none is pending.

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

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

With only openWorldHint=true in annotations, the description carries most of the burden; it usefully discloses that real mouse events are dispatched (not synthetic JS dispatch), which is behaviorally meaningful. However, it says nothing about prerequisites (elements needing to be visible/in viewport), auto-scrolling, timing between press/move/release, or failure behavior.

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

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

A single tight sentence with the core action front-loaded and one qualifying clause that earns its place by naming supported drag mechanisms. 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?

For a 3-parameter, fully documented tool with no output schema and minimal annotations, the description covers what the tool does but omits operational context an agent would want: viewport/visibility requirements, scroll-into-view behavior, drag timing, and what a failure looks like.

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 'from', 'to', and 'tab' are already fully documented with accepted formats (refs, coordinates, Playwright selectors). The description adds no meaning 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?

The description states a specific verb and resource ('Drag from one target to another') and clarifies the mechanism ('real mouse events') plus the drag flavors it handles (HTML5 DnD and pointer-event drags). It distinguishes itself from siblings like click and hover by implication, but never names them 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?

The clause about HTML5 and pointer-event drags implies when this tool applies, but there is no explicit guidance on when to prefer it over alternatives such as click, evaluate, or a scripted sequence, and no stated prerequisites or exclusions.

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

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

Adds real behavior beyond the annotations: promises are awaited, results are JSON and truncated, DOM elements come back as snapshot lines with refs, and page exceptions surface as errors. It does not warn that arbitrary script can mutate page state (which is left to destructiveHint), but the output and error semantics are well disclosed.

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

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

Five short sentences, front-loaded with the action, each adding a distinct fact (script form, promise handling, result shape, error behavior). 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?

With no output schema, the description supplies the return-value contract and the error contract, which is the main gap it needed to fill. Minor omission: what happens to 'target' when a plain expression rather than a function is passed, and whether execution is scoped to one tab or frame beyond the 'tab' param.

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 only 33% schema coverage, the description carries most of the load and does so: 'script' is explained as an expression or function source, and the otherwise undocumented 'target' is given meaning as the element passed to that function. The 'tab' parameter is covered only by the schema, which is fine since the schema documents it.

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

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

States a specific verb and resource: 'Run JavaScript in the page.' Nothing in the sibling list overlaps with arbitrary code execution, so the tool is practically distinguishable from hover/click/snapshot. It never names an alternative, though, so there is no explicit sibling differentiation.

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

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

Usage is only implied: you gather that this is the code-execution escape hatch for scripting or extraction. The description never says when to prefer it over snapshot, read, find, or wait, nor any precondition such as needing a loaded page.

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

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

With only openWorldHint in the annotations, the description carries the behavioral burden and adds useful details: text-like values are replaced, submit is gated on all fields succeeding, results are one line per field, and values are never echoed. It does not explain partial-failure atomicity, such as whether successful fields remain filled when another field fails.

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 key behavior is front-loaded and nearly every clause earns its place. The value-type mapping is a long run-on sentence, so structure could be improved with bullets, but the content is not 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?

For a moderately complex batch mutation with no output schema, the description covers the important value coercion rules, submit gating, and per-field result summary. It leaves gaps around the `target` selector format and what happens to partially successful fills when another field fails.

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?

Although schema coverage is already 80%, the description adds crucial semantics for the polymorphic `value` parameter: string for text-like fields, option value/label or string[] for select, boolean for checkbox/switch, true or label/value for radio, paths for file, and string for date/time/color/range. This is substantially more useful than the schema's bare anyOf union.

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: fill several fields in one call, with an optional submit click. The batch phrasing and the submit condition distinguish it from the single-field `type` sibling without requiring 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?

It makes the batch case clear (several fields in one call) and specifies that submit is clicked only if every field succeeded. It does not explicitly name `type` as the single-field alternative or state when not to use it, so it stops short of full routing guidance.

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

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

Annotations already cover the safety profile (readOnly, openWorld), and the description adds genuinely new behavior: search spans all frames, exact matches are ordered first, and each hit returns as a snapshot line with its ref plus an ' in <heading/landmark>' indented line. No output schema exists, so that return-format disclosure is doing real work. Minor gaps remain on zero-result behavior and limit interplay.

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 sentences, front-loaded with the match semantics, then ordering, then the enumeration special case, then the return shape. No filler and no restatement of the tool 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?

For a four-parameter read tool with no output schema, the description covers matching rules, frame scope, ordering, the empty-query mode, and the returned line format. It leaves unaddressed what an agent sees when nothing matches and how limit/truncation is surfaced, which are the only meaningful omissions.

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 tab, role, limit, and query are all documented in structured fields. The description reinforces the cross-field rule (empty query + role = enumerate) and adds the otherwise-unstated 'case-insensitive substring' semantics, but it does not define the role vocabulary or the ref format beyond naming them. Baseline 3 fits.

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 ('find') plus the exact match surface: case-insensitive substring over accessible name, visible text, placeholder, label, and value, across all frames. The scoping (all frames, smallest element for split text, exact matches first) makes it distinguishable from read/snapshot siblings that dump rather than search.

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 operating context: use an empty query with a role to enumerate every element of that role, and note that exact matches sort first. It never explicitly names an alternative (e.g., 'use snapshot for the full tree' or 'use read for page text'), so the routing decision is inferred 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 only declare openWorldHint=true, so the description carries most of the behavioral burden. It helpfully discloses that the action reveals :hover menus and tooltips, but it omits details like whether any state persists, timing behavior, or what the tool returns.

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 sentence with the core action front-loaded and a compact parenthetical adding the key effect. There is no wasted text.

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

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

For a simple two-parameter interaction tool with full schema coverage and no output schema, the description covers the essential purpose and effect. Minor gaps remain around timing and post-hover behavior, but nothing critical is missing.

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

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

Schema description coverage is 100%, so both the tab and target parameters are already fully documented in the schema. The description adds no syntax or format guidance beyond that, making the baseline 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?

States a specific verb and resource: "Move the mouse over a target." The parenthetical clarifies the effect (revealing :hover menus and tooltips). It is clear, but it does not explicitly distinguish itself from sibling tools like click or find.

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

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

The description gives clear context for when the tool is useful: when hover-triggered menus or tooltips need to be revealed. It does not state exclusions or name alternatives such as click, but the intended use case is clear.

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

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

With only openWorldHint declared, the description carries the burden well: it specifies the exact result format, that HTTP error statuses are reported rather than thrown, that network failures surface as net::ERR, and the subtle distinction between a committed-but-unsent-settled navigation (not an error, marked "still loading") and a never-committed navigation (error, stopped). That timeout semantics disclosure is exactly the non-obvious behavior an agent needs.

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

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

The primary action is front-loaded and no sentence is filler, but the middle section is a dense run-on that packs return format, error taxonomy, and snapshot options into one long clause chain. A short sentence break would improve scanability without cutting 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?

There is no output schema, yet the description precisely describes the return string format and the viewport snapshot payload, plus the error/still-loading branches. For a 6-parameter navigation tool with minimal annotations, an agent has everything needed to call it and interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds genuine meaning beyond the schema by stating that a scheme-less URL is upgraded to https and clarifying that snapshot:true attaches the whole page whereas the default attaches a viewport snapshot. Tab, wait_until, and timeout_ms are left to the schema, but that is acceptable given full coverage.

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?

Opens with a specific verb and resources: "Go to a URL (scheme-less gets https://), or back/forward/reload," which matches the action enum exactly. It is clearly distinguishable from siblings like click (which follows links in-page) and snapshot (which only captures).

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 explains the interplay with snapshot ("call snapshot for the whole page; snapshot:false to skip"), giving real routing guidance between this tool and its most confusable sibling. It does not explicitly say when to prefer a click-driven navigation over navigate, so it is strong but not exhaustive.

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

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

Annotations only declare readOnly/openWorld, so the description carries the burden and does well: it discloses the 1000-entry cap, that credentials in headers are redacted, that bodies are truncated at 10k, and that binary bodies report size only. It omits whether requests are captured only after page load or whether prior navigation history is included, which matters for interpreting an empty result.

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 dense paragraph with no filler; every clause adds information about format or filtering. It is slightly back-loaded – the output format leads and the actual purpose (request listing) must be inferred from the first few words – 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?

Six optional parameters and no output schema make the description's format string and truncation/redaction notes essential, and they are present. What is missing is capture-window behavior and default tab resolution (though the schema documents the latter), leaving only a minor completeness gap.

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

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

Schema coverage is only 33%, so the description meaningfully compensates: pattern is explained as substring or /regex/, type gets concrete examples (document, fetch, xhr, script), and failed_only is defined precisely as network failures plus HTTP >= 400. Only limit and tab semantics are left entirely to the schema, which does document them, so the gap is small.

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 identifies a specific resource (the HTTP requests issued by a tab) and even specifies the exact output line format, so an agent knows it is retrieving network activity rather than console logs or DOM state. It does not explicitly contrast itself with siblings like console or evaluate, which are the nearest look-alikes.

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?

Filtering options (pattern, type, failed_only) imply the intended debugging workflow, and the mention of request_id implies a drill-down flow, but the description never states when to choose this over console or evaluate, nor any prerequisite such as needing the page loaded or requests captured first.

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

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

With only openWorldHint, the description carries most of the behavioral burden. It usefully discloses that `target` is focused first (a real side effect) and that keys fire in order, but says nothing about whether keystrokes go to the focused element or the page, timing/delays, or failure behavior if a selector isn't found.

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 the examples replace paragraphs of format explanation. The trailing fragment "target is focused first" is terse but purposeful rather than sloppy.

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?

No output schema exists, so the description ideally would say what comes back (the `snapshot` param hints at an "effect summary" but this is never explained). For an open-world input tool with 4 params and only one annotation, the definition is adequate but leaves meaningful gaps around targeting and results.

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 50%: `tab` and `snapshot` are documented in the schema, but `keys` and `target` are raw. The description compensates well for both — chord syntax like "Control+a" and ordered sequences for `keys`, and the focus-first semantics of `target` — which the schema alone would not convey.

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 ("Press keys or chords in order") and the four examples make the exact input format unambiguous. It never names the sibling `type` tool to contrast keyboard input with text entry, so sibling differentiation is only implied.

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 examples imply when this applies (keyboard shortcuts, navigation keys, ordered sequences), but there is no explicit guidance on when to use `press` instead of `type`/`fill_form`, and no stated prerequisites or exclusions. An agent must infer the boundary itself.

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?

Beyond the readOnlyHint annotation, the description discloses meaningful behavior: boilerplate (nav, footers, cookie banners, sidebars, ads) is stripped, content is truncated at max_chars, and a continuation marker format is given verbatim. That is real added context an agent could not get from annotations alone.

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 sentences, front-loaded with output format, then exclusions, then paging. The truncation sentence is long but each clause carries operational information; nothing is redundant padding.

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

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

For a zero-required-parameter read tool with no output schema, the description covers return format, content filtering, and pagination sufficiently to call it correctly. The unexplained semantics of 'target' and the unstated default format value are minor residual gaps.

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

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

With 60% schema coverage, the description compensates well for the two most behaviorally important parameters: the max_chars truncation rule and the offset paging protocol, including the exact footer syntax. The 'target' parameter still receives no explanation of accepted values, which is the main remaining gap.

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

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

The description opens with a concrete statement of the resource returned: page (or target) main content as markdown. That clearly separates it from siblings like snapshot or screenshot, though the tool name 'read' alone would be ambiguous without it. It stops short of naming a 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?

Usage is only implied by the mention of 'target' and the offset paging hint; there is no explicit statement of when to use this instead of snapshot, find, or evaluate. An agent must infer that this is the tool for readable page text rather than DOM structure.

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 and openWorldHint, and the description still adds substantive behavior: default jpeg quality 70, long edge capped at max_edge (1280), the fact that annotate overlays are removed before returning (so the caller must not expect them to persist), and that save writes under <output-dir>/screenshots/. What is missing is what the call actually returns when save is false.

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

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

Four dense sentences with no filler, front-loaded with the capture modes before the defaults and side effects. The telegraphic phrasing ("Default jpeg quality 70, long edge at most max_edge") is efficient but costs some readability.

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

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

For an 8-parameter tool with no output schema and thin schema descriptions, the definition covers behavior well but leaves two real gaps: what is returned when `save` is false (image payload? path? reference?), and what `target` accepts (CSS selector, snapshot ref, coordinates). An agent can call it, but not confidently predict the response.

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

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

Schema coverage is only 13% (just `tab`), so the description must carry the load and largely does: it supplies defaults and meaning for quality (70), max_edge (1280), full_page, target, annotate, and save. `format` is left to the schema enum and `target`'s accepted form (selector vs. ref) is never specified.

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 first sentence names a specific verb and resource and enumerates the three capture modes (viewport default, full page, target element), which is exactly what an agent needs to decide between this and a non-visual sibling. It does not, however, explicitly distinguish itself from `snapshot` or `video`, so the boundary with those siblings is left to inference.

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?

"Afterwards, 'x,y' targets use this image's pixel coordinates" is genuine cross-tool guidance linking the screenshot to click/drag/hover, but it only covers the post-capture workflow. There is no statement of when to prefer screenshot over `snapshot` (DOM/accessibility) or `video`, and no exclusions or prerequisites.

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 provide openWorldHint, so the description carries most of the behavioral burden. It discloses the default scroll amount (80% of viewport/container), the default container (the page), and even the return format ('scrolled y=<y>/<scrollHeight> viewport=<h>') plus detection of height changes for infinite scroll – valuable context 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?

The description is a compact paragraph that front-loads the core behavior and then details the two modes and output. It is dense but every sentence adds useful information; minor room for clearer separation but overall efficient.

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

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

Given the tool's moderate complexity (5 optional parameters, two modes, container vs page defaults, infinite scroll detection), the lack of an output schema, and minimal annotations, the description provides everything an agent needs to call it correctly: defaults, mode distinctions, and expected output format.

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 only 20% (only the tab parameter is described in schema), so the description must compensate. It does well: it explains the semantics of target, direction, amount (with default), and to (top|bottom), covering all parameters except tab, whose default is already in the schema.

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

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

The description states a specific verb ('Scroll') and resource ('the page or a container'), and explicitly distinguishes two modes: scrolling a target into view versus scrolling a container in a direction. This lets an agent immediately understand what the tool does without opening the schema.

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

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

It clearly explains the two invocation patterns: omitting direction/to scrolls target into view, while providing direction or to makes target the scroll container. However, it doesn't name any alternative sibling tools or explicitly state when to prefer this over e.g. click or evaluate for scrolling-related tasks.

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 supply openWorldHint=false, so the description carries most of the burden and does disclose meaningful traits: launch discards open tabs but cookies survive in a persistent profile, and close behaves differently across launch and attach modes. It stops short of covering failure modes or what happens to an existing session on relaunch.

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 dense sentence that front-loads the resource and enumerates actions with their consequences; every clause carries information. The nested parentheses make it slightly harder to scan than a short bulleted form would be.

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

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

There is no output schema, and the description nevertheless enumerates what status returns (mode, headless, browser version, profile, tabs, active tab). For a three-action lifecycle tool with thin annotations, this covers what an agent needs to invoke it correctly.

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

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

Schema coverage is 40%, so the description must compensate, and it does explain the action enum values and the launch-vs-attach distinction for mode. However, headless, isolated, and cdp_endpoint are left to the schema (only the latter two are documented there), so the gap is only partially filled.

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 the resource (browser session) and spells out the three action values with their distinct effects: status reports mode/headless/version/profile/tabs, launch restarts the browser, close ends or disconnects. An agent can distinguish this lifecycle tool from siblings like tabs or navigate 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?

It gives per-action conditions ('close the browser in launch mode, disconnect in attach modes') but never states when to reach for this tool versus siblings such as tabs or navigate, nor when launch vs connect mode is appropriate. Usage is implied by the action list rather than explicitly guided.

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 and openWorldHint, so the description needn't restate safety, and it adds real context instead: the line format, iframe inlining, and the fact that the footer signals when paging with offset is needed. It doesn't explain truncation behavior or the role of max_chars, which is the main missing piece.

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

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

One dense paragraph, front-loaded with what the tool returns, then modes and paging. Nearly every clause carries information, though the running sentence structure makes the paging rule easy to miss.

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

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

For a 6-parameter read tool with no output schema, it explains the return shape and the mode choice well. However, two parameters (max_chars, viewport_only) are left semantically empty, and truncation behavior — central to a 'compact' snapshot — is only gestured at via the footer hint.

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 50%: tab, scope, and offset are documented in the schema, while mode is documented by the description's interactive/full explanation. max_chars and viewport_only are unexplained in both places, leaving the description's compensation incomplete.

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: 'Compact accessibility snapshot of a tab', and describes the output shape (one line per element, indented by nesting, iframes inlined). That pins down the operation precisely. It never contrasts itself with siblings like read, find, or screenshot, which could otherwise look like plausible alternatives for inspecting a page.

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 partial selection guidance: interactive is the default vs full 'adds text, lists, tables, images', and 'Page with offset when the footer says so' hints at paging. But there is no explicit statement of when to prefer snapshot over read/find/screenshot, nor any prerequisites.

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

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

With only an openWorldHint annotation, the description carries the behavioral burden and does so well: default-active-tab semantics for `select`/`close`, prior-tab reactivation after close, id non-reuse, automatic popup registration, and viewport-snapshot return on `new`. It doesn't describe what `select`/`close` return or any failure/error behavior, leaving a minor 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?

Front-loaded with the tool name followed by per-action clauses, so an agent can scan for its action quickly. The nested parentheticals make it dense and slightly run-on, but every clause conveys a distinct behavior rather than restating the schema.

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

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

For a 4-parameter, 4-action tool with no output schema and minimal annotations, the description supplies the activation, ordering, and id-lifecycle rules an agent needs. Missing only return-value detail for `select`/`close` and any failure modes such as closing an invalid or already-closed tab id.

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 only 25% (just `tab`), so the description must compensate, and it largely does: `background`, `url` (only meaningful for `new`), and the `action` enum values are all given operative meaning in prose. It does not state whether `url` accepts relative paths or must be absolute, nor that `tab` is invalid for `new`/`list`.

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?

Names the resource (tabs) and enumerates all four operations — list, new, select, close — with a concrete behavior for each, including the exact list output shape. It also distinguishes itself from the `snapshot` sibling by noting `new` returns only a viewport snapshot and directing full-page capture elsewhere.

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 routes to an alternative ("call snapshot for the whole page") and states conditions such as `background:true` suppressing activation and headed-mode-only fronting for `select`. It lacks guidance on when to open a new tab versus using `navigate` in the current tab, so it stops short of full when/when-not coverage.

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 openWorldHint, so the description carries the behavioral load and does disclose two valuable traits: default replacement semantics and 'The typed text is never echoed,' which tells the agent it cannot verify input from the response. It omits failure behavior (element not found, timeout) and whether submit can trigger navigation, which matter for an open-world browser 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?

One dense sentence with semicolon-separated clauses; the core action and its default are front-loaded, and modifiers follow in the order an agent would consider them. Slightly telegraphic, but no clause is 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?

No output schema exists, and the description compensates by noting the silent-input behavior so the agent knows to verify state another way (e.g. snapshot/read). For an 8-parameter open-world action it is largely complete, with only failure and post-submit side effects left unstated.

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 50%; the undocumented parameters are exactly text, append, slowly and submit, and the description defines all four in prose, including the default (replace) that the schema leaves unstated. It adds no detail for target, tab, snapshot or timeout_ms, but those already have schema descriptions.

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

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

States a specific verb and resource ('Type text into a field') plus the accepted field kinds (input, textarea, contenteditable). It does not explicitly distinguish itself from the sibling fill_form or press, so the agent must infer the boundary from names 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?

Gives conditional guidance for each behavioral mode: append for adding, slowly for autocomplete widgets, submit to press Enter afterwards. No explicit when-not-to-use or named alternative (e.g. fill_form for multi-field entry, press for bare keystrokes) is given.

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 only annotation is openWorldHint=true, so the description carries most of the burden and does so well: it discloses that chooser interception suppresses the native dialog, that paths must resolve inside enumerated allowed roots, and that dot-files are refused unless a flag is set. It does not describe failure behavior (e.g., what happens when a path is rejected) or whether uploads are synchronous, which keeps it from 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?

Single densely packed paragraph with the action front-loaded and no filler sentences. The parenthetical notes earn their place by explaining observable behavior, though the sentence is long enough that an agent must parse several constraints at once.

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 no output schema and only three parameters, the description covers the operationally important ground: target resolution modes, path sandboxing, and hidden-file policy. It omits what the tool returns or reports on success/partial failure, which is a modest gap given there is no output schema to fall back on.

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 67% and the description compensates for the undocumented core parameter: it explains what kinds of target are acceptable and — more importantly — the behavioral difference between them, going beyond the schema's enumeration of ref/point/selector forms. It also qualifies the paths parameter with root restrictions and hidden-file rules. The tab parameter is left entirely to its schema description, so not a 5.

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

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

The description opens with a specific verb and resource ("Upload files") and immediately distinguishes the two invocation mechanisms: a direct input[type=file] versus an element that opens a chooser. That is enough for an agent to tell it apart from siblings like type, fill_form, or click without opening any 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?

It clearly explains the two contexts in which the tool applies (direct file input vs. chooser-opening element) and notes that no native dialog will appear in the second case, which shapes how the agent should sequence calls. It does not name an alternative tool or explicitly state when not to use it, 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?

With only openWorldHint in annotations, the description carries the burden and does well: it discloses that seek-based capture restores playback time and paused state, that DRM-black frames are flagged rather than silently returned, that `save` writes images to <output-dir>/frames/, and that every_ms samples in real time. It stops short of stating timeouts, failure modes for missing videos, or cross-origin restrictions beyond the iframe note.

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 purpose, then organized by action, and no sentence is filler. The telegraphic style ('play/pause/seek(time)/set(rate, muted, volume, loop)') is efficient but occasionally compresses past readability, e.g. the 'frames' sentence packs three capture modes into one clause.

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, multi-mode tool with no output schema, the description covers the return shape of `list` (explicit field list), the frame labeling convention ('frame i/n @ mm:ss.ss'), and caption formatting. Minor gaps remain around play/pause/set return values and error behavior, but an agent has enough to invoke it correctly.

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

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

Schema coverage is already 94%, so the baseline is 3; the description adds real value by explaining the mutually exclusive frame-capture modes (times list vs count over start..end vs every_ms + duration_ms) and by tying captions to the start/end window. It also explains the `target` default, which the schema repeats but the description anchors to the overall selection rule.

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?

Opens with a specific verb+resource ('Watch videos on the page (all frames, incl. cross-origin iframes)') and then enumerates every action mode (list/play/pause/seek/set/frames/captions) with what each returns. The scope is unambiguous, though it never explicitly contrasts itself with the screenshot/snapshot siblings that also produce images.

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

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

Usage is implied through the action-by-action breakdown and the default target rule ('the largest visible playing video, else the largest visible one'), which tells the agent how to omit `target` safely. There is no explicit guidance on when to prefer this over `screenshot`/`snapshot` for capturing video frames, and no stated preconditions such as whether the video must be playing or the page focused.

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?

Adds meaningful behavior beyond the openWorldHint annotation: the timeout produces an error that names the failed condition, and ms is an unconditional sleep capped at 30000. It doesn't say whether the call throws vs. returns on timeout explicitly, nor describe polling behavior, but the critical failure semantics are disclosed.

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

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

A single dense sentence with the primary constraint front-loaded and conditions enumerated in parentheses. Efficient, though the parenthetical enumeration of state and url forms makes it slightly harder to scan than a short bulleted phrasing would be.

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

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

For a 9-parameter tool with no output schema, the description covers what matters: the condition menu, the exclusivity rule, the ms cap, and timeout error behavior. Remaining gaps (tab scoping and timeout_ms default) are documented in the schema, so nothing essential is missing.

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

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

With only 22% schema description coverage, the description compensates heavily: it explains url accepts substrings or /regex/, that state defaults to visible when paired with target, that ms is the unconditional mode with a 30000 cap, and that condition params are alternatives. This is semantic detail the schema cannot convey.

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 (wait) and enumerates exactly what it waits on: text, text_gone, target/state, url, load_state, ms. This is precise and immediately distinguishable from siblings like snapshot or evaluate, which read state rather than block on it.

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?

'Wait for exactly one condition' establishes the key usage constraint (mutual exclusivity of condition types) that no schema field expresses. It does not name alternatives or say when a wait is unnecessary (e.g., vs. snapshot or evaluate), leaving some inference to the agent.

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