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

With no annotations, the description must carry the burden of behavioral disclosure. It explains how to target an element but says nothing about side effects, navigation, waiting behavior, or error handling. The iframe chaining detail is more parameter guidance than behavioral context, leaving the post-click outcome unspecified.

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 core action and immediately followed by a precise iframe usage note. Every sentence earns its place with no filler or redundancy.

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

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

For a simple 2-parameter tool, this is minimally adequate: it covers the basic click action and frame handling. However, without annotations or output schema, it lacks guidance on choosing this ref-based click over sibling click variants and does not explain expected return values or errors.

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 already documents both parameters, including the chaining syntax for nested frames. The description's frameSelector mention largely restates schema content, adding no significant extra semantics.

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

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

The description uses a specific verb ('Click') and clearly identifies the target as an element by ref from the snapshot. This distinguishes it from coordinate-based, locator-based, or text-based click tools among the 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?

The description gives clear context for when to use this tool ('by ref from the snapshot') and provides concrete iframe usage instructions with chaining syntax. It does not explicitly exclude or compare against sibling click tools, but the ref-based condition implicitly defines its niche.

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 clarifies the coordinate frame ('relative to a frame's viewport') and how to target nested frames, which are meaningful behavioral traits. It does not mention click event details, wait behavior, or side effects, but these are less critical for a simple coordinate click action.

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

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

The description is two sentences long, with the core action first and usage guidance second. Every sentence adds value without redundancy or filler. This is a model of 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?

Given the tool's complexity (5 parameters, no output schema, no annotations), the description provides necessary context for when to use coordinate-based clicking and how to handle nested frames. It does not explain return values, but that is not essential for a click action. The description, combined with the schema, provides sufficient context for most use cases.

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

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

The input schema provides descriptions for all 5 parameters (100% coverage), so the schema already documents the parameters. The description adds minimal extra meaning by reinforcing the coordinate system and frame chaining, but this largely duplicates the schema. Baseline 3 is appropriate because the description does not significantly add beyond the structured 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 clearly states 'Click at (x, y) relative to a frame's viewport,' which identifies the specific verb, resource, and coordinate system. It distinguishes from sibling tools by noting the use case 'when snapshot/refs are unavailable (e.g. cross-origin or canvas),' separating it from element-based click 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?

The description explicitly says 'Use when snapshot/refs are unavailable' and gives examples (cross-origin, canvas), which clearly indicates when to use the tool. It also instructs to 'Chain frameSelector for nested frames,' providing practical usage guidance. However, it does not explicitly mention alternative tools or when not to use it, so it stops short of full 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?

No annotations are provided, so the description carries the full burden. It discloses the implementation method (Playwright page.mouse.click) and reliability, but it does not mention side effects (e.g., triggering events, scrolling) or prerequisites (e.g., frame must be loaded). For a mutating action 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?

Two sentences, front-loaded with the core action and then a clarifying example and implementation note. Every word earns its place with no fluff.

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

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

The tool is simple, and the schema covers all parameters, but with no output schema and no annotations, the description doesn't describe what happens upon success/failure or whether the click occurs even if no element is at the coordinates. It is adequate for basic usage but lacks deeper context for a complete picture.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds an example that maps (0.5, 0.9) to center-bottom, which is helpful but largely redundant with the per-parameter descriptions. It doesn't provide syntax details beyond what the schema already documents.

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 action ('Click') with a precise scope ('at relative position (rx, ry) in [0..1] inside the frame'). The example '(0.5, 0.9) = center-bottom' further clarifies the behavior and distinguishes it from absolute-position click tools like 'browser_click_at'. However, it doesn't explicitly name sibling alternatives, so it falls just short of a 5.

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

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

The description implies usage for clicking at relative coordinates within a frame and mentions reliability ('Uses Playwright page.mouse.click for reliable coordinates'). It does not contrast with alternatives (e.g., 'browser_click' for element-based clicks) or state when not to use it. This is clear context but with no 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?

No annotations are provided, so the description carries the full burden. It discloses what it returns (screenshot, page coordinates, in-frame pixel) and a key limitation ('No dot drawn'), which is valuable behavioral context. It does not mention error behavior or side effects, but for a read-only debug tool this is sufficient.

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

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

The description is two sentences, front-loaded with the main output, and every word adds value. It conveys the essential information without any redundancy or irrelevant 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?

For a simple debug tool with no annotations and no output schema, the description covers the return value, key limitation, and usage intent. It lacks details on error handling or coordinate interpretation, but the tool's scope is narrow and the description is sufficiently complete for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema, only re-mentioning rx and ry in the context of click_at_rel. It does not provide extra meaning for frameSelector or the exact format of coordinates.

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

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

The description clearly states the tool returns a frame screenshot plus exact page coordinates and in-frame pixel where click_at_rel(rx, ry) would click. It distinguishes from siblings by explicitly mentioning 'No dot drawn' and 'use to verify target', contrasting with actual click tools like browser_click_at_rel.

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

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

The phrase 'use to verify target' gives a clear when-to-use scenario. It implies this is a debugging/verification alternative to click_at_rel, and the context of sibling tools reinforces that. However, it does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden. It discloses the locator-based approach and frame handling, and notes enabledOnly to click the first enabled match. However, it omits behavior like waiting for actionability, scrolling, error handling on no match, or navigation consequences, which is a notable 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?

Three concise sentences. The core purpose is front-loaded, and every sentence provides essential usage guidance without redundancy.

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

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

For a 10-parameter tool with no annotations, the description covers the crucial aspects: primary locator modes, iframe handling, and optional parameters. It doesn't mention timeout or force, but those are well-documented in the schema, and overall the description is sufficient for typical use.

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%, giving a baseline of 3. The description adds value by enforcing the 'provide one of' rule and clarifying semantics for nth, enabledOnly, and scopeCss beyond what the schema states.

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 it clicks by Playwright locator, and outlines the specific locator strategies (role+name, text, css). This distinguishes it from coordinate-based or text-evaluation click tools among its 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?

It gives concrete usage instructions: use frameSelector for iframes, omit for main page, and provide one of role+name, text, or css. It does not explicitly compare against alternative click tools like browser_click or browser_evaluate_click, but the intended usage 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 no annotations provided, the description carries the burden of behavioral disclosure. It transparently reveals that it bypasses visibility/actionability, runs in frame context, and works only for same-origin frames. This is useful, but it doesn't mention side effects or failure behavior beyond the timeout parameter, so it's not fully comprehensive.

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 three short sentences, each delivering essential information: what it does, why to use it, and its constraint. It is front-loaded and free of filler, making it highly efficient for an agent to parse.

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 complexity (frame clicks, bypassing actionability), the description covers the core behavior, usage scenario, and a key limitation. It lacks an explicit statement about return values or what happens on failure, but the schema's timeoutMs and the absence of an output schema keep this from being a major 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?

The input schema already provides full descriptions for all parameters (100% coverage), so the baseline is 3. The description reinforces the frame context and the bypassing behavior, which indirectly clarifies the purpose of the frameSelector and css parameters, but it doesn't add significant new parameter-level detail beyond the schema.

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

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

The description clearly states the tool clicks an element inside a frame using DOM .click(), with the context of running in frame context. It distinguishes itself from sibling tools by specifying the mechanism (DOM .click()) and the limitation (same-origin frame only), making its purpose unambiguous.

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

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

It explicitly says to use when locator click fails (e.g., SUBMIT disabled or not visible), providing a clear trigger condition. It also notes the same-origin frame limitation, but does not name sibling alternatives directly or explicitly state when not to use it, so it falls just short of full guidance.

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

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

With no annotations, the description carries the transparency burden. It discloses key behaviors: using DOM .click(), bypassing visibility/actionability and overlay issues, and the same-origin frame constraint. However, it does not mention potential event simulation differences or error behavior, so it is not fully transparent.

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

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

The description is compact: three sentences, each adding unique value. The main purpose leads, followed by behavioral notes and usage guidance. No fluff or repetition.

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

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

The tool is relatively simple (click action), and the schema fully documents all parameters. The description provides usage context, constraints, and clarifies when to choose it over alternatives. However, it does not describe return values or failure modes, but for a click tool this is acceptable. Given the lack of annotations, a complete description would ideally mention error handling, but overall it is adequate.

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 does not add extra parameter information beyond what the schema already provides; the mention of 'text content' aligns with existing parameter descriptions. No additional semantics are provided.

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

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

The description states a specific action: 'Click an element by its text content via DOM .click() inside the frame.' It clearly identifies the method and resource, and differentiates from siblings by positioning it as a fallback when 'locator/click_at_rel fail' and by noting the same-origin frame restriction.

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

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

The description explicitly says 'Use when locator/click_at_rel fail (e.g. quiz options)', naming alternatives and providing an example scenario. It also notes the limitation 'Same-origin frame only', which serves as an exclusion criterion.

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 burden. It adds useful context such as 'page coordinates' and the return tuple, but does not disclose whether the operation is read-only, what happens if the frame selector is invalid, or any potential side effects. This is a minimal but not misleading disclosure.

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

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

The description is two short sentences with no fluff. The first sentence states the core function, and the second provides a concrete usage example. Every word earns its place.

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

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

For a simple one-parameter read-only tool with no output schema, the description covers the essential return shape and suggests a primary use case. It does not explicitly mention 'iframe' in the description, but the schema does. Overall, it is reasonably complete for the tool's complexity.

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 fully documents the single parameter 'frameSelector' with the instruction 'use >> for nested'. Since schema description coverage is 100%, the description adds no extra parameter meaning beyond what the schema already 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?

The description clearly states the tool's purpose: 'Get bounding box (x, y, width, height) of the frame in page coordinates.' It uses a specific verb ('Get') and resource ('bounding box of the frame'), and the mention of 'browser_click_at' distinguishes it from other browser 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?

The description gives explicit usage context: 'Use with browser_click_at or to compute relative clicks.' This tells the agent when to use the tool, though it does not explicitly exclude alternatives or list when-not-to-use scenarios.

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 disclosure burden. It truthfully lists what the tool returns (iframes, canvas rects, shadow root count, bodyRect) and indicates it runs 'inside the frame,' suggesting a read-only operation. It does not mention side effects, error behavior, or timeout handling, but for an inventory operation the output disclosure is sufficient.

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

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

The description is two sentences, with the first sentence enumerating the exact output items and the second providing the use case. Every word earns its place, front-loading the essential information without any fluff.

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

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

Given the absence of an output schema, the description compensates by enumerating key output fields (id, name, src, rect, bodyRect) and the count of shadow roots. It is adequate for an inventory tool, but it does not specify the exact shape of rectangles or potential failure modes, leaving minor 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?

The input schema covers both parameters with descriptions: frameSelector ('Chained iframe selector') and timeoutMs. The description adds no additional parameter-level meaning beyond reinforcing the 'inside the frame' context, which aligns with frameSelector. Since schema coverage is 100%, a 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?

The description uses a specific verb ('list') and identifies exact resources: child iframes, canvas elements, shadow root count, and bodyRect. It clearly distinguishes itself from sibling tools by framing the output as an inventory of frame internals, with a concrete use case (detecting nested iframes or canvas UI).

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

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

The description states when to use the tool: 'Use to see if visible UI is in a nested iframe or canvas.' This provides clear context but does not explicitly name alternatives or exclusions. It implies a diagnostic role without comparing to sibling tools like browser_frame_probe or browser_snapshot_frame, so it falls short of a full 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?

No annotations are provided, so the description carries the full burden. It discloses the probe's return fields and the interpretation of failures (counts=0 may mean canvas), which is helpful. However, it doesn't mention side effects, behavior when the frame isn't found, or that it waits for the frame to resolve (timeoutMs implies this but isn't 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, focused sentence that front-loads the primary output and then adds a diagnostic note. Every word earns its place with no redundancy or filler.

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

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

Without an output schema, the description compensates by listing the exact fields returned (url, title, readyState, counts, textSample) and providing a diagnostic interpretation. It's sufficient for a probe tool, though it could clarify how the results are structured or formatted.

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%: both parameters have clear descriptions (frameSelector with an example, timeoutMs with default and purpose). The tool description adds no additional parameter context, 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 clearly states the tool's function: 'Run a small diagnostic inside a frame' with specific outputs (url, title, readyState, counts, textSample). It distinguishes itself from sibling tools like browser_snapshot and browser_frame_inventory by focusing on DOM visibility probing.

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 explicit usage context: 'Use to see if Playwright can see DOM (if probe fails or counts=0, UI may be canvas).' This tells the agent when to choose this tool, though it doesn't explicitly name 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 burden of behavioral disclosure. It only states the action, not what happens when history is empty, whether navigation blocks or waits, or what success/failure looks like.

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, front-loaded sentence with zero waste. It is as concise as possible while conveying the core 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?

This is a simple parameterless tool, but contextual completeness is reduced by the absence of return values, error behavior, or navigation semantics. The description is minimally viable but leaves important behavior unspecified.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter details, but none are needed.

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

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

The description 'Go back in history' clearly states the action (go back) and the resource (history), distinguishing it from sibling tools like browser_go_forward and browser_navigate. It is terse but 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is the opposite of browser_go_forward, nor does it advise against using it when no history exists.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Go forward in history' without specifying behavior when no forward history exists, whether it waits for page load, or any side effects. This is a minimal disclosure.

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, concise sentence that directly conveys the tool's purpose. It is front-loaded and contains no unnecessary words or repetition, earning a high score for 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?

For a simple tool with no parameters and no output schema, the description is adequate but lacks edge-case context such as behavior when history is empty. It is complete for basic use but could benefit from a note on failure modes.

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

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

The tool has zero parameters, and the schema is empty. The baseline for 0 parameters is 4, and there is no need for parameter documentation. The description adds no parameter information, which 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 'Go forward in history' clearly states the action with a specific verb and resource. It is distinguished from siblings like browser_go_back, which covers the opposite direction, and browser_navigate, which handles direct navigation.

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 usage is implied: use this tool to move forward in the browser's history. However, there is no explicit comparison to alternatives or mention of when not to use it, though the tool's simplicity makes the context fairly intuitive.

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 discloses the implementation ('elementFromPoint'), the return fields (tag, id, class, rect, pointerEvents, cursor; iframe src/name), and implies a read-only, non-mutating operation. It lacks an explicit statement about no side effects, but the overall behavior is well 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 three concise sentences: what it does, what it returns, and its purpose. Each sentence earns its place with no fluff or redundancy. It is front-loaded with the core action and remains highly readable.

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 must explain return values, which it does by listing the fields. With no annotations, it also covers the behavioral aspect. It does not mention error cases (e.g., element not found) or clarify that it does not perform a click, but for a simple hit-test tool, the provided information is largely sufficient.

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 minimal extra parameter meaning beyond the schema—it mentions that rx/ry are relative in [0..1] and that the operation is inside a frame, but these are already captured in the schema descriptions. The description does not provide additional context about the parameters (e.g., coordinate mapping, frame chaining nuances).

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

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

The description clearly states the verb ('Return'), the resource ('element at relative (rx, ry)... inside the frame'), and the method ('via elementFromPoint'). It also explains the purpose ('Confirms where clicks land'), distinguishing it from sibling tools like browser_click_at_rel (which clicks) and browser_frame_bbox (which returns geometry).

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

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

The description provides clear context by stating the tool confirms where clicks land, implying use for hit-testing/verification before actual clicks. It does not explicitly name alternatives or exclusions, but the intended use case is evident from the description and the sibling tool names.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states the action and iframe handling, but doesn't disclose whether the hover has side effects, triggers events, or requires any preconditions. This is minimal coverage.

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

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

The description is two short sentences, directly front-loads the action, and contains 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 simple two-parameter tool, the description covers the primary use and the frame case, but given no annotations, it could mention that hovering may trigger UI changes or that the element must be visible. Still, it's largely complete for its 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 input schema already describes both parameters with 100% coverage; the description's frameSelector note duplicates the schema's description. No new parameter semantics are added, 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?

The description uses a specific verb 'Hover' and identifies the resource 'an element by ref', clearly distinguishing from sibling tools like browser_click or browser_type. It directly states the core action.

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

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

It provides explicit iframe usage guidance ('Use frameSelector when target is inside an iframe'), which is clear context. However, it doesn't discuss when to prefer hover over alternatives or exclusions, so it lacks full comparative guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses that only visible clickables are listed, that listing is frame-scoped, and that various filters are supported. This covers key behavioral traits, though it does not mention return format or potential side effects (which are minimal for a list operation).

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

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

Two tight sentences with no redundancy. The first sentence states the core function, the second lists filter options and the use case. Every word earns its place.

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

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

For a tool with 9 parameters and no output schema, the description provides sufficient context for selection and invocation: it names the resource, timing, and main filter dimensions. It does not describe the return structure, but parameter details are fully covered in the schema, so overall completeness is good.

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 baseline is 3. The description adds value by grouping filter options (role+name, text, css, enabledOnly, scopeCss) but doesn't elaborate on parameters like timeoutMs or includeBoundingBox beyond what the schema already provides.

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

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

The description begins with a clear, specific action: 'List visible clickable elements (buttons, links) in a frame.' It also distinguishes this tool from the sibling browser_snapshot by adding 'Use to discover what to click without snapshot.'

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 closing phrase 'Use to discover what to click without snapshot' gives clear context for when to use this tool. It implicitly differentiates from browser_snapshot but does not explicitly state when not to use it or name alternative 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does not mention whether navigation waits for page load, what happens after navigation, potential side effects, or error behavior. The description adds no details beyond the action itself.

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 very concise with no unnecessary words. It is front-loaded and efficient, though it lacks the depth seen in higher-quality descriptions.

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 simple navigation tool with one parameter and no output schema, but the description does not explain expected outcomes such as whether the page load completes, what is returned, or how to verify success. It is incomplete for an agent to use confidently.

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 parameter 'url' is described as 'URL to open'. The tool description 'Navigate to a URL' adds no additional meaning beyond the schema, 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?

The description 'Navigate to a URL' uses a specific verb and resource, clearly indicating the tool's primary action. It does not explicitly differentiate from sibling tools, but the action is distinct enough given the tool name.

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 browser_go_back, browser_go_forward, or browser_wait. The description simply states the action without context 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, but it only restates the action ('Press a key') and adds iframe targeting. It does not disclose behavior like event sequencing, modifiers, focus requirements, or potential side effects such as navigation. This is a minimal disclosure with little added 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 two short sentences, precisely front-loaded with the action ('Press a key') and examples. Every word earns its place without unnecessary 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 with two documented parameters and no output schema. The description covers the main action and the iframe nuance, but lacks any note about edge cases, wait behavior, or what happens if the key press triggers navigation, making it adequate but not rich.

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

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

The input schema already describes both parameters (key, frameSelector) with examples, so schema coverage is 100%. The description adds a note about using frameSelector to send to an iframe, which is slightly clearer than the schema's 'target the frame', but does not add significant meaning beyond the schema.

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

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

The description clearly states the tool presses a key and gives examples (Enter, Tab, ArrowRight). It distinguishes from sibling tools like browser_click and browser_type by focusing on key presses, though it does not explicitly compare. The verb 'Press' is specific and the resource is 'key'.

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 context that keys like Enter/Tab/ArrowRight can be pressed and mentions using frameSelector for iframes, but it does not explicitly state when to prefer this over browser_type or browser_click. It implies usage for key events, but no exclusions or alternatives are named.

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

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

No annotations are provided, so the description carries the full burden. It only states the scope (page or iframe) and does not disclose the output format, whether it captures the full page or viewport, or any side effects. This is insufficient for a tool with no annotation support.

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 concise sentence that is front-loaded with the verb and resource. It contains no fluff or unnecessary details, making it 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 low complexity (1 optional param, no output schema, no annotations), the description covers the core action but lacks crucial context about the return value (e.g., image path vs base64) and any behavioral constraints. It is minimally viable but not fully complete.

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

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

The schema describes frameSelector as an optional iframe selector, matching the description's mention of 'specific iframe'. Since schema coverage is 100%, the baseline is 3; the description adds no extra semantics beyond the schema.

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

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

The description clearly states the tool takes a screenshot of the page or a specific iframe, using the specific verb 'take' and identifying the resource. This distinguishes it from siblings like browser_snapshot (DOM snapshot) and browser_frame_bbox (bounding box).

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

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

The description implies usage by stating what it does (screenshot) but does not explicitly guide when to use it over alternatives like browser_snapshot. No exclusions or contextual triggers are provided, so it remains at the 'implied usage' level.

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 adds no behavioral details beyond the schema—no mention of return values, error handling, or the prerequisite of having a snapshot ref. The iframe guidance is already present in the schema, so it contributes no unique transparency.

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

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

The description is two short sentences, front-loaded with the main action and no wasted words. Every sentence is purposeful, though the second sentence is somewhat redundant with the schema, it remains concise.

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 omits return value information and preconditions such as needing a snapshot ref. The core function is clear and schema covers all parameters, but the tool's complete behavior is under-specified for an agent to fully anticipate side effects or 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?

The input schema has 100% description coverage for all three parameters, so the description adds no new semantic information beyond what the schema already states. It merely reiterates 'by ref' and iframe usage, which the schema explains.

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

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

Description clearly states 'Select option(s) in a dropdown by ref' with a specific verb and resource, differentiating it from other browser action tools like click or type. The iframe hint adds specificity, making it obvious what the tool does.

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

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

Provides clear usage context with 'Use frameSelector when inside an iframe,' which indicates when to apply that parameter. However, it does not explicitly mention alternatives or when not to use this tool relative to sibling tools, so it falls short of a 5.

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

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

With no annotations, the description must carry the transparency burden. It discloses the iframe inclusion behavior ('Set includeFrames true to include iframe content') but does not explain what the snapshot contains, how refs are represented, or any potential side effects. Adequate but not rich.

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

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

Two sentences, front-loaded with the action, and every word contributes meaning. No unnecessary detail or repetition.

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

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

For a simple tool with one optional parameter and no output schema, the description adequately covers purpose and usage. It could mention what the snapshot format looks like, but it provides enough for an agent to decide when to invoke 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?

The schema already provides 100% coverage for the single parameter (includeFrames) with a description. The tool description merely restates this option ('Set includeFrames true...') without adding new meaning, so baseline 3 is appropriate.

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

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

The description clearly states it 'Capture[s] accessibility snapshot of the current page' and explains its purpose: 'Use for getting refs to interact with.' This distinguishes it from visual tools like browser_screenshot and interaction tools like browser_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?

The description gives clear usage context ('Use for getting refs to interact with') but does not explicitly mention alternatives or cases when not to use it. This fits the 'clear context, no exclusions' level.

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 for behavioral disclosure. It discloses the nested frame syntax with an example, which is useful behavior not obvious from the schema. However, it doesn't mention what the snapshot output is (e.g., image path, base64), what happens if the selector is invalid, or explicitly confirm that it's a read-only operation. The nested-frame guidance adds some value but leaves significant 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 two sentences long and immediately states the core purpose. The example is concisely embedded and adds real value without fluff. Every word earns its place.

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

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

This is a simple tool with one parameter and no output schema or annotations. The description explains the selector mechanics well, but it doesn't state what the snapshot returns (e.g., a screenshot image) or how it relates to browser_snapshot. For an agent to fully understand the tool's effect and output, more information is needed, though the simplicity keeps it adequate.

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% since the only parameter, frameSelector, is described in the schema. The description adds value by providing a concrete example ('iframe#pplayer_iframe >> iframe#modulePlayerIframe') that clarifies the chaining format beyond the schema's generic description. This extra guidance helps the agent construct valid selectors.

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

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

The description clearly states the tool's purpose: 'Snapshot a single iframe by selector.' It specifies the action (snapshot), the resource (iframe), and the method (by selector). This distinguishes it from sibling tools like browser_snapshot which captures the full page, and browser_frame_probe which likely inspects frames.

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

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

The description provides clear context that this tool is for snapshotting a single iframe, and gives a specific example of using ' >> ' for nested frames. While it doesn't explicitly state when not to use it or name alternatives, the purpose is distinct enough that an agent can infer when to select this tool over 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?

With no annotations, the description carries the transparency burden. It discloses that typing targets the focused element or a ref, and that frameSelector handles iframes, but it does not reveal whether existing text is cleared, whether it waits for element interactivity, or what happens on failure. This is adequate but not rich.

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

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

The description is two sentences with no wasted words, front-loading the core action and adding the iframe tip second.

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 moderate complexity of four parameters and no annotations or output schema, the description covers the essential usage but omits details like the submit parameter behavior and distinctions from sibling typing tools. It is minimally viable.

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 already documents all four parameters with 100% coverage. The description reinforces the ref and frameSelector roles but adds no new semantics beyond the schema, matching the baseline.

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

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

The description clearly states the tool types text into the focused element or a ref-identified element, using a specific verb and resource. It does not explicitly distinguish from the sibling browser_type_locator, but the ref-based approach provides some 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 provides context on when to use the tool (focused element or ref) and mentions frameSelector for iframes, but it does not give explicit guidance on when to prefer this over browser_type_locator or browser_press_key. Usage is implied rather than explicitly contrasted with 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 burden of explaining behavior. It adds useful context about locator alternatives, nth being 0-based, and scopeCss resolving within a container. However, it does not disclose error handling, return values, or behavior when multiple elements match without nth, which would be valuable for a typing 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 three concise sentences, front-loaded with the core action and followed by parameter guidance. Every sentence earns its place with no redundancy or filler.

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

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

Despite having 10 parameters and no annotations or output schema, the description covers the essential usage scenario: how to target an element (role+name, text, css), how to narrow scope (nth, scopeCss), and frame handling. It omits details about submit and timeoutMs, but those are well described in the schema, so the context is largely complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond schema by enforcing the 'Provide one of' constraint and clarifying that frameSelector is for iframes only, which the schema does not convey as a mutual exclusivity 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?

The description starts with a specific verb and resource: 'Type text into an element found by locator.' It clearly distinguishes this from sibling tools like browser_click_locator by focusing on typing text and specifies the locator strategies (role+name, text, css).

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 usage constraints like 'Provide one of: role+name, text, or css' and 'Omit frameSelector for main page,' which help select locator parameters. However, it does not explicitly state when to prefer this tool over alternatives like browser_type or browser_click_locator, leaving the comparison 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?

'Wait for a number of seconds' discloses only the basic action. With no annotations provided, the description does not clarify whether the wait is blocking, whether fractional seconds are supported, or what happens with invalid values. This is minimal behavioral disclosure.

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 sentence that is direct and free of fluff. It is appropriately concise.

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 one fully documented parameter and no output schema, the description covers the core function. However, it lacks any usage context or behavioral nuance, making it minimally complete.

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

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

The schema already documents the 'time' parameter as 'Seconds to wait', and the description adds no information beyond that. With 100% schema coverage, 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 clearly states the tool's action ('Wait') and resource ('number of seconds'), distinguishing it from sibling browser tools like navigation and clicking. It is specific and non-tautological.

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, no alternatives, and no exclusions. It simply states what it does, leaving the agent to infer usage context.

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