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

The description discloses that it reports findings and optionally attempts recovery when auto_fix=true, which is useful transparency. However, it does not explain what recovery actions may be taken, whether they can modify app state, or what the default read-only behavior entails, leaving side effects partially 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 compact and well-structured, using two sentences to cover purpose, output, optional behavior, and a prerequisite. Every sentence contributes useful information with no redundant or vague 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 simple parameter list and no output schema, the description covers the tool's purpose, optional configuration, and prerequisite. 'Report findings' is somewhat vague about the exact output format, and 'attempts recovery' lacks detail, but the overall context is sufficient for basic 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 only parameter, auto_fix, has schema title and default but no schema description. The tool description supplies meaning by stating that auto_fix=true enables recovery attempts, effectively covering the parameter's role. It could be more explicit about the default false behavior, but the semantic gap is mostly filled.

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 ('diagnose'), a clear resource ('current screen'), and specific conditions being detected (crashes, ANRs, permission blockers, unexpected overlays), followed by reporting findings. This clearly distinguishes it from sibling tools like ai_understand_screen or find_element.

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

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

The description gives a prerequisite (requires OPENAI_API_KEY or LLM_* env) and behavior for auto_fix=true, but provides no explicit guidance on when to choose this tool over related siblings such as ai_understand_screen or ai_execute_goal. It lacks when-to-use and when-not-to-use direction.

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 mentions that the agent runs a loop and returns a step log, but it does not state whether the agent can perform side effects or take destructive actions. With no annotations, the full burden is on the description, which lacks explicit safety details.

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, compact and well-structured. It states the primary function, notes dependencies, and gives usage preference, all without redundancy.

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

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

The description provides sufficient context by directing users to prefer primitive tools and clarifying when delegation is appropriate. It also notes the external dependency on API keys, making the overall context 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 'goal' parameter is explained implicitly as 'natural-language goal', but 'max_steps' is not described in the text or schema. Since schema coverage is 50% (one of two parameters explained), the description adds moderate value but leaves a gap.

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

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

The description clearly states that the tool delegates a natural-language goal to a server-side AI agent that runs an observe-think-act loop and returns a step log. The purpose is unambiguous and specific.

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 to prefer primitive tools unless the user explicitly asks to delegate, providing a clear when-to-use guideline. It also mentions the required API keys, which is a practical usage condition.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that the tool performs a server-side LLM call and requires specific environment configuration, which is a meaningful behavioral constraint. However, it does not mention what happens if the key is missing, whether the screen data is sent externally, or any latency/cost/privacy implications of invoking a remote LLM.

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 two-sentence description is tight and efficient: the first sentence states the core purpose and expected output, and the second sentence adds the critical configuration requirement and fallback. No filler or redundant restatement of the tool name.

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 zero-parameter input and the presence of an output schema to explain return values, the description covers the essential invocation context: purpose, configuration prerequisite, and alternative path. It could be slightly more complete by addressing what the tool returns or what conditions make it inappropriate beyond missing configuration, but overall it is sufficient for an agent to decide and call correctly.

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

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

The tool has zero parameters, so there is no parameter semantics burden on the description. The baseline for zero-parameter tools is 4, and the description appropriately focuses on the tool's behavior and prerequisites rather than parameters.

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

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

The description clearly states the tool's specific action: ask the server-side LLM to semantically analyze the current screen, including output categories like page type, purpose, and key elements. This verb+resource+result framing distinguishes it from sibling tools like get_screen_elements, which retrieves structural elements rather than semantic analysis.

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 states when to use this tool: when OPENAI_API_KEY or equivalent LLM configuration is available. It also provides a clear alternative and fallback path: otherwise prefer get_screen_elements + screenshot and analyze yourself. This is strong usage guidance with a named alternative and condition.

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 fully carries the safety burden: it labels the tool DESTRUCTIVE, details effects (logout, settings wipe), and discloses the confirm requirement beyond the schema's default.

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

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

One dense sentence front-loads the destructive warning and packs purpose, effects, and a parameter prerequisite without redundant 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 two-parameter destructive action with an output schema, the description covers the essentials. It is only slightly incomplete by not stating what happens if confirm is not true, although 'Requires confirm=true' implies the operation will not proceed.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies confirm's role as a mandatory safety gate and ties package_name to the app being cleared, but it does not describe the expected package_name format or the behavior when confirm is false.

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 and resource ('clear all user data of an app') and adds concrete effects ('logs the user out, wipes settings'), which clearly differentiates it from siblings like stop_app or clear_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 use case is implied by the stated purpose, and the confirm=true precondition is an actionable guideline, but the description does not explicitly contrast this tool with alternatives or state when not to use it.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does disclose an important behavior: clearing the focused field when no selector is given. However, it does not describe failure modes, whether the operation is destructive beyond clearing, or how multiple matching elements are handled, leaving gaps in transparency.

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

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

The description is a single, compact sentence and front-loads the primary action. It would be slightly better if it named the concrete selector parameters, but there is no wasted wording.

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

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

Despite having an output schema, the description omits essential context for correct invocation: how to express a selector, whether multiple selector params combine, and what happens when no selector matches. An agent calling this tool with only the schema and description would lack enough detail to reliably construct arguments.

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 zero parameter descriptions, so the description must compensate by explaining what index, resource_id, target_text, and text_contains mean. It only refers generically to 'selector' without mapping that term to the actual parameters, leaving an agent to guess how the four optional fields are used to locate the input.

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 ('clear') and resource ('text of an input field'), and distinguishes the two invocation modes: by selector or on the focused field. It does not explicitly differentiate this from sibling tools like input_text, but the verb 'clear' is sufficiently distinct from 'input'.

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 explains what the tool does but gives no guidance on when to choose this tool over alternatives such as input_text or tap. There is no mention of preconditions, exclusions, or typical clearing workflows, so an agent must infer the appropriate usage context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose the key side effect of remembering the device as default and the return type (screen size, current app). However, it does not explain behavior when serial is omitted, whether a previous default is replaced, or prerequisites like device visibility, so transparency is adequate but incomplete.

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

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

Two sentences, no filler. The core action and session-default behavior are front-loaded, followed by the return value. Every word earns its place.

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

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

The tool is simple, and the description covers purpose, side effect, and returns, with an output schema present to describe the response structure. However, it omits guidance on the sole parameter (serial) and does not reference the sibling list_devices for discovering valid serials, leaving a meaningful gap for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the serial parameter. It does not mention serial at all. The parameter name is self-explanatory as a device identifier, but the optional/null semantics and behavior when omitted are left entirely to inference.

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 ('Connect'), the resource ('Android device'), and the session-scoped side effect (becoming the default). It also states the return value, distinguishing it from siblings like list_devices and disconnect_device without needing to open the schema.

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: before subsequent device-related calls in the session, since it establishes the default device. However, it does not explicitly mention alternatives (e.g., list_devices to discover serials) or specify when not to use it, leaving the guidance mainly implied.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It goes beyond the tool name by explaining that the uiautomator2 session is released, and it clarifies the default-device behavior when serial is omitted. It doesn't mention broader side effects, but the session release is a meaningful and sufficient behavioral detail for this simple tool.

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

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

The description is two sentences with no filler. The primary action is front-loaded, and the optional serial behavior is presented as a direct, useful follow-up. Every sentence earns its place.

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

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

This is a low-complexity tool with one optional parameter and an output schema present. The description covers the core operation, the parameter's default behavior, and the side effect of releasing the uiautomator2 session. Nothing critical is missing for an agent to call this tool correctly.

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

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

The schema provides no descriptions for the serial parameter, so the description must compensate. The instruction that omitting serial disconnects the current default device adds real semantics beyond the schema's optional string/null type. It implies that providing a serial targets a specific device, which is enough for a single-parameter tool, though it doesn't state where the serial value comes from.

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 ('Disconnect') with a clear resource ('a device') and adds the behavioral detail of releasing the uiautomator2 session. It distinguishes the action from sibling tools like connect_device and list_devices by specifying the operation on a device-level session.

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

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

The description gives clear usage context: omitting the serial parameter targets the current default device, which is a practical rule for invocation. It does not explicitly name alternatives or exclusions, but the operation is simple and the context is unambiguous for the common case.

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, and the description does not disclose side effects, such as whether the gesture triggers app actions, changes UI state, or requires any preconditions. The full burden falls on the description, which is minimal.

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 one short sentence with no redundant information. It front-loads the action and directly states the two targeting modes.

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 no annotations and minimal parameter metadata, the description lacks important context such as expected behavior, potential side effects, error conditions, and return value. It is sufficient for a basic understanding but not complete for safe and correct invocation.

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

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

The schema has no parameter descriptions, and the tool description only lists parameter names without explaining coordinate origin, precedence rules, whether x/y are required together, or how selector parameters interact. Coverage is too low to rely on the schema, and the description does not fully compensate.

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

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

The description clearly states the action (double-tap) and the two supported target modes: coordinates (x, y) or an element selector (text / resource_id / index). This distinguishes it from sibling gestures like tap, long_press, and 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 does not explain when to prefer double-tap over tap, long_press, or other gestures. It only describes what the tool does, not the conditions or context in which it should be used.

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

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

With no annotations, the description carries the full burden. 'Check whether' and 'currently exists' indicate a read-only, immediate operation, but it does not disclose what happens when no match is found, whether it only considers visible elements, or any error behavior. It is minimally transparent but not comprehensive.

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

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

The description is two short sentences with no unnecessary words. The functional purpose is front-loaded, and the required selector-field constraint is stated immediately. Every sentence earns its place.

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

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

For a 5-parameter tool with no annotations, the description is thin. It omits matching semantics (e.g., AND/OR combination), the role of the index parameter, and behavior when no element matches. The output schema likely covers return values, but selector construction guidance remains underspecified.

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

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

Schema description coverage is 0%, so the description must compensate. It adds a useful constraint ('Provide at least one selector field') but does not explain the meaning or interaction of individual parameters like text, text_contains, or resource_id. The property names are somewhat self-explanatory, but the description alone is insufficient for precise selector construction.

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 ('Check') and resource ('element ... on screen'). The phrase 'currently exists' distinguishes it from wait_for_element and get_screen_elements by implying an immediate, non-waiting existence check. 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 implies use for verifying immediate presence of an element, but it does not explicitly contrast this with sibling tools like wait_for_element or get_screen_elements. It gives no explicit when-to-use or when-to-use-alternative guidance.

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

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

No annotations are provided, so the description must carry the behavioral burden. It does so by explicitly enumerating what information is returned (serial, screen resolution, SDK level, screen-on state, foreground app), which clearly signals a read-only information retrieval operation. It does not explicitly state side effects are absent, but 'Get info' strongly implies it.

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, information-dense sentence that front-loads the core action and resource, then packs the important output fields into a clear list. Every word earns its place 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?

With zero parameters and an output schema present, the description does not need to explain return values or argument details. It covers what the tool returns and implies when to use it, but it omits an explicit note about requiring a connected/current device, which is a minor completeness gap.

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

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

The tool has zero parameters and the schema coverage is effectively complete, so there are no parameter semantics to explain. The description correctly focuses on the output, earning the baseline score of 4 for zero-parameter tools.

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 ('info about the current device') followed by a concrete list of data fields. This clearly distinguishes it from sibling tools like list_devices or get_server_status.

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

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

The description implies the tool should be used when the agent needs device-level information, but it does not explicitly state when to choose it over siblings or mention any prerequisites such as requiring a connected device. Usage context is only inferred.

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

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

With no annotations, the description carries the behavioral burden. It discloses that this is an observation/dump operation with no mutation implied, describes the output format in concrete detail, and adds a performance characteristic ('cheapest way'). It does not discuss edge cases or error behavior, but the read-only nature and output contract are clearly conveyed.

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

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

Two sentences with no filler. The first sentence front-loads the output format; the second immediately connects the output to concrete follow-up actions. 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 low-complexity read tool with an output schema, the description fully specifies the default behavior and downstream usage. The only real gap is the raw_json parameter, and since it is optional with a sane default, the primary invocation path is complete. The presence of an output schema also covers return-value details.

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

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

Schema description coverage is 0%, so the description needed to compensate for the raw_json parameter, but it never mentions raw_json at all. The parameter is only self-documented by its name and boolean type; the agent gets no explanation of what raw JSON looks like or when to set it to true.

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 ('Dump'), the resource ('current screen'), and the exact output shape ('numbered list of interactive elements' with indices, types, text, id, flags, and center coordinates). This clearly differentiates it from screenshot, find_element, and ai_debug_screen while also signaling its role as a lightweight observation 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?

Explicitly says this is 'the cheapest way to observe the screen' and tells the agent how to use the output with tap(x, y) or selector-based actions. It gives clear usage context, though it does not explicitly name alternatives or state when to avoid this tool, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that the server auto-starts on demand and exits after an idle timeout, which is valuable non-obvious behavior. It does not cover every possible side effect, but for a status getter this is strong disclosure.

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

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

Two sentences with no filler. The main purpose is stated first, followed by the most relevant behavioral context. Every sentence 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?

For a parameterless read-status tool with an output schema, the description is complete. It covers what status information is returned and the key server lifecycle behavior, leaving no critical gap for an agent to call 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?

The tool has zero parameters and schema coverage is 100% vacuously, so the baseline is 4. The description adds no parameter details because none are needed.

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

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

The description clearly states the tool retrieves automation-server status, specifying the exact details returned: uptime, idle-watchdog countdown, and connected devices. It distinguishes itself from siblings like list_devices by focusing on server-level status rather than device enumeration.

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 this tool is for checking server health/lifecycle, and the auto-start/idle-timeout note gives useful context for when it might be relevant. However, it does not explicitly state when to prefer this over list_devices or other siblings, leaving the agent to infer the selection criteria.

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

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

With no annotations, the description carries the full burden. It states the basic action but does not disclose edge-case behaviors such as what happens if no field is found, whether it replaces existing text (though the 'clear' parameter suggests this), or if it triggers events. It's minimally adequate for a straightforward action.

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

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

The description is a single, efficient sentence that front-loads the primary action and provides a clear fallback. It has no unnecessary words and earns its place.

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

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

The tool has six parameters, no schema descriptions, no annotations, and an output schema, yet the description is extremely sparse. It fails to explain how selectors are specified, what the parameters do, or what the output represents. This is incomplete for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only mentions 'selector' without mapping it to any of the actual parameter names (resource_id, target_text, etc.), and it gives no explanation of content, clear, index, or text_contains. This is a severe gap for a tool with six parameters.

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

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

The description clearly states the action (type text) and the target (input field), and it distinguishes between two modes: by selector or by current focus. This makes it easy for an agent to understand what the tool does and differentiate it from sibling 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 when to use the tool (when typing text into a field) but does not explicitly mention alternatives or exclusions. It notes that without a selector it uses the focused field, which is some guidance, but it doesn't compare to related tools like clear_text or 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It does this well by stating not only that it lists devices but also what state information it reports (online status, uiautomator2 session establishment). The term 'list' implies a read-only, non-mutating operation, which is a useful behavioral trait. It does not explicitly mention side effects such as starting the ADB server, but for a list operation this is a minor omission.

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

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

The description is a single, well-structured sentence that front-loads the core action ('List all Android devices attached via ADB') and then adds specific output details without redundancy. Every word earns its place, and there is no unnecessary filler.

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

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

For a simple, parameterless listing tool, the description is complete. It tells the agent what the tool does and what information the result will contain. The presence of an output schema relieves the description of explaining return-value structure, and no dependencies, authentication, or setup prerequisites are needed for a device enumeration 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?

The tool has zero parameters and the schema coverage is 100% (empty object). With no parameters to document, the baseline is 4, and the description correctly avoids inventing parameter-related details. No additional parameter semantics are needed.

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

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

The description uses a specific verb ('list'), identifies a clear resource ('all Android devices attached via ADB'), and goes beyond a bare resource by naming the exact information returned (online state, uiautomator2 session status). This clearly distinguishes it from action-oriented siblings like connect_device or get_device_info.

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: enumerating connected Android devices to serve as a discovery step before other operations. However, it does not explicitly state when to choose this tool over alternatives, such as get_device_info (which likely targets a single device) or get_server_status (which checks ADB server health). There are no exclusions or when-not-to-use conditions.

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 a heavier burden for behavioral disclosure. It does state the underlying action and target modes, plus expected UI outcomes, but it does not discuss duration semantics, potential side effects, or what happens when both coordinates and a selector are supplied. The core gesture is clear, but deeper behavioral context is missing.

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 wasted words. It communicates the action, the two targeting modes, and the typical use cases efficiently.

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 seven parameters, no annotations, and no schema descriptions, this one-sentence description is insufficient for an agent to confidently choose and populate parameters. The tool's basic purpose is clear, but important contextual details about selector fields and duration are left unspecified, despite an output schema being present.

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

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

Schema description coverage is 0%, so the description must add meaning to the seven parameters. It explicitly mentions x and y and the concept of selecting an element by selector, but it does not explain how text, index, resource_id, text_contains, or duration behave. The generic 'selector' wording only partially compensates for the complete lack of parameter documentation in 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?

Description states a specific action ('long-press'), clearly specifies the two target modes (coordinates or element via selector), and gives concrete use cases (context menus, selection mode, drag handles) that distinguish it from sibling tools like tap, double_tap, and swipe. It is neither a tautology nor vague about what the tool does.

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

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

The mention of 'context menus, selection mode, drag handles' provides clear contextual guidance on when a long-press is appropriate. It does not explicitly name alternatives like tap or double_tap or state when not to use this tool, but the intended use context is evident.

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

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

Annotations are absent, so the description must carry the behavioral disclosure burden, yet it only lists valid keys. It does not mention side effects (e.g., power toggling screen state), whether the press is a discrete tap-and-release, or that a connected device is required. For a state-changing action, this is a meaningful transparency gap.

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

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

The description is a single, well-structured sentence with no filler. The verb is front-loaded, and every listed key is necessary given the one-parameter schema.

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

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

For a simple one-parameter tool with an output schema, the description is usable out of the box. However, it omits behavioral context such as device connection requirements and side effects, and it offers no guidance on when to use this instead of sibling input tools. It is adequate but not rich.

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

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

The input schema gives no parameter description (0% coverage), but the description compensates by listing the permitted keys in prose and clarifying 'recent' as the app switcher. However, the schema's enum already communicates the allowed values, so the added semantic value is modest.

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 and resource ('Press a device key') and enumerates the exact supported keys, making its scope immediately clear. It naturally distinguishes itself from gesture-based siblings like tap, double_tap, and long_press.

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

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

The description implies when to use the tool—whenever a device key needs to be pressed—but it does not explicitly state when not to use it or how it compares to alternatives such as tap or input_text. The key list provides indirect differentiation, but no direct routing guidance.

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

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

The description states that the tool returns an image and a text summary, making the primary output transparent. It does not mention any side effects, but since it is a screenshot operation, it is implicitly non-destructive; no annotations are present to contradict this.

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, consisting of three clear sentences without unnecessary fluff. It efficiently conveys the core action, output, and a useful tip in a well-organized manner.

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 provides sufficient context for the tool's purpose and a specific cross-tool usage scenario. However, it omits details about the effects of 'max_dim' and 'save_path', which could be relevant for users to fully understand the tool's capabilities and constraints.

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 explains the purpose of the 'with_som' parameter, but does not describe the other two parameters ('max_dim' and 'save_path'). Since only one of three parameters is clarified, the description only partially adds meaning beyond the schema's basic type and default information.

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 captures the current screen as an image for visual verification, which is a specific and unambiguous purpose. It also mentions the output includes an image and a text summary, further clarifying the intended use.

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 a concrete usage hint: combining with_som=true with get_screen_elements to map numbered boxes to element indices. This gives practical guidance on how to use the tool effectively, though it does not explicitly contrast it with alternatives or specify when to prefer it.

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

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

No annotations are provided, so the description carries the full burden. It discloses the core action and a prerequisite ('current scrollable view'), but does not explain what 'forward' or 'backward' mean in practice, how much the view scrolls, or what happens when no scrollable view is available. This is minimum-viable transparency.

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

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

One sentence with no filler. The verb, resource, and differentiator are front-loaded, and every word carries meaning. It is appropriately sized for a simple tool.

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

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

For a low-complexity tool with one optional parameter and an output schema, the description is nearly complete. The main gaps are the semantics of 'forward'/'backward' and behavior when no scrollable view exists, which are minor for typical use. The sibling set and output schema cover much of the surrounding context.

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

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

Schema description coverage is 0%, but the single parameter 'direction' is fully enumerated with self-explanatory values. The description adds the useful context that direction is used without coordinates, yet it does not disambiguate 'forward'/'backward' or the mapping between directions and scroll behavior. It partially compensates for the schema gap.

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 'Scroll', a clear resource ('the current scrollable view'), and the key differentiator 'without needing coordinates.' This distinguishes it from sibling tools like swipe, which require coordinates, without having to inspect their schemas.

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

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

The phrase 'without needing coordinates' signals when this tool is appropriate and implicitly contrasts with coordinate-based alternatives, but it does not name those alternatives explicitly or state exclusions. This is clear context rather than a fully explicit routing rule.

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 behavioral disclosure burden. It explicitly states that the server is re-spawned automatically on the next tool call and that the action is always safe, which is valuable transparency beyond the schema.

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. The core action is front-loaded, and the safety/re-spawn behavior is provided as valuable supporting context.

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

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

For a zero-parameter tool with an output schema, the description is complete. It explains what the tool does, why it might be used, and the key behavioral assurance that it is safe and automatically re-spawned.

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

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

The tool has zero parameters, so there is nothing for the description to explain. The schema already fully covers this, and the description appropriately focuses on behavior rather than parameters.

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

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

The description clearly states the verb 'stop' and the resource 'background automation server', while the purpose 'to free resources' adds context. It is easily distinguished from siblings like stop_app or get_server_status because it names the exact server component.

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

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

The phrase 'Manually stop... to free resources' provides clear usage intent, and 'always safe' reassures the agent about consequences. It does not explicitly mention alternatives or when not to use it, but the use case 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that it launches an app, but does not mention side effects like bringing the app to the foreground, potentially leaving the current screen, or the meaning of the 'stop_first' parameter. This is very limited behavioral transparency for a state-changing operation.

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

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

The description is a single, front-loaded sentence with no filler words. It efficiently conveys the core action and the key parameter context in a compact form.

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?

While the tool is relatively simple and has an output schema, the description omits important context such as the effect of 'stop_first', the meaning of 'activity', and any prerequisites like device connectivity. For a state-changing tool with no annotations, this is insufficient for an agent to invoke it correctly in all situations.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains 'package_name' implicitly via 'by package name'. The 'activity' and 'stop_first' parameters, both with defaults, are not described at all, leaving their purpose and usage unclear.

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 ('Launch'), a clear resource ('an app on the current device'), and the key identifier ('by package name'). This distinguishes it from siblings like 'stop_app' and 'clear_app_data' without needing to inspect the schema.

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 launch an app on the current device. However, it does not provide explicit guidance on prerequisites such as a connected device, nor does it mention alternatives or when not to use this tool. The context is clear but lacks exclusionary or prerequisite information.

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 itself must convey behavioral implications. 'Force-stop' does signal a terminating/destructive action, but it does not disclose potential side effects (e.g., loss of unsaved state, effect on background processes, behavior if the package is missing). The core behavior is transparent, but the consequences are not fully addressed.

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

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

A single sentence contains the verb, target, and parameter relation with no filler. It is front-loaded 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 one-parameter force-stop operation with an output schema available, the description plus schema provide enough to call the tool correctly. It misses minor context such as error handling and side-effect caveats, but these are not essential for basic 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 0%, so the parameter meaning relies on this description. The phrase 'by package name' directly connects the sole required parameter to the action, and although it lacks a format example, a single self-explanatory parameter makes correct invocation straightforward.

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

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

The description states a specific action (force-stop), a resource (app), and the key discriminator (package name). This clearly distinguishes the tool from siblings like start_app and clear_app_data without requiring schema inspection.

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 operation's purpose is clear, but there is no explicit when-to-use guidance or stated alternatives. Usage is implied by the phrase 'force-stop an app', which is sufficient for simple cases but does not explain when to prefer this over clear_app_data or start_app.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention that a swipe is a touch gesture that may trigger navigation, scrolling, or app-specific actions, nor does it discuss side effects or prerequisites beyond screen size calculation. It also doesn't clarify the effect of the optional duration parameter on behavior.

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

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

The description is compact: two sentences with no filler. The first sentence is action-oriented; the second gives a useful tip about using get_device_info. It could include a bit more parameter detail, but it is efficiently sized.

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 5 parameters and 0% schema coverage, the description is too thin. It doesn't explain coordinate origins, duration units, or the effect of the gesture (e.g., swipe vs fling vs drag). The sibling list shows many alternative gestures (tap, scroll, long_press), and without boundary conditions, the agent may misuse this tool. The get_device_info hint is helpful but doesn't fill the 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 0%, and the schema only provides titles like 'Sx', 'Sy', 'Ex', 'Ey' with no descriptions. The description adds minimal semantics: it explains that sx, sy is the start coordinate and ex, ey is the end coordinate. However, it does not specify the coordinate system origin (e.g., top-left), units in pixels, or what duration means. Also, the duration default of 0.5 is undefined in units (seconds? milliseconds?).

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/drag') and the exact parameters (from (sx, sy) to (ex, ey)). It distinguishes itself from tap, double_tap, long_press, and scroll by specifying both start and end coordinates. It doesn't explicitly compare to siblings, but the verb plus coordinate range makes the purpose 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 when to use the tool (when a swipe or drag gesture is needed) and gives a useful hint about computing coordinates from get_device_info. However, it doesn't explicitly state when not to use it or mention alternatives like scroll for scrolling gestures. The guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the tap action and the coordinate-or-selector constraint, but does not explain what happens if a selector matches multiple elements, whether coordinates and selectors can be combined, timeout behavior, or failure outcomes.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the second sentence adds an essential usage constraint without redundancy.

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

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

Given 9 parameters, 0% schema description coverage, and no annotations, the description is too sparse. An agent cannot reliably determine which selector parameters to fill, how they combine, or what precedence applies when both coordinates and selectors are provided.

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

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

Schema description coverage is 0%, and the description barely compensates. It identifies x/y as coordinates and implies selector-based lookup, but does not enumerate which of the many fields (text, index, xpath, resource_id, text_contains) count as selector fields, nor does it explain timeout or description parameters.

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

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

The description clearly states a specific verb ('tap') and resource (screen or element found by selector), and distinguishes coordinate-based taps from selector-based taps. It differentiates well from siblings like double_tap and long_press by describing a single tap action on the screen.

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

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

The description does not explain when to use this tool instead of alternatives such as double_tap, long_press, or swipe. It offers invocation guidance about coordinates versus selectors, but no contextual routing between sibling tools.

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

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

With no annotations provided, the description must carry the full behavioral disclosure burden. It does explain the blocking semantics and the selector requirement. However, it does not disclose what happens on timeout, whether failure throws or returns, or how multiple matching elements are handled. This is a meaningful gap for a blocking operation.

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

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

The description is a single, front-loaded sentence that begins with the action verb 'Block' and states both the main behavior and a concrete usage example. There is no redundancy or filler; every word 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?

For a tool with five parameters, zero annotations, and zero schema descriptions, the description is too minimal. It omits what each selector field does, how timeout behaves, and what happens if the element never appears. The output schema presumably covers return structure, but critical call-time behavior is missing.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining the parameter meanings. It only says 'selector field' without specifying which of text, index, resource_id, or text_contains act as selectors. Timeout is visible in the schema but its unit and failure behavior are not described. Property names hint at semantics, but the tool description adds almost no parameter 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 specific action: block execution until an element matching a selector appears. It also gives a concrete example (waiting for the next page after a tap). It does not explicitly contrast this with sibling find_element, so it loses a point on differentiation, but the core purpose is unambiguous.

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

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

The example 'after tapping a button, wait for the next page' gives a clear context for when to use this tool. It also instructs agents to provide at least one selector field. However, it does not mention when NOT to use it or name alternative tools like find_element, so the guidance is helpful but not fully explicit.

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