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

No annotations are provided, so the description carries the full burden. It does not disclose behavioral traits such as whether the element is scrolled into view, what happens if the element is not found, or whether the action triggers navigation or events. This leaves the agent guessing.

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 is concise and easy to scan, though it could be slightly more detailed without becoming verbose.

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 annotations and no output schema, the description should still clarify how it differs from the sibling 'tap' tool and what happens on failure or when the element is not clickable. These gaps make it less than complete for an agent.

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

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

The description adds meaning for 'by' by listing allowed values (css, xpath, text), which the schema does not constrain with enums. However, it does not explain 'selector' beyond its name, and with 0% schema coverage, more detail would be expected to fully compensate.

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/tap an element' with a specific verb and resource. It provides some additional detail about the 'by' parameter but does not distinguish this tool from the sibling 'tap' tool, which appears to be a near-synonym.

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 vs. alternatives like 'tap' or 'type_text'. The description only mentions the parameter format, not the appropriate 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?

No annotations are provided, so the description must fully disclose behavior. It clearly states the core effect (ends the session) and the key behavioral trait (automatic reconnection on a later call), which reassures agents that the action is not permanently destructive. It could mention whether session-scoped data (e.g., console captures, network timings) is reset, but for a simple close operation this coverage 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 short sentences, each earning its place. The first states the primary action; the second adds a critical behavioral fact (reconnection). 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?

The tool is simple: no parameters, an existing output schema (so return values need not be described), and the description covers the only two relevant facts (what it does and the reconnection behavior). It is fully complete for its scope.

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 input schema is empty (100% schema coverage is trivially satisfied). The description correctly provides no parameter details. Baseline for zero parameters is 4, as there is nothing to explain.

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 ('End') and identifies the resource ('automation session on the phone'), clearly distinguishing it from siblings like session_info (which reports info). The action is unambiguous.

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

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

The statement 'A later call reconnects automatically' implies this is a non-destructive, reversible action and positions it as safe to invoke before subsequent operations. However, it does not explicitly state when to use it versus alternatives, when not to use it, or whether to close the session at the end of a task.

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 behavioral disclosure. It explains the lifecycle of the capture hook and the self-navigation edge case, which is useful. However, it does not disclose whether clearing occurs, potential side effects, or the exact format of the returned logs.

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 concise sentences. The first states the tool's purpose, and the second adds essential lifecycle context. 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 tool with no output schema, the description covers the core function and a key edge case. However, it omits the meaning of the 'clear' parameter and does not explicitly state the return format, leaving some context incomplete.

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 has one param (clear) with 0% description coverage, and the description does not mention this parameter at all. The agent is left to infer what 'clear' does, which is a significant gap given the low 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 clearly states the tool returns console messages and uncaught errors captured since the last navigation. It distinguishes itself from sibling tools like network_timings and install_console_capture by specifying its output scope.

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

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

It explains when the capture is active (after navigate()) and instructs to call install_console_capture() to re-arm if the page navigated itself. This provides clear context for when to use this tool and how to prepare for it, though it does not explicitly list cases where an alternative should be used.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It usefully reveals that the result is converted to a string and that `return` is required to capture a value, but it omits potential side effects of executing arbitrary code, error handling behavior, or implications for the page state. This is a notable gap given the tool allows arbitrary script execution.

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 extremely concise, consisting of two short sentences. The first sentence states the tool's purpose, and the second provides a necessary usage tip. There is no wasted wording or redundant information, making it highly efficient.

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

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

Given that this is a simple tool with one parameter and an output schema, the description adequately covers the core functionality. It explains what the tool does, how to use the parameter, and the return type. Minor missing details include side effects and error handling, but the description is sufficient for a basic understanding and 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?

The schema provides only the parameter name 'code' with no description, so the description must add meaning. It does so effectively by explaining how to use the `code` parameter: wrap the desired expression in `return ...` to get a value back, with a concrete example. This goes beyond the schema, though it could further clarify error cases or that the code executes in the page context.

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 JavaScript in the page and return the result as a string.' This uses a specific verb ('Run') with a clear resource ('JavaScript in the page') and outcome ('return the result as a string'). It distinguishes this tool from siblings like click, type_text, and screenshot, which perform entirely different actions.

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

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

The description provides clear context for use, stating that the tool evaluates JavaScript and returns a string. It also gives an explicit usage pattern ('Wrap in `return ...` to get a value back, e.g. `return document.title;`'), which guides the user on how to invoke it correctly. However, it does not explicitly state when not to use it or name alternative tools, though the sibling list makes the tool's unique role fairly obvious.

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 explains the fundamental behavior (navigate back) but does not mention edge cases (e.g., behavior when history is empty) or side effects (e.g., whether it waits for page load). This is adequate but not enriched.

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 immediately conveys the tool's purpose with no redundant information. It is front-loaded and efficient.

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

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

Given the tool's simplicity (zero parameters, no output schema, single action), the description is largely complete. It could mention failure modes or exact outcome, but for a straightforward browser navigation action, the description provides sufficient context for an AI agent.

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

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

The tool has zero parameters, so the input schema is trivially fully covered. The baseline for 0 params is 4; the description adds no parameter details because none exist, but no additional information 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 clearly states the action ('Navigate back') and the resource ('Safari's history'), distinguishing it from sibling tools like 'navigate' (general navigation) and 'reload_page' (refresh). It is specific and 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 clear context for when to use this tool: when the agent needs to move backward in Safari's browsing history. It does not explicitly mention alternatives or exclusions, but the use case is self-evident given 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 present, so the description must carry the burden of behavioral disclosure. It mentions '(Re)install' implying idempotency, but does not describe side effects such as clearing existing logs, changing page behavior, or what the returned output represents. The mutation impact is largely 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?

The description is a single, front-loaded sentence that directly states the tool's purpose without waste. 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?

The tool is simple (0 params, output schema exists), so the description does not need to explain return values. However, it lacks context about prerequisites (e.g., whether the hook must be installed before using console_logs) and does not clarify the effects of reinstallation. Adequate but with clear gaps.

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

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

The tool has zero parameters, so there is nothing for the description to explain about parameters. According to the rubric, 0 parameters gets a baseline of 4. The description does not need to add parameter details.

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 ('install') and the resource ('console/error capture hook') with a scope ('current page'). It is specific and distinguishes itself from siblings like console_logs, which retrieves logs rather than installing the capture mechanism.

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 indication of when to use this tool versus alternatives. It does not mention that it might be a prerequisite for console_logs or that it should be called before capturing console output. No exclusions or alternative tool references are provided.

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

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

With no annotations, the description carries full burden. It adds the useful detail that it waits for page load, and specifies the environment. However, it omits failure handling, timeouts, or side effects, which would be expected for a navigation 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 a single, efficient sentence that immediately states the action and result. 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?

The tool is simple with one parameter and no output schema. The description covers the core behavior but does not mention return values, error conditions, or what happens if the load fails. For a navigation tool with a waiting behavior, this is a noticeable 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 has zero description coverage for the 'url' parameter, and the tool description simply says 'Open a URL' without elaborating on required format, scheme, or other constraints. It adds little beyond the schema's parameter name.

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 (open URL), the target environment (Safari on iPhone), and an additional behavior (wait for load). This distinguishes it from sibling tools like click, tap, and reload_page.

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

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

While no explicit alternatives or exclusions are named, the description clearly implies this is the tool for loading a new URL. The context of sibling tools (reload_page, go_back) makes the use case apparent without further 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 adds a useful behavioral note that zero transferSize on a non-cached entry usually indicates a failed request, but it does not disclose other details such as read-only status, output format, or how max_entries affects results.

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 extremely concise, with the primary purpose in the first sentence and a valuable troubleshooting tip in the second. Every sentence adds value and there is no redundancy.

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

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

The tool has one optional parameter and no output schema, so the description needs to explain what the tool returns and how parameters work. It provides the data source and a behavioral hint but leaves the max_entries parameter unexplained and does not describe the result structure in enough detail for an agent to know what to expect.

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 description does not mention the max_entries parameter at all. Since schema description coverage is 0%, the description must compensate but fails to explain the parameter's meaning or default behavior.

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

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

The description clearly identifies the tool as returning resource timings from the Performance API, listing the fields (URL, type, duration, transfer size). This distinguishes it from sibling tools like console_logs or page_source, 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?

No guidance is provided on when to use this tool versus alternatives. The description neither states specific use cases nor mentions sibling tools, leaving the agent to infer from the name.

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

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

The description discloses the truncation behavior tied to max_chars, which is a useful behavioral detail. However, it does not clarify whether the HTML is the live rendered DOM or the original source, nor does it mention potential performance implications. With no annotations, it only partially covers the behavioral burden.

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

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

A single sentence that is front-loaded with the core purpose and includes the key qualifier about truncation. Every word earns its place, and there is no unnecessary padding.

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

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

For a simple tool with one parameter and an output schema, the description is sufficient to convey the essential behavior. It lacks guidance on alternatives, but the tool is basic enough that the description covers most of what is needed. More detail about the return value or caveats could improve it, but the output schema likely covers the return type.

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 description directly explains the max_chars parameter as a truncation limit, which is meaningful given the schema has no per-parameter description. This compensates well for the 0% schema description coverage, though it does not specify the exact counting unit (e.g., characters).

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 the raw HTML of the current page and mentions the truncation behavior, making it unambiguous. It distinguishes from siblings like screenshot or snapshot by specifying 'raw HTML', which is precise.

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

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

There is no guidance on when to use this tool versus alternatives such as snapshot or evaluate_javascript. It only states what it does, not when to prefer it, leaving the agent to infer usage from the purpose.

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

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

No annotations are provided, so the description carries the burden. It discloses the key side effect of re-arming console capture, which adds value beyond the tool's name. However, it does not mention potential loss of page state or whether the reload waits for the page to load, leaving some behavioral ambiguity.

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 ('Reload the current page') and adds a secondary behavior ('re-arm console capture') without any waste. 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 no parameters, no output schema, and no annotations, the description is adequately complete. It states the primary action and the console capture behavior, covering essential context. A more detailed warning about page state loss would improve it, but it is not essential for a competent agent.

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

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

The tool has zero parameters, and the schema coverage is trivially 100%. The description does not need to explain parameters, and the baseline for zero-parameter tools is 4, which is appropriate here.

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: 'Reload the current page' uses a specific verb and resource, and the additional 're-arm console capture' distinguishes it from other navigation tools like go_back or navigate. It is unambiguous and immediately understandable.

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 the tool is used when the current page needs to be refreshed, but it does not explicitly state when to use it over alternatives like go_back or navigate, nor does it mention any exclusions. The usage context is clear but not elaborated.

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 action without disclosing output format, file saving behavior, or whether it captures the full viewport or only the visible area. This is minimal behavioral information.

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 sentence with no extraneous words, making it highly concise. However, it is also under-specified, so while structure is clean, the content is exceptionally brief.

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, output schema, and parameter explanation, the description is insufficient. An agent cannot predict what the tool returns (e.g., an image path, base64 string) or how to interpret the result.

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

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

The single parameter max_width is not mentioned in the description, and schema coverage is 0%. The agent cannot infer what max_width controls (e.g., resizing the screenshot) or how the default is applied.

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 'Screenshot' and names the resource 'current iPhone Safari viewport', clearly distinguishing it from sibling tools like navigation and text entry. It is unambiguous and concise.

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 screenshot versus alternatives like snapshot or page_source. The description lacks any context on scenarios where this tool is preferred, leaving the agent without decision criteria.

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 positive dy scrolls down, but does not mention the horizontal dx behavior or any side effects. This is basic but not rich behavioral 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 with no filler. It is appropriately concise and front-loads the core action.

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 description covers the core behavior, but it lacks explicit mention of dx direction, default behavior, or return value. Given the simple nature and schema defaults, it is minimally complete but has noticeable 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 schema has 0% description coverage, so the description must explain both parameters. It only explains the meaning of dy (vertical direction), leaving dx's horizontal semantics implied but not stated. This is insufficient for full parameter 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 clearly states the action (scroll) and the resource (the page), and specifies the mechanism (pixel delta). It is distinct from all sibling tools, none of which perform scrolling.

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 (whenever scrolling is needed), but it does not explicitly mention alternatives or exclusions. Given there is no sibling scroll tool, the usage is clear enough, but it lacks explicit 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 burden of disclosing behavior. It reveals that the session might be attached to different devices ('real iPhone' vs 'Mac Safari') and frames the tool as a verification step, implying read-only behavior via the verb 'report.' It adds useful context about session 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?

The description is two sentences: the first states the primary action, the second gives usage guidance. It is front-loaded, direct, and contains no redundant information.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description covers purpose and usage scenario adequately. It does not detail the exact return format, but for a session-info tool, 'report what device/browser' is sufficiently clear for the agent to understand what to expect.

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, which sets a baseline of 4. There is no need to describe parameter semantics beyond what the empty schema already conveys, and the description appropriately focuses on the tool's purpose.

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: 'Report what device/browser this session is actually attached to.' It uses a specific verb ('report') and resource ('device/browser'), and distinguishes itself from sibling action-oriented tools like navigate, click, and screenshot.

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 explicit when-to-use guidance: 'Use this first to confirm you are driving the real iPhone and not Mac Safari.' It identifies a concrete scenario and priority, but does not explicitly state when not to use the tool 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?

No annotations are provided, so the description carries the full transparency burden. It discloses that the output is a structured, compact view and only includes visible interactive elements, which is useful behavioral info. However, it does not explicitly state that the tool is read-only, nor mention potential caveats like handling of iframes, dynamic content, or page load states, leaving some behavioral gaps.

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

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

The description is two sentences, front-loaded with the tool's purpose and contents, and the second sentence adds clear usage guidance. No fluff or redundancy.

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

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

With no output schema and 0 parameters, the description carries the burden of explaining return values. It lists the main content (URL, viewport, scroll position, interactive elements) and the usage context. It stops short of detailing exact data structure or edge cases, but for a simple 0-parameter tool this is quite 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 tool has 0 parameters and an empty schema, so the baseline is 4 per the rubric. The description adds no parameter info because none is needed; nothing is left undocumented.

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 what the tool does: it returns a compact structured view of the page including URL, viewport, scroll position, and visible interactive elements with selectors and rects. It also distinguishes itself from page_source by explicitly recommending snapshot for click decisions, making its purpose unambiguous and distinct from 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 explicitly says 'Prefer this over page_source()' and explains it is 'the cheap way to decide what to click.' This provides a clear when-to-use directive and names the alternative tool, giving strong usage 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 transparency burden. It discloses that the touch is 'real' (not synthetic) and that coordinates are in CSS pixels relative to the viewport. However, it does not mention potential side effects, failure modes (e.g., out-of-bounds coordinates), or whether the touch triggers standard events, leaving some behavioral ambiguity.

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 exceptionally concise: two sentences, front-loaded with the primary action and followed by a single usage guideline. Every word serves a purpose, with no redundant information or repetition of schema details.

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 or annotations, the description covers the essential context: what the tool does, the coordinate system, and when to use it. It omits nothing critical for an AI agent to select and invoke the tool correctly, though a note on coordinate bounds or error handling would make it 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 input schema lists only x and y as required integers with no descriptions (0% schema coverage). The description compensates by specifying 'viewport coordinates (CSS pixels)', which clarifies the coordinate system and units for both parameters. This adds meaning beyond the bare schema, though it could define the origin (e.g., top-left) more explicitly.

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: 'Send a real single-finger touch at viewport coordinates (CSS pixels).' It uses a specific verb ('send') and resource ('touch at viewport coordinates'), which distinguishes it from sibling tools like 'click' that rely on selectors.

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

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

The second sentence explicitly advises when to use the tool: 'Use when there is no sensible selector — e.g. a canvas or a custom overlay.' This provides a clear usage context and implicitly contrasts with selector-based alternatives like 'click', though it does not name the alternative tool directly.

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 disclosing side effects. It mentions clearing and submitting, which are key behavioral traits. However, it omits details such as default clearing behavior (clear defaults to true), whether the element is focused first, or what happens if the input is not found, leaving gaps in 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 a single, 15-word sentence that is concise and front-loaded with the core action. Every word contributes value 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?

The tool has 5 parameters, no annotations, and no output schema. The description covers the main action and two options but omits important context such as how selectors are specified, the meaning of the 'by' parameter, and what the tool returns after execution. It is adequate for a simple tool but leaves several gaps that an agent would need to infer.

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 0%, so the description must compensate for parameter clarity. It addresses 'clear' and 'submit' by mentioning them explicitly, but it does not explain 'by' (selector type) or 'selector' beyond their names, nor does it clarify the relationship between these parameters. The cryptic 'by' parameter is left entirely unexplained.

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 with a specific verb ('Type') and resource ('an input on the phone'), and mentions two optional behaviors (clearing and submitting). This distinguishes it from sibling tools like click, tap, and scroll, which perform different actions.

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

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

The description implies when to use the tool (typing into inputs) but provides no explicit guidance on when to choose it over alternatives or any exclusions. It does not mention situations where other tools like evaluate_javascript might be more appropriate, so usage context is only implied.

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