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 says 'Click an element' without mentioning waiting behavior, visibility requirements, side effects, or failure modes. This is a minimal disclosure that does not inform the agent about what happens when the click is performed.

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 with no filler. It front-loads the action and includes the key detail about target identification. 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?

The description is sufficient for a simple click action, but it lacks context on when to use this tool versus siblings like browser_hover or browser_type. It also does not mention what the tool returns or how errors are handled. Given the moderate complexity and the availability of many sibling tools, the description is minimally adequate but not 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 all four parameters are already documented in the schema. The description itself does not add any additional meaning beyond what the schema provides. Since the schema covers everything, 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 states a specific verb ('Click') and resource ('an element') and explains how to identify it via snapshot ref or Playwright selector. This clearly distinguishes it from sibling tools like browser_hover or browser_type, so an agent can understand its purpose without ambiguity.

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 (e.g., hover, type, drag). It does not mention any conditions, exclusions, or prerequisites. An agent must infer that clicking is the intended action, but there is no explicit routing to this tool over others.

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 clearly states the core side effect: closing the browser session and releasing all resources, which signals finality and cleanup. It could explicitly mention irreversibility or that subsequent browser tools may fail, but the main behavior is transparent enough.

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

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

The description is a single, front-loaded sentence with no filler. Both clauses earn their place: 'close the browser session' states the action, and 'release all resources' adds a useful behavioral outcome.

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

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

For a zero-parameter lifecycle tool with no output schema, the description covers the essential purpose and behavioral effect. It would be slightly more complete if it noted that the session cannot be reused afterward, but the simplicity of the tool makes the current description 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?

The tool has zero parameters, so there is no parameter semantics burden for the description to carry. The baseline of 4 applies because there is nothing for the description to add beyond the empty input 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 uses a specific verb, 'Close', and an explicit resource, 'browser session', then adds the clarifying outcome 'release all resources.' This makes the tool's purpose unmistakable and distinguishes it from the navigation, input, and inspection sibling 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 no guidance about when to call this tool, such as 'use when done with the browser' or 'do not use to close an individual tab.' It relies entirely on the name and generic context, with no explicit when-to-use or when-not-to-use framing.

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 conveys a read-only operation ('Return'), defines the data source and scope ('captured since the session started'), and mentions the optional filtering behavior. It does not detail the exact return structure, but for a simple read tool this is adequate.

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. It states the main action, additional content, session scope, and the optional filter in a compact and readable way.

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 optional boolean parameter, no output schema) and the description covers its purpose, scope, and main behavior. A brief note about the return format would improve completeness, but the current description is sufficient for an agent to invoke the tool correctly.

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

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

Schema coverage is 100%, and the only parameter (onlyErrors) has a clear description in the schema. The tool description's phrase 'optionally filter to errors only' restates the schema semantics without adding new meaning, so it does not elevate beyond 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 uses a specific verb ('Return') with a clear resource ('console messages') and additional scope ('captured since the session started'), making it easy to distinguish from siblings like browser_network_requests. It also usefully includes 'uncaught page errors' as part of the result set.

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 clearly indicates when to use the tool — when console messages or uncaught page errors are needed — and specifies the session scope. It does not explicitly contrast with alternatives, but the resource and context are unambiguous enough that an agent can select it correctly without extra 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 full burden of behavioral disclosure. It only states the basic action without revealing whether the drag simulates mouse events, whether it waits for the drop to complete, any permission requirements, or potential side effects. The distinction from browser_drop is also unexplained.

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 front-loads the core action. There is no redundant phrasing or filler, making it efficient for an agent to parse quickly.

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

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

Given the absence of annotations and output schema, the description is too minimal. It does not clarify the return value, prerequisites like obtaining a snapshot, or the behavioral differences from sibling browser_drop. This leaves gaps that could lead to incorrect invocation.

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

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

The input schema already provides descriptions for startTarget and startElement, and the $ref properties endTarget and endElement inherit those descriptions, effectively covering all parameters. The description adds no extra parameter-level meaning, 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 verb 'drag' and the resource 'element', and specifies the action 'drop it onto another element'. It is distinct from sibling tools like browser_drop, which likely handles a different gesture. The mention of ref eN or selector makes the target 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 guidance is provided on when to use this tool versus alternatives such as browser_drop, browser_click, or browser_hover. The description does not mention prerequisites, typical scenarios, or when not to use it, leaving the agent to infer usage 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?

Annotations are absent, so the description alone must disclose side effects and execution traits. It states only the mechanical action and gives no indication that the drop is synthesized, whether it can trigger navigation or file-handling side effects, or whether permissions are required. This is a meaningful transparency 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?

The description is a single front-loaded sentence that packs the action, payload alternatives, and targeting mechanism without filler. It is appropriately concise for a well-schematized 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 rich 100% parameter schema, the description covers the essential invocation path: it names payload modes and the target. It still leaves behavioral details such as synthetic-event semantics and post-drop effects to inference, but this is not fatal for a simple drop action.

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 prose echoes `paths`, `data`, and `ref`/selector targeting but adds no meaning beyond the schema; the schema itself documents the payload formats. No deduction needed.

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

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

The description names a specific action (`Drop`), the two accepted payload kinds (`paths` for files, `data` for MIME data), and how to target an element (`ref` or selector). This is sufficiently distinct from sibling actions like `browser_click`, `browser_type`, and `browser_drag`.

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

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

It clearly conveys the intended use case — dropping local files or in-memory MIME data onto a page element — and how to address the target. It does not explicitly name alternative tools or exclusion cases, but the context is specific enough to guide selection.

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 that a function is evaluated and JSON is returned, but does not mention that the function can modify the page, require permissions, or have side effects. It also omits any note about the safety implications of running arbitrary code, which is critical for a tool that executes JavaScript.

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-structured sentence that states the core action, the optional scope (page vs element), and the return format. No wasted words, and the key information is front-loaded.

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

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

For a tool that executes arbitrary JavaScript, the description is incomplete. It lacks safety warnings, an explanation of what constitutes a valid function or how results are serialized, and any mention of when to use this instead of browser_run_code_unsafe. The absence of an output schema and annotations increases the need for more thorough documentation.

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

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

The schema provides 100% coverage with descriptions for all three parameters, including examples for the function parameter. The description adds the context that the function runs against the page or a target element (ref or selector), which clarifies the 'target' parameter. This is helpful but not essential beyond what the schema already implies.

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 evaluates a JavaScript function on the page or a specific element and returns a JSON result. It uses a specific verb ('evaluate') and resource ('page or element'), and the return type is clear. While it doesn't explicitly contrast with the sibling browser_run_code_unsafe, the name and description already differentiate it from click/type/hover 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 guidance on when to use this tool versus alternatives, particularly browser_run_code_unsafe, which also executes JavaScript. The description does not mention when to prefer this over other browser tools, nor does it note any limitations or prerequisites (e.g., page load state).

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It states the mechanism (setting files on an input) but does not mention side effects such as triggering change events, requiring permission, or handling validation. For a mutation tool, this is incomplete.

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, efficient sentence that front-loads the core purpose ('Upload one or more files') and then clarifies the target identification. There is no wasted wording.

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 3 parameters and no output schema, the description covers the essential action, target specification, and default behavior. It does not explain return values or error handling, but these are likely not critical for this tool type. Overall it is reasonably 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 parameters are already documented. The description adds the default behavior for the target parameter (defaults to first file input), which is helpful, but it does not add substantial meaning beyond the schema – baseline 3 is appropriate.

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

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

The description clearly states the action (upload files), the target (file input), and the identification method (ref or selector). It is specific enough to distinguish from siblings like browser_click or browser_fill_form, which serve different purposes.

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 when uploading files via a file input, but it does not explicitly state when to use this tool versus alternatives, nor does it mention when not to use it (e.g., for other input types). The default behavior is noted, but there is no explicit routing guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose a key behavior beyond the schema: the tool returns one snapshot after filling. However, it does not mention side effects, permissions, page changes, or whether field filling can trigger navigation or dialogs, so the behavior is only partially 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 a single, front-loaded sentence that communicates the action, scope, field types, batching behavior, and result with no filler. 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?

The schema is rich and fully documents the nested fields, while the description covers the core invocation context and explicitly states the return behavior (one snapshot). The main gap is the lack of explicit sibling guidance and annotation-style safety/behavior notes, but the essential operational information is present.

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

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

The schema describes all parameters and their value semantics in detail, including type-specific behavior for checkbox, radio, combobox, and slider. The description adds no parameter-level value beyond restating the supported field kinds, so the baseline of 3 applies given 100% schema coverage.

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

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

The description states a specific action ('Fill multiple form fields'), lists the supported field kinds, and mentions the single-call behavior with one snapshot returned. It is clearly differentiated from sibling tools like browser_type and browser_select_option by the 'multiple' and 'single call' phrasing, though it does not explicitly name those alternatives.

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 when to use the tool: when multiple form fields need to be filled together in one call. It does not explicitly say when NOT to use it or when to prefer siblings like browser_type or browser_select_option, leaving the routing decision mostly implicit.

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

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

It clearly discloses that the operation is a read-only search over the current page snapshot and that it returns refs for matches. It does not address edge cases like no snapshot or both parameters being supplied, but the core behavior is visible despite having no annotations.

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

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

The description is a single front-loaded sentence with no filler. Every phrase contributes information about the search target, match criteria, or return value.

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?

Basic invocation is clear: provide text or regexp and receive refs. However, with no required parameters stated and no guidance on what happens if both or neither are provided, an agent could make an ambiguous call.

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 parameter descriptions already explain the text and regexp arguments. The description adds only that they are alternative match modes; it does not clarify exclusivity, precedence, or whether at least one is 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?

The description names a specific action ('Search'), a resource ('current page snapshot'), and a result ('returning each match's ref'), and scopes the search to controls' name/value/role. This clearly distinguishes it from siblings like browser_snapshot and browser_evaluate.

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 use when locating controls in the current snapshot by text or regexp, but it never states when not to use it or points to an alternative. It also omits prerequisites such as ensuring a snapshot 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. It clearly discloses that this is a one-shot registration for the NEXT dialog and explains the two modes (accept/dismiss) with optional prompt text. It does not cover edge cases like multiple dialogs or no dialog appearing, but the core behavior is explicit and unambiguous.

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

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

Two sentences with no wasted words. The core action is front-loaded, and the usage instruction is placed immediately after, making the description easy to parse and act on.

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 no output schema, the description plus the exhaustive schema cover the essential context: what it does and when to call it. Minor edge cases are not addressed, but they are not critical for correct invocation.

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

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

Schema description coverage is 100% and both parameters are already well-documented. The description only paraphrases accept and promptText without adding extra semantic value 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 states a specific verb ('Register') and resource (JavaScript dialog handling), enumerates the dialog types (alert/confirm/prompt/beforeunload), and clearly distinguishes this from all sibling browser tools, none of which target dialog handling.

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

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

It gives an explicit timing instruction: 'Call this before the action that triggers the dialog.' This clarifies when to use the tool. It does not name alternatives, but no sibling tool serves the same purpose, so the guidance is sufficient.

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 does not mention any side effects (e.g., tooltips), visibility requirements, permission implications (despite the schema hint about the 'element' parameter being used for permission), or potential failure modes. The description is purely functional without behavioral 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, direct sentence with no superfluous words. It front-loads the core action ('Hover over an element') and immediately follows with identification details, achieving maximum conciseness without sacrificing clarity.

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 simplicity and the complete schema, the description is adequate for executing the action, but it lacks usage context (when to prefer this over alternatives) and behavioral caveats. It also does not explain the purpose of the 'element' parameter (for permission), leaving some guidance to the schema alone.

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

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

The schema already fully describes both parameters (100% coverage), including the exact meaning of 'target' and 'element'. The description adds no new semantic value beyond restating the identification methods, so it meets the baseline for high schema coverage but does not enrich understanding.

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 the verb 'hover' and the resource 'element' precisely, and specifies the two identification methods (snapshot ref or Playwright selector). This clearly distinguishes it from sibling interaction tools like browser_click or browser_drag.

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 the many browser_* alternatives (e.g., browser_click, browser_type). The only hint is the verb 'hover' itself, which implies the intended interaction but provides no explicit 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 provided, the description carries the full behavioral burden. It discloses that the tool returns a snapshot, but says nothing about page-load waiting, redirect/error handling, tab behavior, or that this mutates browser state.

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 14-word sentence that front-loads the primary action and follows with the return value. 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 single-parameter tool this is minimally viable: an agent knows to pass a URL and expect a snapshot. However, with no output schema and no annotations, the meaning of 'snapshot' is undefined and edge behaviors are undisclosed.

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 only parameter, url, is already documented as 'The URL to navigate to.' The tool description merely restates this purpose without adding format details such as required protocol or full vs relative URL handling.

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 ('navigate'), resource (the browser), and target (a URL), and adds the return behavior (snapshot of the resulting page). It reads clearly and is implicitly distinguishable from siblings like browser_navigate_back and browser_snapshot, though it never names them.

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

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

The description gives no when-to-use guidance or alternative routing. With 24 sibling tools including browser_snapshot (snapshot without navigation) and browser_navigate_back (reverse navigation), an agent gets no help deciding between them.

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 the key behavior of returning a snapshot after navigating, but does not mention potential errors (e.g., no previous page) or side effects on the current page state. The disclosed information is minimal but covers the primary outcome.

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 that states the action and its result with no wasted words. It is optimally concise for a zero-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 simple navigation-back tool with no parameters and no output schema, the description adequately states what it does and what it returns. It lacks edge-case details, but these are not critical for a basic action. The description is complete enough for an agent to invoke 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?

The tool has zero parameters, and the schema is empty, so the description adds no parameter-specific meaning. Per the baseline for 0-parameter tools, a score of 4 is appropriate because there is nothing to explain beyond what the schema already 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 the action ('Navigate back') and the specific resource ('the previous page'), and adds the output ('return a snapshot'). It is distinct from siblings like browser_navigate (which goes to a URL) and browser_tabs (which manages tabs), 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?

No explicit when-to-use or alternative guidance is provided. The usage is implied by the name and description: to go back in history. This is adequate for a simple action, but there is no comparison to other navigation tools or mention of when not to use it (e.g., if at the first page).

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It does disclose the return payload (method, URL, resource type, status, headers) and that it operates on captured requests (implying a non-destructive read). However, it omits behavior when both `index` and `url` are provided, or when neither is provided (since both are optional in the schema). It also does not state what happens if no matching request is found. These are meaningful gaps in a tool with no safety annotations.

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

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

A single, well-structured sentence that front-loads the action and return fields, then states the selection mechanism. Every word contributes value; there is no redundancy or filler. The description is appropriately sized for the tool's complexity.

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 has two optional parameters, no output schema, and no annotations, the description should clarify how parameters interact and what happens in edge cases. It explains what is returned and how to select a request, but leaves a key ambiguity: if both `index` and `url` are provided, which takes precedence? Also, it does not specify behavior when no selector is given (though both optional). These omissions make it incomplete for an agent that needs to call it reliably, though the core functionality is clear.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly: `url` selects the most recent request containing the substring, and `index` is a 0-based index from browser_network_requests. The description adds only the phrase 'selected by index or by url substring', which restates the schema without new meaning. Since the schema handles parameter semantics, a baseline score of 3 is appropriate, with no additional value added by the description.

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

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

The description opens with a specific verb ('Return') and a clear resource ('full detail of one captured network request'), enumerating the exact fields returned (method, URL, resource type, status, headers). It also specifies the two selection mechanisms (index or url substring), distinguishing it from the sibling browser_network_requests which lists all requests. No ambiguity about what this tool does.

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

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

The description implies usage: you need details of a single request rather than a list. It names selection by index (which comes from browser_network_requests) or url substring, so an agent understands when to call it. However, it does not explicitly state 'use this instead of browser_network_requests' or mention any alternatives or when not to use it, leaving the differentiation implicit rather than explicit.

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

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

No annotations are present, so the description carries the behavioral burden itself. It discloses that this is a read-only listing operation, scoped to the session, and exactly what each output line contains. It does not discuss the empty-list case, but that is a minor gap for such a simple 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?

One sentence, front-loaded with the action verb, and every clause earns its place by specifying the resource, the temporal scope, and the exact output format. There is no filler or repetition.

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

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

For a zero-parameter, no-output-schema read-only listing, the description covers the essential invocation details: what is listed, from what period, and in what format. It leaves the agent to infer the relationship to browser_network_request, but that is not necessary to call the tool 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?

The input schema has zero parameters, so there is no parameter behavior for the description to clarify. Per the rubric, this is a baseline 4 because the description is not expected to document nonexistent parameters.

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 the exact verb 'List' and the resource 'network requests captured since the session started', then defines the output as one line per request with index, method, status, and URL. This clearly differentiates it from the sibling browser_network_request by emphasizing the plural, session-scoped listing.

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 temporal scope 'since the session started' implies when the data is availableients the agent some context for use. However, it does not explicitly name alternatives or state when to prefer browser_network_request (singular) for detailed request inspection.

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 without revealing side effects (e.g., whether it triggers keyboard events, requires page focus, or works on any element). The agent gets no information about prerequisites or outcomes.

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 with no filler, front-loading the core action. It is appropriately sized for the tool's simplicity.

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 parameter and no output schema, the description is minimally adequate, but it lacks usage context and behavioral transparency. It does not tell the agent when to prefer this over browser_type, nor does it disclose any side effects, leaving gaps in decision-making.

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 fully describes the 'key' parameter with examples, so the description adds no additional meaning beyond what the schema already provides. Baseline score of 3 is appropriate since schema coverage is 100%.

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

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

The description states a specific verb ('press') and resource ('keyboard key') on the current page, and explicitly mentions combinations like 'Control+A', making it distinct from siblings such as browser_click and browser_type. It clearly conveys 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?

No explicit guidance on when to use this tool versus alternatives like browser_type. The implication is that it is for key presses rather than typing text, but there is no mention of exclusions or when it should not be used (e.g., for text input or dialog handling).

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 does state the core behavior and that a snapshot is returned, but it does not mention side effects, whether the resize persists, or what the snapshot contains. 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?

A single sentence with no filler. The primary action is front-loaded, and the return behavior is included efficiently. 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 tool with two fully documented parameters and no output schema, the description is mostly complete: it states the action and that a snapshot is returned. It could clarify what 'snapshot' means, but this is a minor gap 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?

Schema description coverage is 100%, so the schema already documents width and height as pixel values. The description only refers to them as 'given width and height' and adds no additional semantic 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 states a specific verb ('Resize'), a clear resource ('browser viewport'), and the exact inputs ('given width and height'). It also adds a secondary behavior ('return a snapshot'), which distinguishes it from other browser tools that do not resize the viewport.

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 about when to use this tool versus alternatives such as browser_snapshot or browser_take_screenshot. The description explains what it does but not the conditions under which an agent should choose it 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 full responsibility for behavioral disclosure. It reveals that the tool executes arbitrary async code with `page` in scope, targets the active page, returns JSON, is dangerous, and requires an environment variable. It stops short of detailing failure modes or side effects beyond the generic danger warning.

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 fluff, front-loading the critical 'DANGEROUS' warning before the technical details. Each clause conveys essential information: danger, execution model, target, return type, and activation requirement.

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 single-parameter code execution tool with no output schema, the description covers the execution environment, the active-page scope, the JSON result, and the required environment flag. It omits explicit error-handling or serialization caveats, but these are not essential given the simple signature and the strong overall context provided.

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 fully describes the `code` parameter with a clear example and notes the async function body and `page` scope. The description adds little beyond repeating that same execution model, so it does not meaningfully supplement the schema. Baseline 3 is appropriate since coverage is 100%.

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

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

The description clearly states that the tool runs a raw Playwright JavaScript snippet against the active page and returns its JSON result. It gives a specific verb ('run') and resource ('active page'), but it does not explicitly differentiate this from the sibling browser_evaluate tool. This is clear but lacks explicit sibling differentiation.

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

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

The description provides context through the 'DANGEROUS' warning and the operational gate 'Disabled unless LAYA_ALLOW_UNSAFE_CODE=true.' However, it does not explicitly state when to use this tool instead of safer alternatives like browser_evaluate, nor does it give exclusion criteria. The usage context is implied but not fully directive.

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 identifies how to target the element but does not disclose behavioral traits such as side effects (e.g., firing change events), prerequisites (e.g., dropdown must be open or visible), or permission requirements. For a mutation operation, this is a significant gap, potentially leading the agent to attempt selection without ensuring the dropdown is interactable.

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, well-structured sentence that front-loads the core action and includes the targeting method. No filler or redundancy; every word contributes to functional clarity.

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 parameters well, but the description omits behavioral context like side effects, required interaction state, or error handling. With no output schema or annotations, an agent might not know if the selection triggers navigation or requires permission. While not catastrophic, it leaves gaps in scenarios where dropdown interaction has prerequisites.

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 restates the schema's target info ('snapshot ref (eN) or selector') and adds 'one or more options' for values, but this adds marginal new meaning beyond what the schema already specifies. It does not introduce format details or examples, so it meets the baseline without exceeding it.

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

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

The description clearly states a specific verb ('select') and resource ('options in a dropdown') and specifies the two identification methods (snapshot ref or selector). This distinguishes it from sibling tools like browser_click (clicking an element) and browser_fill_form (filling forms), making the 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?

The description implies when to use it: when selecting options in a dropdown, including multi-select for multiple values. It provides clear context but does not explicitly mention alternatives or exclusion criteria. Sibling names are present, but no direct comparison is made. This is adequate but could be improved with a note on when browser_fill_form might be preferred.

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 the output is a 'compact' snapshot (not full DOM), that refs are 'stable' (persist across interactions), and that it provides the targets for other tools. It implies a non-destructive read operation. It does not mention errors or performance, but for a simple snapshot tool this is adequate.

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

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

Two sentences with zero redundancy. The core action is front-loaded, and the second sentence delivers the key detail about ref markers that drives usage. 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?

The tool has no output schema, so the description must convey the return value. It states it returns a compact accessibility snapshot with stable ref markers, which is sufficient for an agent to know how to consume it and pass refs to other tools. It omits a precise structure, but given the tool's simplicity, this is a minor 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 tool has zero parameters, so schema coverage is trivially 100%. Per the rubric, a baseline of 4 is appropriate because there is nothing to clarify about parameters. The description does not need to add parameter meaning.

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

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

The description states a specific action ('Capture'), a clear resource ('compact accessibility snapshot of the current page'), and uniquely identifies its output (ref markers) that serve as targets for sibling tools. This distinguishes it from browser_take_screenshot (visual) and browser_console_messages (logs), making the 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?

While it does not explicitly name alternative tools, the sentence 'Interactive elements carry stable [ref=eN] markers used as targets for other tools' implies the workflow: capture a snapshot first to obtain refs, then use those refs with tools like browser_click or browser_type. This is strong implicit guidance, though it lacks an explicit 'when not to use' or a direct comparison to 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 behavioral disclosure burden. It does state the direct effects of each operation ('create', 'close', 'select'), but it omits important behavioral detail such as return values for 'list', what happens if the active tab is closed, or how selection affects the active tab. 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 a single, tightly packed sentence with a clear noun phrase ('Manage browser tabs') followed by a colon-delimited list of operations. There is no fluff or redundant restatement; 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?

The tool is simple, but with no output schema and no annotations, the description should ideally mention what 'list' returns and note that 'index' is effectively required for 'close' and 'select' despite not being in the schema's required list. The current text is minimally viable but leaves these operational details implicit.

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 'optionally at a URL' for create, but this mirrors the schema. It does not add new semantic information beyond describing the operations that use 'index' and 'url'.

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 resource ('browser tabs') and specific operations ('list', 'create', 'close', 'select'), each with concrete behavior. This separates it from sibling tools like browser_navigate and browser_close, which target page navigation or the browser 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?

The opening 'Manage browser tabs' plus the enumerated operations clearly signal when to use this tool: whenever a tab-level action is needed. It does not explicitly name alternatives or exclusions, but the context is unambiguous and provides enough guidance for an agent to route tab operations here.

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 most of the behavioral disclosure burden. It does disclose the output format ('PNG, JPEG, or WebP image content block') and page/element scope, but it does not mention side effects, permissions, or limitations beyond what the schema already states.

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. It communicates the action, target scope, and output format efficiently 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?

With all parameters documented in the schema and the output type stated in the description, an agent has enough to invoke this tool correctly. The main gap is routing guidance versus browser_snapshot, but that is a usage concern rather than a missing calling 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 the parameters are already fully documented. The description adds no new parameter-level meaning beyond framing the tool, which matches the baseline for high schema coverage.

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

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

The description uses a specific verb ('Capture') and clear resource ('the page or a single element'), with output formats spelled out. It is clear and actionable, but it does not explicitly differentiate from sibling tools like browser_snapshot, so it stops 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 states only what the tool does ('Capture a screenshot...') and gives no guidance on when to prefer it over alternatives such as browser_snapshot. There are no exclusions, prerequisites, or when-not-to-use signals.

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 typing replaces existing content, whether the element is auto-focused, what happens on non-editable elements, or how the 'slowly' and 'submit' options affect 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?

The description is a single, front-loaded sentence with no filler. It efficiently communicates the core action and target specification.

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 lack of annotations and output schema, the description is too sparse to be fully actionable. It omits side effects, prerequisites, and return behavior, which an agent would need to invoke the tool correctly in a browser automation context.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no extra meaning beyond what the schema provides, such as clarifying the 'element' parameter's role in permission handling.

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 ('Type') and resource ('editable element'), and clarifies the target format ('snapshot ref (eN) or selector'). This clearly distinguishes it from siblings like browser_click, browser_press_key, and browser_fill_form.

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 browser_fill_form or browser_press_key. The description only states what it does, leaving the agent to infer the appropriate 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It states the core wait behavior and the three termination conditions, but it does not disclose timeout behavior, what happens on failure, whether the options are mutually exclusive, or what a no-argument call does.

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, tightly packed sentence with no filler or repetition. The main behavior is front-loaded and every clause adds useful information about a distinct wait mode.

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 low-complexity and the primary behavior is described, but important contextual details are missing: timeout/error behavior, interaction between the optional parameters, and the effect of calling with no arguments. Since there are no annotations or output schema, these gaps are meaningful for an agent deciding how to call the tool.

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

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

The input schema already fully describes all three parameters with 100% coverage, so the description adds no new parameter-level detail. It merely rephrases the schema's semantics in natural language, which keeps it at the baseline for well-covered schemas.

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

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

The description clearly identifies the operation: waiting on the browser page state. It enumerates the three supported conditions (text appears, text disappears, or a fixed delay), making the tool's purpose unambiguous and distinct from the sibling browser tools, none of which are wait operations.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions. However, the three modes imply the usage context: wait for text with text, wait for text removal with textGone, and wait for a fixed duration with time.

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 return payload (transcript, snapshot, verification) and the fallback behavior, which is helpful. However, it does not reveal whether the tool may perform mutating actions on the page, any safety considerations, or how the decision engine behaves. The disclosure is partial.

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

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

Three sentences with zero waste. The purpose is front-loaded, the return items are listed succinctly, and the fallback is mentioned briefly. Every sentence earns its place.

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

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

This is a complex tool (autopilot with a decision engine) with no annotations and no output schema. The description is sparse: it does not explain what the Laya engine is, what kinds of goals are appropriate, any performance expectations, or how the agent should interpret the verification result. Given the complexity, the description is under-specified.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds minimal extra meaning—only the mention of 'current (or given) page' for the url parameter. It does not enrich the goal or maxSteps parameters beyond what the schema provides. 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 ('pursue') and a clear resource ('a natural-language goal on the current (or given) page'), and distinguishes itself from the low-level browser_* siblings by framing it as an autopilot that delegates to the Laya decision engine. This clearly separates it from the granular operations.

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

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

The description implies usage for natural-language goals and mentions the fallback to Assist-mode tools when weights are absent, but it does not explicitly state when to use this versus the low-level browser tools or when not to use it. The guidance is implied rather than explicit.

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