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

The description discloses that it computes the center and executes a precise tap, which is useful. However, it does not mention failure behavior (e.g., element not found), whether it waits for the screen to stabilize, or that it is a mutating action. Since no annotations are provided, the description carries the full burden and could be more thorough.

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 fluff. The key action and locator types are front-loaded, and the behavioral detail about center computation follows logically. Very 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?

The tool has six optional parameters with no required ones, yet the description does not clarify how to choose among them or what happens when multiple are provided. It also lacks details on error handling or return values, and there is no output schema. For a tool with ambiguous parameter usage, this is a significant 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?

Schema description coverage is 100%, so the schema fully documents all six parameters. The description adds minimal value beyond that, only restating that it uses text, content description, or resource ID. It does not explain how parameters combine or take precedence, but the baseline of 3 applies since the schema covers 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 states a clear verb ('click') and resource ('UI element'), and lists three locator types. It implies it is element-based, distinguishing it from the coordinate-based android_tap sibling, though it doesn't explicitly name that alternative.

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

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

No guidance on when to use this tool versus siblings like android_tap or android_find_element. It doesn't state that android_tap is for raw coordinates or that this is preferred for element-based interactions. The context is implied but not explicit.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the action ('Get') without mentioning that this is a read-only operation, whether it requires special permissions, or how it behaves when no app is focused. For a tool that queries system state, this lack of behavioral context leaves an agent uncertain about side effects and prerequisites, earning a low score.

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 unnecessary words. It efficiently states the verb and resource without redundancy, making it highly concise and structurally sound.

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 getter with one optional parameter and no output schema, the description adequately explains what is returned (package name and activity). It does not elaborate on device selection or error handling, but given the tool's simplicity and the optional nature of the parameter, these omissions are minor. The description is complete enough for an agent to use the tool correctly in most scenarios.

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 100% description coverage for the single optional parameter deviceId ('Optional device ID'), and the tool description adds no additional meaning about this parameter. The description does not discuss how deviceId is used or its impact on results. With high schema coverage, the baseline is 3, and this description does not elevate it.

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

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

The description uses a specific verb 'Get' and names the exact resource: 'package name and activity of the currently focused foreground Android application.' This clearly distinguishes it from siblings like android_screenshot or android_ui_dump, which have different purposes. An agent can immediately understand what this tool does and how it differs.

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: use when you need the identity of the current foreground app. It does not explicitly list alternatives or when not to use it, but the specificity of the purpose makes the usage scenario obvious. Without exclusions or references to sibling tools, it falls short of a 5, but is above a 3 because 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 burden of behavioral disclosure. It states the operation is 'get' which clearly implies a read-only action, but it does not explicitly say it is non-destructive or describe behavior on errors (e.g., if no device is connected). While the intent is clear, it lacks explicit safety/error context.

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

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

The description is a single, focused sentence with no redundant words. It front-loads the purpose and enumerates the returned fields, making it easy to scan.

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 read-only tool with one optional parameter and no output schema, the description covers the returned information and the connection prerequisite. It does not mention error handling or output format, but these are minor for a straightforward info-gathering tool, so slightly above average.

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 100% parameter coverage, fully describing the optional `deviceId` parameter including its effect when omitted. The description adds no additional meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the action (get) and resource (detailed information about the Android device), and enumerates the specific fields returned (device ID, model, manufacturer, OS version, SDK level, screen resolution). This distinguishes it from sibling tools, which are all actions or app-specific queries.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, typical use cases, or situations where it would be inappropriate. Since siblings are all actions, the distinction is implied but not explicit, so below average.

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

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

No annotations are provided, so the description must disclose behavioral traits, but it offers none. It does not mention that this is a convenience wrapper, any side effects, permission requirements, error behavior, or results of the action. The description simply lists action types without revealing how the underlying device interaction behaves or what happens on failure. This is a significant gap for a tool with no safety annotations.

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

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

The description is a single sentence and is front-loaded with the core purpose, so it is concise in wording. However, it is under-specified; the list of actions is useful but lacks the essential usage context that would make the sentence earn its place. It is not overly verbose, but it is minimal to the point of being incomplete, so it is only moderately 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?

Given the tool's complexity (17 parameters, 7 possible actions, no output schema), the description is grossly incomplete. It does not explain how to invoke each action, which parameters are required, how coordinates are resolved, or what the response contains. The tool cannot be used correctly without external knowledge. The absence of any param-action mapping is a critical flaw, making this definition inadequate for reliable agent invocation.

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

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

Schema description coverage is 100%, so each parameter has a basic description (e.g., 'X coordinate for tap'). However, the tool description adds no extra semantic value, and the parameter descriptions themselves are insufficient to clarify which parameters apply to which action. For instance, it is not clear that 'x1','y1','x2','y2' are required for swipe, or that 'text' is needed for type and click_element. The description fails to link parameters to actions, leaving the agent to infer the mapping from the schema alone, which is ambiguous.

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 performs a high-level Android action and enumerates the supported actions (tap, swipe, type, press_key, click_element, scroll, launch_app). The verb 'execute' and resource 'Android action' are specific. However, it does not distinguish itself from its many sibling tools (e.g., android_tap, android_swipe) that accomplish the same individual actions, leaving the agent uncertain whether to use this unified tool or a specific counterpart.

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

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

There is no guidance on when to use this tool versus the dedicated sibling tools. The description does not mention any advantages (e.g., convenience, single-call aggregation), prerequisites, or scenarios where it is preferred. The agent is left with no context to decide between calling android_execute_action and a specific tool like android_tap, making this dimension essentially missing.

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

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

No annotations are provided, so the description carries the full burden. It discloses that it searches the current screen and returns elements with computed center tap coordinates, implying a non-destructive read operation. However, it does not describe failure behavior when no match is found, how multiple matches are handled, or any permissions/limitations.

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

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

Two sentences with zero fluff. Purpose is front-loaded in the first sentence, and the return value (center tap coordinates) is stated in the second. No redundant or vague wording.

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

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

For a 7-parameter optional tool with no output schema, the description explains the search scope and the return type (matching elements with center coordinates). However, it omits details on how multiple criteria combine (AND/OR), whether all matches or only the first are returned, and the exact return structure – a gap since there is no output schema to clarify this.

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% – every parameter has an individual description. The tool description's list of search criteria (text, content description, resource ID, class name) maps directly to schema fields, adding no new semantics beyond the schema. Baseline of 3 applies.

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

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

States a specific verb 'Search' and resource 'UI elements on current Android screen', lists four search criteria (text, content description, resource ID, class name), and notes it returns elements with computed center tap coordinates. This clearly distinguishes it from siblings like android_ui_dump (hierarchy dump) and android_click_element (action).

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

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

No mention of when to use this tool versus alternatives. Sibling tools such as android_ui_dump or android_click_element are not referenced, leaving the agent to infer that targeted searching should precede clicking. No conditions, exclusions, or guidance on selecting between find and dump actions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action (launch) but does not explain side effects such as bringing the app to the foreground, what happens if the package is not installed, whether it waits for launch completion, or how non-optional parameters like activity and deviceId affect behavior. The description is minimal and relies on the name for implicit meaning.

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 opens with the core verb and resource. It is direct, front-loaded, and contains no filler. It efficiently conveys the essential information without unnecessary elaboration.

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

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

For a tool with three parameters, no output schema, and no annotations, the description is under-specified. It does not clarify whether optional parameters are truly optional or how they affect behavior, nor does it mention any prerequisite (e.g., device must be connected) or post-launch state. The tool is relatively simple, but the description could be more complete about observable results and edge cases.

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

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

Schema description coverage is 100% – all parameters (packageName, activity, deviceId) have descriptions in the schema. The description adds examples of package names, which reinforces the format but does not add new meaning beyond what the schema already states. Since the schema already documents parameters, the description provides marginal added value, so a baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Launch an Android application by its package name.' It specifies the verb (launch), the resource (Android application), and the identifying parameter (package name). It is distinct from siblings like android_tap or android_swipe, which handle interaction rather than launching.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that launching an app is a prerequisite for other actions, nor does it advise against using it for already-running apps. Given the sibling list includes many interaction tools, some contextual advice would help, but none is present.

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 states it will 'press' a key but does not disclose potential side effects (e.g., navigating away from the current screen), whether the call blocks, error conditions, or the role of deviceId. The list of supported keys is helpful but does not address behavioral consequences. The description is too sparse for a tool that directly manipulates device 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 a single sentence with a list of examples, which is concise and to the point. It front-loads the core action and then lists specifics. No wasted words, but it could be slightly better structured by separating the enumeration from the action. Still, it is appropriately short and scannable.

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

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

For a tool with only two parameters and no output schema, the description covers the essential input expectations. However, it lacks usage context (when to choose this over tap/swipe), behavioral outcomes, and any edge-case handling. Given the absence of annotations, more explanatory depth (e.g., deviceId semantics, or that pressing navigation keys may alter the app state) would be warranted. It is minimally complete but leaves gaps.

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

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

The input schema already covers both parameters (key and deviceId) with clear descriptions, and the schema description coverage is 100%. The description adds examples of supported keys (HOME, BACK, etc.) which are partially redundant but confirm the 'valid keycode' allowance. This matches the baseline of 3 where the schema does the heavy lifting; the description does not introduce novel semantic meaning beyond the schema.

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

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

The description clearly states the action ('Press an Android hardware or navigation key') and enumerates supported keys, making it distinct from sibling tools like android_tap (screen touches) and android_type_text (text entry). However, it does not explicitly contrast with siblings, so a slight deduction. 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 no guidance on when to use this tool versus alternatives such as android_tap or android_swipe. It does not mention prerequisites, context, or exclusions. An agent would need to infer that this is for physical/navigation keys rather than on-screen interactions. Lacks any 'when to use' or 'when not to use' statements.

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 states the action (capture screen) and output format (PNG) but does not explicitly mention that this is a read-only, non-destructive operation, nor does it disclose potential issues like device availability or permissions. However, the action is intuitively non-mutating, so the lack of detail is a minor gap.

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

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

A single, direct sentence with no filler. The main action and purpose are front-loaded, and every word contributes value. Appropriate for a simple tool.

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

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

Given the low complexity (no output schema, one optional parameter), the description is nearly complete. It explains the output format and purpose, and the parameter is documented in the schema. The only gap is the lack of usage guidance against sibling tools, which slightly reduces completeness but is not critical for such a simple operation.

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 the single parameter (deviceId), which already describes it as optional with auto-selection. The description adds no extra meaning about the parameter, so it meets the baseline for high coverage without adding value.

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

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

The description clearly states the verb 'Capture', the resource 'screen of the Android device', and the output as a PNG image. It also adds purpose ('visual inspection and AI computer-use reasoning'), which distinguishes it from sibling tools like android_ui_dump (which likely returns a structural dump) or action tools like android_tap.

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 visual inspection but does not explicitly state when to prefer this over alternatives such as android_ui_dump or android_device_info. No exclusions or alternative routing are provided, so an agent must infer usage from the stated 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 present, so the description carries the full burden. It adds the direction semantics ('down' reveals content below; 'up' reveals content above), which is helpful and beyond the schema. However, it does not disclose any other behavioral traits such as animation, failure modes, or interactions with the amount parameter, though these may be less critical for a scroll 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, clear sentence with no wasted words. It focuses on the direction parameter, which is the core input, and is appropriately front-loaded.

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

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

Considering the tool's simplicity, the description covers the basic action and direction semantics. However, it omits any differentiation from android_swipe and does not mention how the scroll relates to the current screen position (e.g., relative vs absolute). Given the tool has multiple siblings, this is a notable gap that affects completeness.

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

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

The schema already documents all three parameters with 100% coverage, so the description's role is minimal. It mentions 'direction' and repeats its meaning, but adds no extra detail about 'amount' or 'deviceId' beyond what the schema provides. This meets the baseline expectation, but does not elevate it.

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

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

The description clearly states the action: 'Scroll the screen in a specified direction (up, down, left, right).' It identifies the resource (screen) and the direction parameter, making the purpose evident. However, it does not differentiate from the sibling tool 'android_swipe,' so an agent might not know when to pick one over the other.

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 about when to use this tool versus alternatives like android_swipe or when scroll is appropriate. The description only states what it does, not the context or exclusions, leaving the agent to infer 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?

With no annotations provided, the description carries the full burden of explaining behavior. It states the gesture type and the configurable duration, but does not disclose any side effects, failure conditions, coordinate system assumptions, or whether the gesture is relative to the screen. The description is not misleading, but it adds little beyond what the name and schema already convey.

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, compact sentence that leads with the action and key parameters. It avoids any unnecessary filler or repetition, making it efficient and easily parsed by an agent.

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 gesture tool with no output schema and fully documented parameters, the description explains the core action and duration. However, it omits any mention of coordinate system relative to the screen, potential prerequisites (e.g., device must be unlocked), or behavior when the gesture is out of bounds. These are minor gaps, but the tool is simple enough that this is mostly 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 provides 100% coverage, with all six parameters having descriptive text. The description mentions 'configurable duration' but this repeats the schema's duration field. It does not add extra meaning about coordinate units, origins, or any interaction between parameters. Since schema coverage is complete, a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'perform a swipe / drag gesture' and specifies the resource as 'between two points (x1, y1) and (x2, y2)'. This is distinct from sibling tools like android_tap (a tap) and android_scroll (a scroll), so an agent can immediately tell this is for arbitrary two-point gestures.

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—it is obviously for swipes/drags—but does not explicitly state when to use this tool over alternatives (e.g., 'use android_tap for single taps', 'use android_scroll for scrollable areas'). No exclusions or alternative routing is provided, so the agent must infer applicability from the tool name and description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core action and does not reveal any side effects, prerequisites (e.g., screen on, app foreground), or whether the tap is synchronous or asynchronous. The agent has no information about what happens after the tap or how success is indicated.

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

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

The description is a single concise sentence with no filler or redundant words. It is front-loaded with the action verb and delivers the purpose directly, which is ideal for a simple tool. Nothing needs to be cut.

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

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

The tool is simple, but the description omits important context for correct usage, such as the coordinate system origin (top-left corner is assumed), behavior on invalid coordinates, and the role of deviceId when multiple devices are connected. It also does not distinguish from android_click_element for element-based interactions. Given the rich sibling set, the description is incomplete for an agent that must choose the right interaction tool.

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

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

The input schema already describes all three parameters (x, y, deviceId) with clear definitions and 100% coverage. The description adds nothing beyond restating that the tap is at 'specific (x, y) pixel coordinates', which is essentially redundant with the schema. Baseline 3 is appropriate because the schema handles the semantic load.

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

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

The description states the action verb 'Tap' and the resource 'specific (x, y) pixel coordinates on the Android device screen', making the tool's purpose clear and unambiguous. It is distinct from sibling tools like android_click_element (element-based) and android_swipe (gesture-based), so an agent can tell it apart without further explanation.

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 its alternatives. The description does not mention that it is for coordinate-based taps rather than element-based clicks, nor does it clarify when deviceId is needed. An agent would have to infer usage context from the schema alone.

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

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

No annotations are provided, so the description carries the burden. It discloses a valuable behavioral trait – escaping spaces and special characters – which tells the agent it can safely pass arbitrary text. However, it does not mention failure modes (e.g., no focused field, invalid characters) or whether it waits for the field to be ready. This is partial but not silent, so a 3 is appropriate.

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, zero filler. The core purpose is in the first sentence, with the behavioral nuance (escaping) in the second. Every word earns its place, and it front-loads the most important 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 action tool with one required parameter and no output schema, the description covers the essential aspects: what it does, where it acts (focused field), and its escaping behavior. It could mention error conditions or whether it clears existing text, but these are minor for the scope. Overall, it gives an agent enough to call it correctly in most scenarios.

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

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

Schema description coverage is 100% – both 'text' and 'deviceId' have clear descriptions. The description adds extra meaning for the 'text' parameter by explicitly stating that escaping is handled, which informs the agent that special characters are acceptable. This goes beyond the schema's simple 'Text string to type' and justifies a 4, slightly above 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 states a specific verb ('Type text'), a specific resource ('currently focused Android input field'), and a key detail ('handles escaping for spaces and special characters'). This distinguishes it from sibling tools like android_tap or android_press_key, which serve different actions. The purpose is unambiguous and immediately clear.

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 you need to type into a focused field) but does not explicitly mention when not to use it or name alternatives. It lacks the directiveness of the top-tier example that names a sibling tool. However, the context of 'currently focused' and the sibling names (e.g., android_press_key) make the scenario understandable, so it earns a 3 rather than lower.

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 states that the tool returns a structured, compact list of visible and interactive elements, including text, resource IDs, and screen bounds. This tells the agent what to expect and implies it is read-only (no side effects mentioned). It doesn't mention prerequisites like accessibility service permission or failure modes, but for a 'dump' operation, the core behavior is transparent. Slight gap: does not say whether it blocks or returns immediately, but that is minor given the nature of the tool.

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

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

The description is two clear sentences, starting with the verb 'Dump' and the resource. It front-loads the core action, then specifies output details in a single compact second sentence. No extraneous words or repetition—every phrase adds value.

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

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

The tool is simple (one optional param, no output schema), and the description covers the essential information an agent needs: what it returns and limits the results to visible and interactive elements. This is adequate for an agent to decide whether to call it and what to expect. It could be more explicit about whether the list is flat or hierarchical, and whether it includes scrollable/element hierarchy beyond visible ones, but the given detail is sufficient for typical use.

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

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

The schema has only one optional parameter (deviceId) and its description coverage is 100%, so the schema already tells the agent what the parameter does. The tool description does not add any extra semantics about deviceId (e.g., default behavior, format, or when it's needed). Since coverage is complete, the description doesn't need to compensate, and a baseline of 3 is appropriate.

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

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

The description clearly states the verb 'dump' and the resource 'Android screen UI hierarchy', and specifies the output: a structured list of visible, interactive elements with text, resource IDs, and bounds. This distinguishes it from siblings like android_find_element (which searches for specific elements) and android_click_element (which interacts), so an agent can tell them apart.

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 a use case (inspecting the current UI hierarchy) but does not explicitly state when to prefer this over alternatives, nor does it mention exclusion criteria. For example, it doesn't say 'use android_find_element to locate a single element' or 'use when you need an overview of all visible elements vs. screenshot'. The context is clear but guidance is implicit rather than explicit.

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