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

With no annotations, the description carries the full behavioral burden, yet it discloses nothing beyond the bare action. It does not say whether the click auto-waits for the element, scrolls it into view, throws on missing elements, or how it handles overlays. Only the minimal 'click' semantics are conveyed.

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

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

The description is a single short phrase with zero waste and is front-loaded. However, it is arguably under-specified rather than genuinely concise, giving the agent too little to act on in a crowded sibling set.

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 interaction tool with no annotations and no output schema, the description is too thin. It omits waiting/auto-scroll behavior, failure modes, and how it differs from the many related click and mouse tools, which 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?

There is a single parameter with 100% schema description coverage, so the schema fully documents it (CSS or text selector with an example). The description adds no parameter meaning beyond what the schema already provides, making the baseline 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 clear verb+resource ('Click an element'), which is immediately understandable. However, it does not distinguish this tool from near-identical siblings such as dblclick, mouseClick, mouseDown, and mouseUp, leaving the agent to infer the difference. This is adequate but not differentiating.

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

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

There is no guidance on when to use this versus dblclick, mouseClick, or click-after-scroll patterns. No prerequisites or preconditions (e.g., element must be visible/attached) are stated. The agent must guess the intended usage context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the launch-vs-connect precondition, but does not state that this terminates the app/process, what happens to the active session or connection afterward, or whether state is lost.

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 the critical constraint in parentheses. No filler, 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?

For a zero-param, no-output tool, the description covers the action and its key precondition. The only real gap is post-close implications (session/process state), which is minor given the tool's simplicity.

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

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

The tool takes zero parameters, so the schema has nothing to document and the description correctly adds no parameter detail. Baseline 4 applies for a no-argument tool.

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

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

States a specific verb ('Close') and resource ('the Electron app'), disambiguating the bare name 'close'. The parenthetical explicitly distinguishes it from the 'connect' sibling, so an agent can tell it apart from connect/launch 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?

The parenthetical 'only works with launch, not connect' gives an explicit precondition and names the alternative mode it is incompatible with. It stops short of saying what to do instead if the session was opened via connect, but the when/when-not guidance 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?

No annotations are provided, so the description carries the full burden. It indicates connecting to a running app via CDP but doesn't disclose what happens on success/failure, whether it's idempotent, authentication needs, or connection lifecycle. Minimal behavioral context beyond the mechanism.

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 sentence, front-loaded with the action and target, zero waste. Example is embedded compactly.

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

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

For a tool with no annotations and no output schema, the description should do more to explain connection behavior, success/failure, or interaction with sibling tools like launch/disconnect. It provides basic purpose and an example but leaves key operational context 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 100% and the single parameter 'port' is fully documented in the schema with a default. The description adds no extra parameter detail, but with full schema coverage and only one optional parameter, the baseline of 3 is raised to 4 as the schema suffices.

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 (Connect) and resource (already running Electron app via CDP), and clarifies the target is an existing instance. It doesn't explicitly differentiate from the sibling 'launch' but the 'already running' wording implies the distinction.

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 mentions an example (bun run dev:local with --remote-debugging-port), which gives implied context for use, but it does not state when to use this versus 'launch' or 'disconnect' explicitly. No when-not-to-use 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?

No annotations are provided, so the description carries the full behavioral burden and mostly fails it. It does not say what is returned (a numeric count), whether it throws on an invalid selector, or whether it waits for elements to appear.

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 short sentence with no filler, front-loaded on the action. It is efficient, though the terseness is partly under-specification rather than disciplined conciseness.

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 no annotations, the description should at minimum describe the return value (a count) and failure behavior for an invalid selector. It leaves those gaps entirely unaddressed for a tool whose whole purpose is producing a count.

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 there is a single well-documented 'selector' parameter (CSS selector), so the schema does the heavy lifting. The description adds no syntax or format detail beyond the schema, 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?

The description states a specific verb (Count) and resource (elements matching selector), which is unambiguous within a browser-automation toolset. It does not differentiate itself from siblings like getText or isVisible, but the counting operation is distinct enough that an agent can identify 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?

No guidance is given on when to use this tool versus alternatives such as isVisible, getAttribute, or evaluate that could also inspect DOM elements. There are no exclusions or prerequisite conditions 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?

With no annotations provided, the description carries the full burden and says nothing about side effects (navigation, form submission, text selection), wait/settle behavior after the click, or failure modes for missing or non-interactable elements. It discloses no behavioral traits beyond the action name.

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

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

A single short sentence with zero waste and the action front-loaded. It is efficient, though its brevity reflects under-specification rather than disciplined editing.

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 and no annotations exist, so the description must cover return behavior, timing/waits, and error conditions on its own — and it does not. For an interaction tool with implicit side effects, this leaves meaningful 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?

Only one parameter, and schema description coverage is 100%, so the schema already documents the CSS selector. The description adds no meaning about selector syntax, matching rules, or behavior with multiple matches, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Double-click an element'), which is clearer than the bare name alone. However, it draws no distinction from closely related siblings like click, mouseClick, or mouseDown/mouseUp, so an agent must infer the boundaries 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?

No guidance on when a double-click is appropriate versus the many sibling click/mouse tools, and no prerequisites such as element visibility or scroll-into-view requirements. Usage is left entirely 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses one key side-effect constraint (the app stays alive), which is the most important thing to know. However, it says nothing about whether the CDP session can be resumed, whether the operation is idempotent, or what state is torn down.

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 short sentence with the core action front-loaded and the most decision-relevant caveat (does not close the app) placed immediately after. 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?

For a parameterless, annotation-free teardown tool with no output schema, the description covers the essential behavior. It would be complete at 5 if it noted the session/connection state left behind or whether the agent must reconnect before further CDP calls.

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

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

The tool takes zero parameters, so there is nothing to document; baseline 4 applies. The empty schema is consistent with the description, which implies no arguments are required.

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

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

States a specific verb (disconnect) and resource (CDP), and the parenthetical distinguishes it from the sibling 'close' by clarifying that the app itself is not terminated. An agent can route between close and disconnect 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?

Usage is only implied through the contrast with 'close' — the agent can infer this is the right call when it wants to detach from the browser/session while leaving the app running. There is no explicit statement of when to call it, in what order relative to connect/launch, or whether reconnection is possible.

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

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

No annotations are provided, so the description carries the full burden. It doesn't say whether this is a single atomic action, whether it waits for the drop, whether it dispatches HTML5 drag events or pointer events, or what it returns. For an interaction tool with zero annotation coverage, that's a meaningful 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?

A single short sentence that is front-loaded and wastes no words. It is not under-specified for a tool with this name and a fully documented 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 browser automation gesture tool with no annotations and no output schema, the description omits crucial operational context: how the drag is performed, whether it works with HTML5 draggable elements, timing, and return values. The agent has enough to attempt a call but not enough to do so reliably.

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 schema already documents both parameters as CSS selectors for source and target. The description adds no syntax, format, or matching-semantics details beyond what the schema provides, 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?

The description states a specific verb and action ('Drag and drop') plus the two endpoints involved, which is clear. It doesn't explicitly differentiate from siblings like mouseDown/mouseUp or click, so an agent must infer that this is a composite gesture, but the purpose is unambiguous.

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

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

No when-to-use guidance, no exclusions, and no mention of alternatives such as mouseDown+mouseMove+mouseUp for multi-step drags. The agent gets no help choosing between this and the low-level mouse 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits, yet it only mentions the execution context (renderer process). It omits critical information such as security implications, whether the script can mutate page state, error handling, or return behavior for an arbitrary code execution tool.

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

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

The description is a single, front-loaded sentence with zero wasted words. It is appropriately sized for a simple one-parameter tool.

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

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

For a tool that executes arbitrary JavaScript in a renderer process, the description is severely lacking. It does not address security risks, expected return values, error conditions, or any usage constraints, leaving the agent without essential context to invoke it safely and correctly.

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

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

Schema description coverage is 100%, so the single 'script' parameter is already well-documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, which is the baseline expectation.

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 ('Execute') and resource ('JavaScript') with a clear scope ('in the renderer process'), which implicitly distinguishes it from the sibling 'evaluateMain'. However, it does not explicitly name the alternative tool or clarify the boundary, so sibling differentiation 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?

No guidance is provided on when to use this tool versus alternatives like 'evaluateMain', nor are any prerequisites, side effects, or exclusions mentioned. The description merely states what it does, leaving usage context entirely to the agent.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It identifies the execution context but omits side effects, safety risks, return behavior, and privilege implications of running arbitrary code in the main process.

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

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

A single front-loaded sentence with zero filler. It names the verb, resource, and process directly, which is as concise as possible for this tool signature.

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 are no annotations and no output schema, so the description must carry behavioral context, but it omits return values, async behavior, safety constraints, and error handling. The one parameter is documented in the schema, but the high-risk nature of main-process execution is not addressed.

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 single script parameter is already fully documented by the schema, including the objects it receives. The description adds no additional parameter meaning, 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?

States a specific verb (Execute), resource (code), and scope (Electron main process). It implicitly distinguishes from the renderer-oriented sibling evaluate by naming the main process, but does not explicitly name or contrast the alternative.

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

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

The description says what it does but gives no guidance on when to use it instead of evaluate or other siblings. No prerequisites, exclusions, or renderer-vs-main context are provided.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether existing field content is cleared, whether the element is focused, whether input/change events fire, or what happens if the selector is not 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?

A single efficient sentence with zero waste, but it is so terse that it underspecifies behavior needed to invoke the tool correctly. Brevity here comes at the cost of useful detail.

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 annotations and no output schema, the description should compensate for the missing behavioral context. It fails to explain clearing behavior, event triggering, focus, or error handling for a mutation-style DOM interaction.

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 parameters are already documented in the schema. The description adds no syntax or format detail beyond what the schema provides, 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?

The description states a concrete verb ('fill') and resource ('text into an input field'), which is clearer than a tautology. However, it offers no differentiation from the sibling 'type' tool, which likely performs a similar text-entry action.

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

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

There is no guidance on when to use 'fill' versus alternatives such as 'type', 'click', or 'press'. The agent is left to infer the distinction between filling and typing on its own.

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

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

With no annotations, the description carries the full behavioral burden but discloses almost nothing. 'Get' implies a read, but it does not say what happens if the attribute is absent (null vs throw), whether it waits for the element, or whether the value is resolved live.

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 efficient sentence with the operation front-loaded and zero filler. Nothing is wasted for a two-parameter getter.

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 and no annotations, so the description should explain the return value (e.g., string or null when missing) and element-resolution behavior. For a getter tool this key information is absent, leaving the agent guessing about the result contract.

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 'selector' and 'attribute' are already documented in the schema. The description adds no syntax or formatting detail beyond what the schema provides, so the baseline of 3 applies.

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

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

States a specific verb ('Get') and resource ('attribute value of an element'), so an agent understands the operation. However, it does not distinguish itself from the sibling getText (which retrieves text content) or explain how attribute-based retrieval differs, so differentiation 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?

No when-to-use guidance is given. It does not say when to prefer this over getText, evaluate, or snapshot, nor does it state prerequisites such as the element needing to exist or be attached.

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

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

No annotations are provided, so the description carries the full burden. It doesn't say what happens if the element isn't found, whether it waits for the element, what form the text takes (trimmed, innerText vs textContent), or whether it requires the element to be visible. For a DOM interaction tool with zero annotation coverage, this is a significant 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?

A single concise sentence with zero waste, front-loaded with the action and target.

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 browser automation tool with no annotations and no output schema, the description does not explain return values (e.g., string contents), error behavior when the selector matches nothing, or synchronization (auto-wait) behavior. An agent has significant unanswered questions before invoking it.

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%; the single 'selector' parameter is already documented as 'CSS selector'. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource: 'Get text content of an element.' This is clear and distinct from siblings like getAttribute, snapshot, or evaluate. It lacks sibling differentiation, but the operation 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?

No when-to-use guidance, no indication of when this is preferable to evaluate, snapshot, or getAttribute. The description gives no context for selection among 28 siblings.

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

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

No annotations are present, so the description carries the full disclosure burden, and it discloses almost nothing: no indication of whether the element is scrolled into view first, whether hover state persists, whether events are dispatched, or how failures are reported. The only implicit behavior is that a mouse-over interaction occurs, which is minimal.

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 short sentence, front-loaded, with no filler or redundancy. It is efficient, though its brevity reflects under-specification rather than disciplined concision.

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

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

This is a low-complexity tool with one required parameter at full schema coverage, so the bar is modest. Still, an agent gets no guidance on return/error behavior, hover timing, or its relationship to sibling mouse tools, leaving gaps that a single extra clause could have closed.

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

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

There is a single parameter with 100% schema description coverage ("CSS selector"), so the schema already documents it fully. The description adds no format, matching, or targeting semantics beyond the schema, which is the expected baseline for a fully covered parameter.

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?

"Hover over an element" simply restates the tool name plus its object; it adds no scope, target type, or distinguishing detail beyond what the name already conveys. It is not misleading, but it is essentially a tautology against 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?

There is no statement of when to use this versus the many sibling interaction tools (notably mouseMove, mouseDown/Up, or click). No prerequisites, sequencing, or exclusions are provided, so the agent must infer usage entirely.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only visibility check, but does not explain return semantics, timing/wait behavior, handling of missing elements, or what 'visible' means in this context.

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

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

The description is a single front-loaded sentence with no wasted words. It is concise and structurally clear, though it is minimal for a tool with no annotations or output 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?

The tool is simple and the schema covers the only parameter, but there is no output schema and the description does not state the return value or visibility semantics. For a predicate tool, explicitly saying it returns a boolean would improve completeness.

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

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

Schema description coverage is 100%, and the sole parameter is documented as a CSS selector. The description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Check if element is visible.' It is not vague, but it also does not differentiate this predicate tool from siblings like getAttribute or evaluate, nor does it mention the selector parameter.

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

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

There is no guidance on when to use this tool versus alternatives such as getAttribute, snapshot, or evaluate. The description gives only the basic purpose and no conditions, 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?

With no annotations, the description carries the full burden. It does disclose a meaningful behavioral trait — that this builds and starts a fresh instance rather than attaching to an existing one — but says nothing about process lifecycle, whether an existing instance is killed, permissions, or startup 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 compact sentence with the key behavioral detail (builds and runs fresh instance) front-loaded in parentheses. No waste, though it is minimal rather than richly structured.

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

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

No output schema and no annotations, so the description must convey return/lifecycle behavior; it does not say what launching yields or how it relates to the subsequent connect/close siblings. Adequate but with clear gaps for a process-spawning 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 env, appPath, and headless are already documented in the schema. The description adds no syntax, defaults, or semantics beyond what the schema provides, 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?

Specific verb (launch) and resource (Electron app), with the scope clarified as a fresh built instance for testing. It implicitly contrasts with 'connect' (which presumably attaches to an existing app), but does not name the 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?

'for testing' and 'builds and runs fresh instance' imply the usage context vs connect, but there is no explicit statement of when to use launch versus connect/close or any prerequisites. Usage 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?

No annotations are provided, so the description carries the full behavioral burden. For an input-injecting tool that can trigger navigation or mutations, it discloses nothing about auto-waiting, scrolling into view, out-of-viewport coordinates, or return 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 front-loaded clause with no wasted words. It is terse rather than bloated, though the brevity edges toward under-specification rather than efficient completeness.

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 coordinate-based click tool with no annotations and no output schema should explain prerequisites, wait behavior, and what a click may trigger. Almost none of that context is present for a 4-parameter interaction 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 all four parameters (x, y, button, clickCount) are already documented in the schema, including the default for button and clickCount. The description adds no coordinate format, origin, or unit details beyond the schema, so baseline 3 applies.

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

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

States a specific verb (click) and the mode (coordinates), and the parenthetical '(without selector)' implicitly distinguishes it from the selector-based `click` sibling. It stops short of naming that sibling explicitly, so the differentiation requires a small 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?

No when-to-use or when-not-to-use guidance beyond the bare '(without selector)' hint. It never names `click`, `dblclick`, or `mouseDown`/`mouseUp` as alternatives, and says nothing about preconditions such as the page being loaded or the target being in the viewport.

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

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

No annotations are provided, so the description carries the full disclosure burden and does not meet it. It never states that the press occurs at the current cursor position (implying a prior mouseMove), that the button stays held until mouseUp, or any state/ordering requirements — all essential for a stateful input primitive.

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 short sentence with zero padding, which is structurally clean, but the brevity is under-specification rather than effective conciseness for a stateful primitive in a 28-tool suite.

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 tool is simple, so little is strictly required, but for a stateful mouse primitive the missing information — cursor-position dependency and the required mouseUp pairing — is exactly what an agent needs to invoke it correctly alongside its 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 description coverage is 100% and the single 'button' parameter is fully documented with an enum and default in the schema, so the description adds nothing but also needs to add nothing. 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 verb+resource is stated ('press mouse button down'), which is concrete enough to be understood, but it does not differentiate itself from the many overlapping siblings (click, mouseClick, dblclick, press, mouseUp). An agent cannot tell from this text why it would use mouseDown rather than click.

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

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

No when-to-use guidance at all. In a suite containing click, mouseClick, dblclick, mouseUp, and mouseMove, the description never explains that this is a low-level primitive typically paired with mouseUp (e.g. for drag or hold gestures) rather than a standalone action.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core action and does not mention what coordinate system is used (screen vs viewport), whether the operation is blocking, or any side effects. For a GUI automation tool, this leaves significant behavioral gaps.

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

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

The description is a single, well-formed sentence that is front-loaded with the essential action. Every word earns its place without redundancy or filler. It is appropriately sized for a simple tool.

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

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

Given the absence of annotations and output schema, the description should provide more context to be complete. It does not explain the coordinate system, the effect of the steps parameter beyond the schema, or any usage constraints. For a three-parameter tool with no behavioral metadata, this is insufficient.

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%, so all parameters (x, y, steps) are fully documented in the schema. The description adds no additional meaning beyond what the schema provides, such as coordinate origin or step behavior. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states a specific verb 'Move' and resource 'mouse cursor' plus the target 'specific coordinates'. It distinguishes from siblings like click or drag by focusing solely on movement, but it does not explicitly differentiate from hover or mouseClick which might also move the cursor. Overall, 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 guidance on when to use this tool versus alternatives such as hover, mouseClick, or drag. There is no mention of prerequisites, context, or exclusions. Usage is only implied by the tool name and description.

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

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

No annotations are provided, so the description carries the full burden and provides almost nothing: no mention of required prior state (a held button), effect on drag operations, or error behavior if no button was pressed. Only the minimal action is stated.

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 words, front-loaded with the verb, zero waste. Appropriately sized for a trivial UI primitive, though it is arguably too terse to be self-sufficient.

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

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

For a one-parameter input primitive with no output schema, the description covers the core action but omits the operant context — pairing with mouseDown, drag semantics, and whether coordinates or focus matter. 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 coverage is 100% and the single 'button' parameter is documented with an enum and default, so the schema does the work. The description adds no format or semantic detail beyond what the schema already conveys; 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+resource ('Release mouse button') that unambiguously identifies the action. It is clearly distinguishable from most siblings, though it does not explicitly name its counterpart mouseDown or clarify the pair relationship.

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

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

No guidance on when to use this versus mouseDown, mouseClick, or click. The key context — that this typically pairs with a preceding mouseDown, e.g. for drag operations — is absent.

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

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

No annotations are provided, so the description carries full behavioral burden. It doesn't disclose whether the key press targets the currently focused element, whether it's a single key event or a combination, or any side effects (e.g., triggering form submission on Enter). The example 'Control+S' hints at modifier support, but the description doesn't explain behavior or interaction context.

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

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

A single, front-loaded sentence with zero waste. It is appropriately sized for a simple tool, though that brevity contributes to the gaps in other dimensions.

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

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

Given no annotations and no output schema, the description is too thin for a tool that performs an action in a browser or UI context. It omits crucial context such as where the key press is directed, whether it requires a prior focus action, and potential side effects. An agent would need to infer these details from siblings or trial and error.

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

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

Schema coverage is 100%, with the single parameter 'key' fully described including examples of key names and combinations. The description adds no meaning beyond what the schema provides, so baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb ('press') and resource ('keyboard key'), which is clear enough to distinguish from siblings like click, fill, and type. However, it gives no additional scope or qualifier that would help an agent differentiate from the related 'type' tool (which likely types text) or emphasize the keyboard shortcut aspect implied by the example 'Control+S'.

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?

Provides no guidance on when to use this tool versus alternatives. With siblings like 'type' (which may enter text) and 'click'/'fill', the agent has no explicit direction on choosing 'press' for single key presses or shortcuts. The description is a bare statement of purpose with no usage context.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about the return format (base64 image, URL, or file path), whether it blocks, or side effects. For a capture tool with zero annotation coverage this is a meaningful 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?

A single short, front-loaded sentence with no filler. It is efficient, though its brevity is also the source of the missing detail rather than deliberate compactness.

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?

Low complexity and a well-documented one-parameter schema make this close to adequate, but with no output schema and no annotations, the description should at minimum state what the call returns (image data vs. path) and how fullPage alters 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 description coverage is 100% and the single optional parameter is already documented as "Capture full scrollable page," so the baseline is 3. The description adds nothing about the parameter and its "current window" phrasing mildly conflicts with the full-page behavior.

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 ("Take a screenshot") and resource ("current window"), which no sibling tool duplicates, so an agent can select it unambiguously. The scope wording is slightly muddled by the fullPage parameter, which extends capture beyond the named window.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as snapshot (which likely exposes DOM/accessibility state instead of pixels). The agent must infer that this is the visual-capture path.

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

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

No annotations are provided, so the description carries the full burden. It discloses the input mechanism (mouse wheel) but not defaults for zero/omitted deltas, whether scroll is instant or animated, whether it waits for scroll to settle, or whether scrolling is bounded by the viewport.

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 short sentence with no filler, front-loaded with the verb and target. It is appropriately sized, though minimal.

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 mutation-ish interaction tool with zero annotations and no output schema, the description omits the behavior an agent needs: default magnitudes when deltas are omitted (both params are optional), scrolling semantics, and any effect on page state. Adequate only at the very lowest bar.

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 both parameters are documented with sign conventions in the schema itself. The description adds nothing beyond what the schema provides, 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?

States a specific verb (Scroll) and resource (the page), and notes the mechanism (mouse wheel). It is distinguishable from scrollTo and scrollIntoView by name, but the description doesn't explain how it differs from those siblings.

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

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

No when-to-use or when-not-to-use guidance. With siblings scrollTo, scrollIntoView, mouseMove, and mouseDown all in the same family, an agent has no stated basis for choosing wheel-scroll over those alternatives.

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

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

With no annotations, the description carries the full behavioral burden and is a single sentence. It does not say which scroll container is affected (nearest scrollable ancestor vs. page), whether alignment options exist, whether it waits for the scroll to finish, or what happens if the selector matches nothing.

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

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

A single front-loaded sentence with no filler, appropriate for a one-parameter tool. It is efficient but arguably over-terse given the missing behavioral detail.

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 required param, no output schema, no nested objects), so a short description is defensible. Still, nothing is said about scrolling context or failure modes, leaving the definition minimally adequate rather than 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 single selector parameter is already fully documented in the schema. The description adds no additional semantics, which is the expected baseline when the schema does the work.

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

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

The description states a clear verb (scroll) and resource (element) plus the effect (into view), so an agent knows exactly what action occurs. It does not, however, distinguish this tool from the sibling scroll or scrollTo, both of which likely scroll the page in other ways.

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

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

No guidance is given on when to use this versus scroll, scrollTo, or mouseMove-driven scrolling. The agent must infer the distinction from the name 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention whether scrolling is instant or animated (beyond the schema's behavior enum), whether it waits for completion, what it returns, or any side effects. Only the core action is stated.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple action tool, though brevity comes at the cost of other dimensions.

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

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

Given no annotations, no output schema, and sibling tools with overlapping functionality, the description is incomplete. It fails to differentiate from 'scroll' and 'scrollIntoView' and does not disclose behavioral details needed to invoke the tool correctly beyond the schema.

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

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

Schema coverage is 100%, so the x, y, and behavior parameters are fully documented in the input schema with defaults. The description adds no additional meaning beyond implying that x and y define an absolute position, which the schema already conveys.

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

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

The description states a clear verb (scroll) and resource (absolute position on the page), making the tool's basic purpose understandable. However, it does not distinguish this tool from its siblings 'scroll' and 'scrollIntoView', which likely provide similar functionality with different semantics.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'scroll' or 'scrollIntoView'. It simply states what it does without any usage context, exclusions, or conditions.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about whether change events are fired, whether multi-select is supported (the '(s)' hints at it but is not explained), what happens if the value is absent, or whether the dropdown must already be open. For a DOM-mutating interaction tool this is a substantial 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?

A single, front-loaded sentence with no wasted words. It is efficient, though arguably under-specified rather than optimally concise for a tool interacting with form controls.

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 structurally simple (2 fully documented required params, no output schema, no nested objects), so the schema covers the invocation surface adequately. Still, the description omits behavioral detail about event firing, multi-select, and error cases that an agent would want when automating form interaction.

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

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

Schema description coverage is 100%, with both selector ('CSS selector for select element') and value ('Value or label to select') documented in the schema. The description adds no syntax, format, or matching semantics (e.g., value vs. visible label precedence) beyond what the schema already states, so the baseline of 3 applies.

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

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

The description states a specific verb (Select) and resource (option(s) from a dropdown), which is clear on its own. However, it does not differentiate this tool from the many sibling interaction tools such as fill, click, or type, leaving the agent to infer that this one is specifically for <select> elements.

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

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

There is no guidance on when to use this tool versus alternatives like fill or click, nor any prerequisite such as the element having to be a native select or the dropdown being open. The agent must infer usage entirely from the one-line purpose.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only, non-destructive operation by saying 'Get ... snapshot,' but it does not disclose side effects, safety, freshness, or output characteristics. For a tool with zero annotation coverage, this is a significant 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?

A single, front-loaded sentence with zero waste. It immediately communicates the action, the resource, and the purpose.

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

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

There is no output schema, so the description should ideally explain what the snapshot returns and how to use it (e.g., element references for subsequent actions). It names the accessibility tree but does not describe the return shape or how the snapshot connects to click/fill siblings, leaving a gap for an 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?

The tool takes zero parameters, so according to the rubric the baseline is 4. The schema is empty and the description adds no parameter information, but none is needed.

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

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

States a specific verb ('Get') and resource ('accessibility tree snapshot of the page') and adds the purpose ('for finding elements'). It distinguishes itself from screenshot implicitly, but does not explicitly name any sibling tool, so it falls short of the 5-level 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 parenthetical '(for finding elements)' implies the usage context, so an agent can infer this tool should be used before interacting with elements. However, it does not explicitly state when to use this over alternatives like screenshot, nor does it mention when not to use it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the meaningful trait that typing is per-character and fires key events, but says nothing about focus/visibility prerequisites, timing/speed, or failure behavior when the selector does not match a typeable element.

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 short sentence with no filler, front-loading the action and then the behavioral mechanism. 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?

For a simple two-parameter tool with full schema coverage and no output schema, the description is nearly sufficient. The only meaningful gap is that per the sibling set (focus, visibility, special keys) an agent could benefit from knowing prerequisite element state.

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 both parameters ('selector', 'text') are documented in the schema, so the description only needs to avoid contradicting it. It adds no extra meaning such as selector match scope or whether text may contain special keys (e.g., Enter/Tab), 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 ('Type text') plus a distinguishing mechanism ('character by character, triggers key events'). This implicitly separates it from the sibling 'fill', which is presumed to set values directly, though the sibling is never 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?

The parenthetical '(triggers key events)' hints at when this is preferred over a direct value-set such as 'fill' (e.g., inputs needing keystroke events), but usage is only implied. No explicit when-to-use, when-not-to-use, or named alternative 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?

With no annotations, the description carries the full burden, yet it says nothing about blocking behavior, what happens when the timeout elapses (throw, return false, silent continue), or what the call returns. These are the critical traits for a wait primitive and all are absent.

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

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

It is a single front-loaded phrase with no waste, but it is under-specified rather than genuinely concise. Brevity here comes at the cost of the behavioral detail an agent needs.

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

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

For a tool with no annotations, no output schema, and undefined failure semantics, the description should at minimum explain timeout behavior and the return value. The fully documented schema helps the inputs, but the runtime contract is 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%, so selector, state (with enum and default), and timeout (with default) are already fully documented in the schema. The description adds no syntax or semantic detail beyond that, 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 verb 'Wait' plus the resource 'element or condition' gives a general sense of the action, but 'condition' is never defined and no sibling is referenced (isVisible, snapshot, getText all overlap in intent). An agent can guess the purpose but cannot distinguish it cleanly from the other observation tools.

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

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

There is no statement of when to wait versus polling with isVisible or snapshot, nor any prerequisite or sequencing guidance. The description offers nothing an agent can use to choose this tool over its siblings.

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