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

With no annotations, the description carries the full burden. It discloses that it compares against the last cached snapshot, returns added/removed/text-changed element lists (stable-id diff), and both screen hashes. It also clarifies its relationship to automatic evidence. It does not explicitly state it is read-only or what happens if no snapshot exists, but 'diff' strongly implies non-mutating behavior, and the output description adds context beyond the tool name.

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

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

Two sentences, tightly packed with meaningful information: what it does, what it returns, and its relationship to other tools. 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 description covers the core behavior and return values, and an output schema exists to detail the exact structure. It doesn't mention edge cases (e.g., no snapshot), but given the tool's simplicity and available schema, this is sufficient. Could be a 5, but a note about snapshot prerequisites 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?

Schema description coverage is 100%, so the parameter (device) is fully documented in the schema. The description does not mention parameters, which is fine because the schema already handles it. Baseline 3 applies; no extra value needed from 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 clearly states the tool's function: 'Diff the current screen against the last cached snapshot.' It uses a specific verb ('diff') and resource ('screen' vs 'cached snapshot'), and distinguishes itself by mentioning it is the 'explicit counterpart of the automatic evidence returned by every action tool.' This separates it from sibling tools like get_screen or get_screen_hash.

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

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

It provides clear context by calling itself the 'explicit counterpart of the automatic evidence returned by every action tool,' implying use when explicit diff evidence is needed. However, it does not explicitly state when not to use it or name alternative tools. This is clear context without exclusions, meriting a 4.

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. 'Read' indicates a non-destructive operation, but the description does not disclose potential behaviors like how it handles multiple connected devices or what the output structure is. While the schema mentions the device parameter, the description alone offers limited behavioral detail.

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, highly readable sentence that leads with the action and lists the key facts. It is optimally concise with no filler or redundant content.

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

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

The tool is simple and an output schema exists, so the description does not need to explain return values. It covers the core purpose adequately. A minor gap is the lack of explicit handling for the optional device parameter, but the schema provides that 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?

The schema description fully covers the single parameter (device), so the baseline is 3. The description does not add any additional parameter semantics beyond what the schema already provides, but no extra information is necessary given the 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 specifies the exact action ('Read') and the resource ('device facts') along with a concrete list of attributes (model, manufacturer, Android version, resolution, density). This clearly distinguishes the tool from sibling action tools like tap or swipe.

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 device properties are needed, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. The simple read-only nature makes the context clear, yet no direct guidance is 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 the full burden. It discloses that the tool returns a text-mode snapshot with elements formatted as `[id] class "label" kind@(x,y)` plus the screen hash, and that ids are stable for later use. This gives meaningful insight into the tool's output behavior, though it stops short of detailing prerequisites or edge cases like device connection errors.

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, about 40 words. It front-loads the core purpose and then details the return format and the relevance of stable ids. Every sentence adds value without redundancy or fluff.

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

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

The tool has only 2 optional parameters with full schema descriptions and an output schema (per context signals). The description supplements this by explaining the output line format and the screen hash, which is useful beyond the schema. It is complete enough for an agent to correctly invoke the tool, though it could optionally mention default mode behavior or device‑related failures.

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% for both parameters (mode and device), each with clear descriptions. The tool description adds no additional parameter semantics beyond the schema, so the baseline of 3 applies. The mention of 'compact' in the description aligns with mode defaults but does not extend the schema's 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 clearly states a specific action: 'Capture a compact text-mode snapshot of the current screen.' This distinguishes it from siblings like get_screen_hash (which only returns a hash) and tap (for interactions). The return format is explicitly described, reinforcing the tool's unique role.

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: it returns stable element ids that can be used with tap(). This implies when to use the tool (when you need to inspect or interact with screen elements). It does not explicitly mention alternatives or exclusions, but the sibling context and the stable-id feature effectively steer usage.

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 of disclosure. It discloses that the operation is cheap and returns a hash-based fingerprint, conveying read-only-like behavior. However, it doesn't detail edge cases or side effects, but for a simple hash tool this is sufficient.

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

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

The description is two sentences, with the core purpose front-loaded and the usage case following immediately. Every sentence adds value with 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?

Given the tool's simplicity, the presence of an output schema, and the clear use-case explanation, the description is complete. It doesn't need to explain return values since the output schema exists, and the behavioral context is adequately covered.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add any clarification about the 'mode' parameter (summary vs full) beyond what the schema already states, leaving the agent without additional semantic guidance.

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

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

The description clearly states the tool returns a cheap fingerprint of the current screen (a hash of the snapshot), using a specific verb and resource. It also distinguishes itself from get_screen by explicitly noting it avoids refetching the full snapshot.

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

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

It explicitly guides the agent to call this before and after an action to detect screen changes, and points out the alternative of not refetching the full snapshot, which implies get_screen as the alternative for full content. This gives clear context on when to use the tool.

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 a key behavior: returns an empty list (never an error) when no device is connected. It also specifies the return format, which adds useful context. It doesn't mention prerequisites like ADB being installed, but for a simple tool this is sufficient.

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

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

Two concise sentences with no redundant information. The description front-loads the core action and result, and then adds the exception behavior in a single clause. 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 zero-parameter list tool, the description is complete. It specifies the output schema, the edge case of no devices, and the error behavior. The presence of an output schema further reduces the need for more detail.

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

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

The tool has zero parameters, so the baseline is 4. The description adds value by explaining the output format, which is more relevant than parameter details. There's no parameter ambiguity to resolve.

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 ('List') and resource ('all adb-connected Android devices'), and specifies the output structure ({serial, connection_type}). This distinguishes it from sibling tools like tap or get_device_info, which operate on individual devices rather than enumerating 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 implies usage for device discovery/enumeration without explicitly naming alternatives. Since no other sibling tool lists devices, it's clear when to use this. It lacks explicit 'use this when' statements but the context is unambiguous.

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 the read-only nature and the underlying behavior ('asks a vision-language model for the element's bounding box on the current screenshot'). This is solid, though it stops short of describing potential failure or nondeterminism.

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 concise sentences, front-loaded with the main action and safety hint ('read-only'), immediately followed by the key contextual detail. 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?

For a reasonably simple read-only locate tool with an output schema, the description provides enough context: when to use it, what it does, and on what input it operates. It leaves out error/not-found behavior, but that is likely covered by the output schema; still, a mention of fallback behavior would make it more complete.

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

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

The schema already covers 100% of parameters with detailed descriptions, including a concrete example for target. The description adds contextual framing but no additional parameter-level meaning, so the schema-driven 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 explicitly states the action ('Locate a described element via the VLM grounding layer') and frames it as the 'THIRD perception layer (tree -> OCR -> VLM)', clearly distinguishing it from sibling tools like get_screen and verify_element. It names the exact resource (element) and mechanism (VLM grounding).

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

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

Provides explicit when-to-use guidance: 'when the accessibility tree and OCR cannot resolve a target on a tree-failed screen (Flutter/Unity/games)'. The layer ordering tree -> OCR -> VLM also clarifies when not to use it, making the usage context unambiguous.

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 that unknown/not-installed apps yield a structured APP_NOT_INSTALLED error with a suggestion to use the exact package name. This adds value beyond the input schema, which only describes parameters. With no annotations, it covers an important failure mode, though it stops short of other behavioral details such as foregrounding or permissions.

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

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

Two sentences, front-loaded with the core purpose, followed by a concrete error-handling detail. 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?

Despite having 3 parameters and an output schema, the description covers the main action and a key error case. However, it does not mention session_id or differentiate from open_settings, leaving some ambiguity in tool selection. Overall, the description is sufficient but not comprehensive.

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 already describes app_name and device; the description's 'friendly name or package name' paraphrases app_name's examples. session_id remains undocumented at 67% coverage, and the description does not clarify it. The added semantic value over the schema is minimal.

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 'Launch an installed app by friendly name or package name,' which clearly states the action and resource. It distinguishes from sibling open_settings by implying a general app launcher, though it doesn't explicitly name that sibling.

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 usage scenario: to launch an installed app. However, it provides no explicit when-not-to-use guidance and does not mention alternatives like open_settings. The error hint is about failure recovery, not tool 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?

No annotations are provided, so the description must carry behavioral disclosure. It mentions the deep-link mechanism but does not elaborate on potential side effects, device/session requirements, or failure modes. For a non-destructive navigation action, this is adequate but leaves 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 compact: one main sentence and a list of supported panels. It is front-loaded with the primary purpose and contains no filler. Every element contributes meaningful 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 (3 params, no annotations, but an output schema exists), the description covers the essential purpose and scope. It lacks behavior descriptions for session handling or errors, but these are not critical for a straightforward settings opener. The output schema likely documents return values.

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 67% (panel and device have descriptions, session_id does not). The description adds a list of valid panel values, which is helpful for the panel parameter. However, it does not provide additional meaning for device or session_id, leaving the undocumented session_id poorly contextualized. This partially compensates but not fully.

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: 'Open a system settings panel via ACTION deep link.' It identifies the specific verb (open), resource (system settings panel), and mechanism. The list of supported panels adds specificity and distinguishes it from the sibling open_app tool.

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

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

The description implies usage by enumerating supported panels, which serves as a whitelist of valid targets. It doesn't explicitly mention alternatives or exclusions, but the scope is clear enough. A sibling comparison is absent, but for a simple settings opener, the context 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention potential side effects (e.g., power toggling screen, volume changes), device connection requirements, or error handling for invalid keys. The list of valid keys helps but omits any system-level impact or prerequisites.

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 that efficiently communicates the core purpose and enumerates valid inputs. No filler words or 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?

For a simple 3-parameter tool, the description is minimally viable but leaves gaps: session_id is unexplained, and the lack of annotations increases the need for explicit behavioral context (e.g., side effects, multi-device handling). The output schema may mitigate return-value ambiguity, but the description could still offer more operational guidance.

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 to the 'key' parameter by enumerating all accepted values, which goes beyond the schema's single example. However, schema coverage is partial (67%): 'session_id' is left undocumented by both schema and description, and 'device' is only described in the schema. The description does not fully compensate for the missing parameter semantics.

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

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

The description clearly states the action (press) and the resource (system key), enumerating the specific supported keys. This unambiguously differentiates it from siblings like tap, swipe, and type_text, which operate on screen elements or text.

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 system-level key presses, but does not explicitly contrast with alternatives (e.g., using tap for UI buttons) or define when not to use it. No exclusions or prerequisites are mentioned, leaving the decision to the agent's inference.

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

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

With no annotations provided, the description carries the full burden and does well. It discloses that snapshot caches and budget counters are cleared, that a fresh observer is created on next screen access, and what the return value looks like.

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

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

The description is concise and well-structured: it states the purpose first, then usage triggers, then return value. Every sentence earns its place with no fluff.

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

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

The description is highly complete given the simple optional parameter and available output schema. However, the missing explanation of session_id is a small gap that prevents a perfect completeness score.

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 explain the single parameter `session_id`. Since schema description coverage is 0%, the description should compensate, but it omits any information about how session_id affects the reset operation or what omitting it means.

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 resets the session and specifies exactly what is cleared (per-device snapshot caches and execution budget counters). It is a specific verb+resource formulation that distinguishes this tool from the sibling device-interaction 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?

Explicit usage triggers are provided: call after EXECUTION_BUDGET_EXCEEDED or when element ids from get_screen are stale. This gives concrete, actionable guidance on when to invoke the tool.

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. It adds only the phrase 'native one-page scroll,' which hints at the scrolling mechanism but does not disclose edge-case behavior (e.g., what happens if the page is not scrollable), whether the scroll waits for completion, or any side effects. The behavior beyond the core action 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 immediately conveys the tool's core function. There is no filler or redundant information, making it optimally concise and well-structured.

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

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

The tool is simple and has an output schema, so return values are covered. However, the description omits usage guidance relative to sibling tools and leaves the 'session_id' parameter undocumented in both schema and description. For a straightforward scroll gesture, the description is adequate but not fully complete.

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

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

The schema already describes the 'direction' and 'device' parameters with meaningful context (e.g., content direction vs. finger swipe direction). The description adds the concept of 'exactly one viewport page,' which helps interpret the effect of 'direction.' However, it does not clarify the 'session_id' parameter, and the description alone adds minimal parameter-level detail.

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 exactly one viewport page' with the qualifier 'native one-page scroll.' This distinguishes it from siblings like swipe (which can be arbitrary) and scroll_until (which scrolls until a condition), 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 provides no guidance on when to use this tool versus alternatives such as swipe, scroll_until, or smart_scroll. It does not mention preconditions, exclusions, or scenarios where this tool is preferred, leaving the agent to guess based on the name and behavior.

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 adds valuable details: scrolling is one-viewport-page based, and it stops at the container boundary to avoid useless swipes. It does not mention behavior when max_scrolls is reached, but the stopping condition (scroll ends) is partially disclosed, making this a solid 4.

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 defines purpose, the second adds a relevant behavioral detail. It is front-loaded, contains no filler, and every word contributes to understanding.

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 an output schema and 80% parameter coverage, the description adequately covers the core purpose and stopping behavior. It does not explain return values (not needed) or explicitly mention max_scrolls interaction, but the 'or the scroll reaches its end' phrase covers the natural termination condition. A slightly more explicit note about what happens when the target is not found would elevate it, but it is sufficiently 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 80%, so most parameters are already documented clearly. The description adds the concept of 'semantic target' which subtly enriches the target parameter by indicating it searches by text/desc/id, but this is marginal. It does not meaningfully compensate for the less-documented device/session parameters, so it stays at the baseline 3.

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 explicitly states 'Scroll until a semantic target appears' with a clear verb and resource, and adds a distinguishing behavioral detail ('one-viewport-page scrolling') that separates it from generic scroll_page or swipe tools. It also clearly conveys the stopping condition (target found or scroll ends), making the tool's purpose unmistakable.

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 you need to scroll to bring a semantic target into view. It provides context but does not explicitly name alternatives or exclusion criteria. Since it clearly states the primary use case without exclusions, it earns a 4 rather than a 5.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool aggregates over screens, returns positions, reuses scrolling/end detection, and falls back to OCR on tree-failed screens. This is rich behavioral detail, though it does not mention mutation safety, return format specifics, or rate limits—but given the context, the key behaviors are well covered.

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 primary action and differentiated from a sibling. Every clause adds value—the comparison, the budget behavior, the reuse of scrolling mechanics, and the OCR fallback. No redundancy or filler.

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

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

Given the tool's complexity (aggregation, scroll budget, OCR fallback) and the presence of an output schema, the description is sufficiently complete. It explains the core behavior, how it differs from the closest sibling, and a key edge case (tree-failed screens). The 5 parameters are mostly described in the schema, and the description ties them to the overall workflow.

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 80% (4 of 5 params described), so the baseline is 3. The description adds value by linking 'scroll budget' to max_scrolls and explaining the aggregation semantics. It also clarifies the target and direction indirectly, though it doesn't add new syntax beyond the schema. The extra context about budget and OCR makes it slightly above 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 explicitly states the verb 'Scroll and AGGREGATE' with a specific resource ('every matching element across the screens passed'), and immediately distinguishes itself from sibling tool scroll_until by contrasting 'first hit' vs. 'ALL matches with their positions'. This makes the tool's purpose unmistakable.

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 'Unlike scroll_until (first hit), smart_scroll visits each screen in the scroll budget and returns ALL matches', providing a clear when-to-use vs. alternative. It also mentions reuse of 'one-viewport-page scrolling + end detection' and OCR fallback, giving implementation context that helps decide when to choose this tool.

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 return evidence structure ({executed, screen_changed, changed_elements[], screen_hash}), which adds useful behavioral context. However, with no annotations, it does not cover side effects, failure conditions, or device requirements.

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 with no wasted words. It front-loads the action and immediately specifies the return evidence, making it easy to parse.

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

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

For a simple swipe tool, the description is largely complete: it mentions the return output and the schema covers most parameters. However, it does not differentiate from overlapping siblings like scroll_page or smart_scroll, and session_id remains undocumented, leaving some gaps.

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

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

Schema coverage is 75% (direction, distance, and device have descriptions; session_id does not). The description adds no parameter-level detail beyond what the schema already provides, so it does not compensate for the missing session_id semantics.

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

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

The description clearly states the action ('Swipe the screen') and the specific scope (direction: up/down/left/right). This distinguishes it from siblings like tap or scroll_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?

No guidance is provided on when to use swipe over alternatives like scroll_page or smart_scroll. The description only states what it does, 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?

With no annotations, the description carries the burden. It discloses the return shape (verification evidence fields), the SELECTOR_AMBIGUOUS case with candidates[], and a retry recommendation. It does not mention side effects or waiting behavior, but the verification result indicates the tool confirms its own 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 well-structured: a one-sentence purpose, a bulleted selector guide, and a return-format note. Each component contributes unique 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?

Covers the main behavior (verification, ambiguity handling), selector semantics, and output shape. The schema covers device and session_id. It omits potential edge cases like timeouts or post-tap settling, but for a tap tool the description is sufficiently complete alongside the output schema.

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

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

The description adds significant meaning to the target parameter by explaining each 'by' value (text, desc, id, bounds) with examples and a 'last resort' note. This goes beyond the schema's type-only description. session_id is not covered, but schema coverage is moderate and the main required parameter is well documented.

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?

Clear verb+resource: 'tap a semantic target and verify the result.' Distinguishes from sibling tools like swipe/type_text by focusing on semantic selectors and verification. The selector hierarchy (text/desc/id/bounds) further clarifies its 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?

Provides explicit guidance on selector choice: 'Prefer semantic selectors — never compute coordinates yourself,' with a hierarchy (text, desc, id, bounds last resort). Also advises retrying with by=id on ambiguity. However, it does not explicitly compare to alternative tools like swipe or type_text, though the distinct purpose makes this less critical.

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 and reveals key behaviors: semantic location of the target, the editable-field requirement, and that the field is cleared before typing. It stops short of describing failure modes or edge cases, but the core side effect is explicit.

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 short sentences deliver the core action, the target/focus decision, and the clearing behavior without filler. The description is front-loaded and every sentence contributes.

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 an output schema and no annotations, and the description covers the main operational aspects: what is typed, how the field is selected, and the clearing side effect. It could add failure/error behavior for non-editable fields or a missing target, but it is largely adequate for selection and 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 already documents text, device, and target at 75% coverage. The description adds meaning for target (semantic location, must be editable) and clarifies that the field is cleared, but it does not add value for device or the undocumented session_id parameter.

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

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

The description opens with 'Type text into an input field,' giving a specific verb and resource that clearly distinguishes it from sibling tools like press_key or tap. It further defines the input mechanism (semantic target or currently focused field) and the clearing behavior.

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 conditional usage: use a semantic target when the field is not focused, or rely on the current focus when target is omitted. It also warns that the target must be an editable field, but it does not explicitly contrast with alternative tools like press_key.

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 for behavioral disclosure. It clearly states two critical behaviors: it never raises on not-found or text mismatch, and it returns a structured boolean result. This is valuable and goes beyond the input schema by clarifying error handling and outcome type.

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 that front-load the primary purpose and immediately add a crucial behavioral note. Every word earns its place, 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 output schema exists, so return values are covered. The description covers the core purpose and the non-raising behavior, which is the key contextual information for an assertion tool. It slightly lacks detail on edge cases like timing or off-screen elements, but for this simple tool it is largely complete.

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

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

Schema description coverage is 100%, so the input schema fully documents all three parameters. The description itself adds no parameter-specific details, but the baseline score of 3 is appropriate since the schema handles the heavy lifting.

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

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

The description clearly states the tool's function with a specific verb ('Assert') and resource ('semantic target') scoped to the current screen. It also implies differentiation from siblings by emphasizing the boolean, non-raising result, though it does not explicitly name alternative 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 provides clear context for when to use this tool: when the model needs to branch on existence or text mismatch without exceptions. It does not explicitly list exclusions or alternative tools, but the guidance is sufficient for selecting this tool over siblings like locate or wait_for.

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 and does so excellently. It discloses blocking behavior, polling interval, timeout handling, and the critical non-raising timeout behavior ('Never raises on timeout — returns satisfied: false + final hash'). This goes beyond the schema by explaining runtime behavior and result semantics.

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 compact paragraphs: the first line states the purpose, and the second adds essential behavioral details. Every sentence contributes value—no filler, no repetition of schema fields. It is front-loaded with the main 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?

Given the tool's moderate complexity (5 params, nested target object) and the existence of an output schema, the description fully covers the key aspects: what it does, how it behaves (polling, timeout, return), and the edge case of loading screens/transient UI. It is sufficiently complete for an agent to select and invoke it correctly.

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

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

Schema coverage is 100%, and each parameter already has a descriptive schema comment. The description adds context about interval/timeout ('handles loading screens and transient UI') but does not explain target structure or device semantics beyond what the schema provides. This aligns with the baseline 3 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 opens with a specific verb+resource: 'Block until a semantic target appears or disappears on screen.' This clearly distinguishes wait_for from siblings like verify_element (which likely checks current state) and locate (which finds an element), as it emphasizes blocking/polling over time.

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 usage context: 'Polls fresh snapshots every interval seconds until the condition holds or timeout expires (handles loading screens and transient UI).' This implies when to use the tool (waiting for dynamic UI states) but does not explicitly name alternatives or exclusion cases, which would be needed for a 5.

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