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

With no annotations, the description carries the full behavioral burden. It accurately communicates a read-only listing operation and current-installation scope, but it does not disclose the return format (package names vs. richer metadata), ordering, or error behavior if no device is connected.

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

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

A single front-loaded sentence states the action, resource, scope, and parameter requirement with no filler or repetition. 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 parameterless list tool, this is nearly complete: it identifies the target device, the installed-package scope, and the inclusivity of both system and user packages. The only minor gap is the absence of explicit output-format details, which is low-impact for this 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?

The schema already covers the parameterless signature completely, and the description reinforces it with 'No parameters are required.' This is sufficient for a zero-parameter tool and adds no unnecessary parameter detail.

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

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

The description uses a specific verb ('Returns a list'), names the exact resource ('all packages'), and clarifies scope ('both system and user-installed'), which clearly differentiates it from sibling tools like user_packages and system_packages.

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

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

It clearly conveys the context of listing every package currently installed on the device and explicitly notes that no parameters are required. However, it does not explicitly name alternatives or state when a more specific sibling such as user_packages or system_packages should be preferred.

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

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

With no annotations, the description must carry the safety/behavior disclosure itself. It indicates a read-only fetch of a CPU count, but does not state side-effect freedom, error behavior, or what happens without a connected device. This is adequate for a trivial query but not rich.

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

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

A single sentence conveys the function, target device, and parameter requirement with no redundant wording or buried details.

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

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

For a 0-parameter query returning a simple count, the description is nearly complete: it identifies the device context and the result. It could mention the return value type explicitly, but 'number' is sufficient for an agent to use the result.

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

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

The tool has zero parameters and the schema already shows an empty property set; the description reinforces this with 'No parameters are required.' Under the 0-param baseline this is appropriately scored.

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 ('Returns') and resource ('number of CPU cores on the connected Android device'). This cleanly identifies the tool's function and distinguishes it from the sibling cpu_percent, which measures usage rather than core count.

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

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

No guidance is given about when to choose cpu_count over related tools such as cpu_percent, or about prerequisites like an attached device. 'No parameters are required' is an input detail, not usage selection 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 carries the burden of behavioral disclosure. It states the tool returns a percentage and requires no parameters, which is transparent about the operation's simplicity. However, it does not disclose details like sampling interval, whether the value is instantaneous or averaged, or potential side effects (though likely none).

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 is concise and front-loaded with the core purpose. It includes the essential fact that no parameters are required, with zero wasted words.

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, read-only query tool, the description is largely complete. It states what it returns and that no parameters are needed. Minor gaps include not specifying the return format (e.g., integer vs float, range 0-100) or whether the value is a snapshot or average, but these are not critical for a simple 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 tool has zero parameters, and the schema is empty with 100% coverage. The description explicitly states 'No parameters are required,' which adds clarity beyond the empty schema by confirming the agent needs to supply nothing. Baseline for 0 params is 4, and the description meets 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 tool returns the current CPU load percentage on the connected Android device, using a specific verb ('Returns') and resource ('CPU load percentage'). It is distinct from siblings like cpu_count, which likely returns the number of CPU cores, though it doesn't explicitly differentiate itself.

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

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

The description implies usage context: it is a simple read-only query for CPU load on an Android device, with no parameters required. However, it does not explicitly state when to use this tool versus alternatives like cpu_count or get_properties, nor does it mention any prerequisites such as device connection.

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 correctly says it executes a command and returns output, implying a read/execute behavior. However, it does not disclose that raw ADB shell commands can have side effects, that the command runs with shell privileges, or that certain commands may hang or return empty output. With no annotations provided, the description carries the full burden but only partially covers behavioral risk.

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

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

Two sentences, front-loaded with the main verb and resource, and the parameter explanation is placed near the end. It is appropriately sized with no filler, though the second sentence is somewhat redundant with the schema, which costs it a point.

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 raw execution tool with no output schema and no annotations, the description is thin. The agent is not told what the output looks like (e.g., stdout/stderr, exit code, formatting), how to handle errors, or what environments this applies to (e.g., only when an Android device is connected). A tool with this much power and ambiguity needs more context to be safely invoked by an agent.

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

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

With schema description coverage at 0% and only one required parameter, the description must add meaning beyond the bare schema field name. It says the `command` parameter is 'the shell command to execute,' which adds a minimal explanatory layer but lacks detail such as expected format, quoting requirements, or whether adb shell prefix must be included. It does not compensate enough for the zero schema coverage.

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

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

The description states a specific verb and resource: 'Executes a raw ADB shell command on the connected Android device and returns the output.' This clearly differentiates it from sibling tools like input_tap, get_battery_level, or install_apk, which target specific device functions rather than arbitrary commands. It doesn't name a sibling explicitly, but the 'raw ADB shell command' framing makes its niche obvious.

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 explicit guidance on when to use this tool versus alternatives. The description does not mention which sibling tools handle specialized operations (e.g., input_keyevent or install_apk) or advise preferring them over raw commands. Its general-purpose nature is implied, but nothing tells the agent when raw shell is appropriate or inappropriate.

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. The description only states that it returns a list; it does not explicitly state this is a read-only operation, nor does it mention any potential side effects, permissions, or response characteristics. While the operation is inherently read-only, the absence of any explicit statement or caveat leaves the agent without clear expectations about safety or non-mutating 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 two sentences with no redundant phrasing. The main purpose is front-loaded ('Returns a list of all packages'), followed by the parameter details. Every sentence adds value, and there is no filler. It is appropriately concise and well-structured.

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

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

The tool is relatively simple, but given the presence of sibling tools with overlapping functionality, the description is incomplete. It does not explain the relationship to all_packages, user_packages, or system_packages, nor does it specify the return format (e.g., array of package name strings vs. objects). It also omits edge cases like both filters set to true or false. With no output schema and no annotation coverage, more context is needed for an agent to use it effectively and avoid confusion with siblings.

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 0% (no property descriptions), so the description must compensate. It explicitly explains both parameters: 'Accepts `user_installed_only` and `system_installed_only` as optional boolean parameters to filter the results.' This adds meaning beyond the schema, which only provides defaults. However, it does not clarify behavior when both are true or false, nor does it describe the output format, so it's not fully complete but does cover the basics.

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

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

The description clearly states the tool's function: 'Returns a list of all packages on the connected Android device' with optional filters. The verb 'Returns' and resource 'packages' are specific. However, it does not explicitly differentiate from sibling tools like all_packages, user_packages, or system_packages, which likely serve similar purposes, so it misses the sibling-differentiation aspect that would earn a 5.

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

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

The description gives no guidance on when to use this tool versus its alternatives. It does not mention any conditions or exclusions, nor does it reference sibling tools like user_packages or system_packages. An agent would have to infer from the parameter names alone when to prefer this over the more specialized sibling tools. This is a significant gap for a tool with multiple near-equivalent siblings.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It states that no parameters are required, which is useful. However, it doesn't disclose what the return value looks like (e.g., percentage, integer, string), whether it might fail (e.g., no device connected), or any side effects. For a simple read-only query, this is adequate but not rich.

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

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

The description is a single sentence that states the purpose and parameter requirement with zero waste. It is front-loaded with the action and resource, and the parameter note is concise. 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 zero-parameter read-only tool, the description is mostly complete. The main missing piece is the return format (e.g., percentage vs. raw level), which an agent might need to interpret the result. However, given the simplicity of the tool and the absence of an output schema, the description provides sufficient context for calling it correctly, though not for fully understanding the response.

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 confirms this with an empty properties object. The description explicitly states 'No parameters are required,' which adds clarity beyond the schema by confirming the agent doesn't need to supply anything. With 0 params, the baseline is 4, and the description meets 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 tool's function: returning the battery level of a connected Android device. It uses a specific verb ('Returns') and resource ('battery level'), which is unambiguous. It doesn't explicitly differentiate from siblings, but no sibling appears to perform a similar function, so this is acceptable.

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 context: it's for querying the battery level of a connected Android device. It doesn't explicitly state when to use it versus alternatives, but given the sibling list, no alternative tool serves this purpose. The lack of explicit exclusions is a minor gap, but the context is clear enough for an agent to select it appropriately.

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

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

With no annotations provided, the description carries the full burden. It states the tool 'returns a list of UI nodes', implying a read-only operation, but does not disclose limitations (e.g., behavior when nothing is focused, or whether an accessibility service is required). This is adequate for a simple query but leaves some behavioral context unspecified.

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

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

The description is a single concise sentence that states the core purpose upfront. It wastes no words and 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 parameterless read-only tool with no output schema, the description adequately covers what the tool does. It could clarify the expected output format or the meaning of 'focused', but given the simplicity and the sibling context, it is reasonably complete. The lack of explicit differentiation from get_current_ui_labels is a minor omission.

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

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

The input schema has zero properties and schema coverage is trivially 100%. The description explicitly notes 'No parameters are required', which is consistent but redundant. Since there are no parameters to explain, the baseline 3 applies—the description adds nothing beyond the schema.

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

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

The description states a specific verb ('Returns'), a clear resource ('list of UI nodes'), and context ('currently focused on the connected Android device screen'). This clearly differentiates it from sibling tools like get_current_ui_labels (which returns labels, not nodes) and input_* tools (which perform actions).

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention get_current_ui_labels or any other sibling, nor any exclusions or prerequisites. A tool like get_current_ui_labels may be similar but the description gives no hint about choosing between them.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It reveals the return type and node properties, but does not state whether the operation is read-only, what happens if no UI is present, or if any device state is required. This is partial transparency 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 concise sentences with no waste. The core purpose is front-loaded, and the additional property detail is brief and relevant. It earns its place 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?

For a simple getter with no parameters and no output schema, the description explains the return content adequately. However, it does not disambiguate from the sibling get_current_focused_nodes, nor does it mention edge cases like empty results or device screen state, leaving some context gaps for an agent.

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

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

The tool has zero parameters and an empty schema. The description explicitly states 'No parameters are required,' which is a helpful confirmation beyond the schema and aligns with the baseline 4 for zero-parameter tools, adding clear 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 a specific verb (returns) and resource (UI nodes on device screen), specifies scope (visible, text labels and content descriptions), and differentiates from the sibling get_current_focused_nodes by emphasizing 'currently visible' and 'focusing on text labels and content descriptions.'

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 like get_current_focused_nodes. It does not mention exclusions, conditions, or prerequisites, leaving the agent to infer 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?

No annotations are provided, so the description must disclose behavioral traits. It only says it returns a PID, without mentioning failure modes (e.g., if the package is not installed), device requirements, or output format. For a read-only query tool, this is a significant gap 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?

A single, focused sentence that states the operation and the required parameter without any filler. It is appropriately concise and 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?

Given that there are no annotations and no output schema, the description is thin. For a tool that likely interacts with an adb device, it should mention prerequisites (device connected), failure handling, and the output format. The description is not sufficient for an agent to call it correctly in 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 0%, and the description only restates that package_name is the name of the package to query. This adds little beyond the schema property title, so it does not compensate for the lack of schema descriptions.

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 it returns the PID for a given package name on a connected Android device. It does not explicitly differentiate from sibling tools like get_top_activity or is_installed, but the function's name (get_pid) and specific resource (package) make its 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 it (when you need a PID for a package), but does not explicitly state alternatives or when not to use it. It lacks exclusions or comparisons to sibling tools, so guidance is adequate 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 carries the full burden. 'Returns' implies a read-only operation and 'No parameters are required' is useful, but it does not mention side effects, connection requirements, or output format. The description is minimally sufficient for a simple getter.

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

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

A single sentence that front-loads the purpose and immediately states the input requirement. There is no redundant or extraneous content.

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

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

For a zero-parameter read-only tool, the description is adequately complete: it names the target resource and clarifies no inputs are needed. It could optionally specify the return shape, such as a map or raw text, but that is not essential for selecting or invoking this 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?

There are zero parameters and schema coverage is 100%, so the schema already fully defines the input surface. The description's explicit statement that no parameters are required reinforces this and helps prevent an agent from inventing arguments.

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?

Clearly states a specific verb ('Returns') and resource ('build.prop properties of the connected Android device'). This distinguishes it from sibling tools that handle packages, UI nodes, or device metrics.

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

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

Provides no guidance on when to use this tool versus alternatives. It only states that no parameters are required, which is not selection guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It accurately says the tool returns the serial number and requires no parameters, but it does not disclose behavior when no device is connected, the format of the returned value, or any error conditions.

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. Every word earns its place: the operation, the target, and the parameter expectation.

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 read-only tool with no output schema, this description covers the essential information needed to invoke and interpret the call. Minor gaps around failure cases are not material for such a simple 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 has zero properties and schema description coverage is 100%, so the baseline is 4. The description adds the explicit statement 'No parameters are required,' which clarifies that the tool is callable with an empty argument object.

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 operation ('Returns') and unique resource ('serial number of the connected Android device'), making the tool's purpose unmistakable even among device-info siblings such as get_battery_level, wm_density, and get_properties. The no-parameter note reinforces that this is a simple device identifier retrieval.

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 context is clear: use it to get the serial number of the connected Android device, and it requires no parameters. It does not explicitly explain when not to use it or name alternatives, but there are no closely interchangeable siblings for serial-number retrieval.

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 behavioral burden. It conveys a read-only list operation and explicitly states no parameters are required, but it does not disclose important behavioral details such as whether only pre-installed packages are included, whether a device connection is required, or how the returned list is ordered or formatted. For a simple getter this is adequate but not 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?

The description is a single sentence that front-loads the main action and target. 'No parameters are required' is somewhat redundant given the empty schema, but it is brief and reinforces the calling contract without adding meaningful noise.

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 list tool, the description provides the essential purpose and scope, but it does not position the tool relative to its many sibling package-listing tools. Without an output schema, a bit more detail about the returned list's contents or format would make the description more complete for an agent.

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

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

The tool has zero parametersable, and the input schema already documents this completely with an empty properties object. The description's statement that 'No parameters are required' is redundant but correct. Since there are no parameters to explain, the semantic baseline is high and the description does not need to add more.

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 ('Returns') and resource ('system-installed packages on the connected Android device'), so an agent can easily understand what the tool does. However, it does not explicitly distinguish itself from sibling tools like all_packages, user_packages, or get_all_packages, which limits clarity in the surrounding context.

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 the multiple sibling package-listing tools. Since siblings include all_packages, user_packages, system_packages, get_all_packages, and get_user_packages, the absence of alternative routing or exclusion criteria leaves the agent without enough information to confidently choose this tool.

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

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

With no annotations, the description carries the full burden. It communicates that the tool reads current device state by saying it 'returns' activities, but it does not disclose the return format, possible failure modes, or how 'on top' is defined. This is minimally adequate for a simple query tool but lacks richer behavioral detail.

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

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

The description is a single front-loaded sentence that states the core behavior and then confirms the lack of required parameters. There is no filler, redundancy, or unnecessary detail.

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-only tool, the description is mostly sufficient, but because there is no output schema it does not clarify whether the plural 'activities' implies a list, a stack, or a single value. It also does not address the ambiguity with the sibling get_top_activity, leaving some context incomplete.

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

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

The tool has zero parameters and the schema coverage is 100%, so there is little for the description to add. It explicitly states 'No parameters are required,' which reinforces the empty schema and meets the baseline for a parameterless tool.

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

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

The description clearly identifies the action ('Returns') and the resource ('activities currently on top on the connected Android device'). It is unambiguous about what the tool reports, but it does not differentiate itself from the closely named sibling 'get_top_activity', so it misses the top score.

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 instead of alternatives such as get_top_activity or other UI inspection tools. The only usage-related note is that no parameters are required, which is already evident from the empty schema.

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

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

No annotations are provided, so the description carries the full burden. It clearly states the core behavior (returns the top activity) and implies a read-only operation, but it does not disclose potential failure modes, permission requirements, or what happens when no activity is on top. For a simple getter this is adequate but not rich.

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

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

The description is two short sentences, with the core functionality front-loaded and no filler. The second sentence is arguably redundant with the schema, but it is brief and harmless.

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

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

For a simple tool with no parameters and no output schema, the description covers the essential purpose and return value. It does not describe the return format (e.g., a string or object), but the phrase 'returns the singular activity' gives enough context for an agent to infer a single activity identifier.

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?

With 0 parameters, the baseline is 4. The description reinforces the input contract by explicitly stating 'No parameters are required,' which adds a small confirmation beyond the empty schema.

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

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

The description uses a specific verb ('returns') and resource ('the singular activity currently on top on the connected Android device'), and the qualifier 'singular' clearly distinguishes it from the sibling tool get_top_activities. An agent can understand exactly what this tool does without opening 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 it by stating it returns the singular top activity, which contrasts with the plural sibling, but it does not explicitly say 'use this when you need only one activity' or mention alternatives. There is no exclusion or context for when to prefer this over get_top_activities.

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 tool returns a list, implying a read-only operation, but does not explicitly mention safety (e.g., no modification) or any edge conditions like device connectivity. It is adequate for a simple read operation but lacks depth.

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 conveys the purpose and the lack of parameters. Every word earns its place; there is no fluff or redundancy.

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

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

Given the tool's low complexity (no parameters) and no output schema, the description is nearly complete. It clearly states what the tool returns and from where. It could optionally note that it is read-only, but the lack of annotations makes this minor gap acceptable. It does not specify the exact format of the list (e.g., package names only), but this is not critical for a list-returning 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 tool has zero parameters, and the description correctly notes that no parameters are required. This matches the schema (empty properties) and adds no extra semantic burden. The baseline for zero parameters is 4, and the description satisfies it without introducing ambiguity.

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

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

The description clearly states the tool's function: it returns a list of user-installed packages on the connected Android device. This is a specific verb and resource, and the qualifier 'user-installed' distinguishes it from sibling tools like system_packages and all_packages.

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 its siblings (e.g., get_all_packages, user_packages, system_packages). It only states that no parameters are required, which is about invocation, not usage context. No exclusions or alternative routing is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says it 'simulates a back button event' but does not disclose potential effects like navigating to a previous screen, closing the keyboard, exiting an app, or that the behavior may be application-dependent. This is a meaningful gap for an input-injection 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 a single, front-loaded sentence with no filler. It states the action and the parameter requirement, and 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 zero-parameter action with no output schema, the description is largely complete: it identifies the action, the target device, and confirms no parameters. A little more context about typical side effects would improve completeness, but nothing essential is missing for invoking it.

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?

With zero parameters and 100% schema coverage, the schema already shows no properties. The description adds explicit confirmation that no parameters are required, which removes any ambiguity. This adds value beyond the empty schema, so a 4 is appropriate.

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

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

The description states a specific verb ('Simulates') and a clear resource ('a back button event on the connected Android device'). It is distinguishable from siblings like input_home and input_tap because it specifically targets the back button. However, it does not explicitly contrast itself with input_keyevent, which could also send a back keycode.

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

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

No guidance is given about when to use this tool over alternatives such as input_keyevent or other input simulation tools. The description only states what it does and that it requires no parameters, leaving an agent to infer when it should be selected.

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 it 'simulates' an event, but does not disclose that this may be restricted to Android devices or whether it affects the app under test. It also doesn't note potential side effects like minimizing the current app.

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 waste, and the key action is front-loaded. Efficient and to the point.

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, the description is mostly complete. However, it lacks details on the device platform (e.g., only Android) and the expected device state (e.g., device unlocked), which are useful for an agent to call it correctly in a broader context.

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

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

The tool has zero parameters, so the schema is complete and the description correctly states 'No parameters are required.' The description adds minimal but sufficient context 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?

States a specific verb ('simulates') and resource ('home button event') with clear scope ('on the connected Android device'). Distinguishes from siblings like input_back and input_keyevent by naming the exact button.

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

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

Provides no guidance on when to use this tool versus alternatives. For example, it doesn't note that it only works on Android or that it should be used to exit to the home screen, nor does it mention alternatives like input_keyevent for system keys.

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 states the action itself but does not disclose side effects, permission requirements, whether the event is inject-and-forget, whether key repeat or key hold is supported, or what the tool returns.

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

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

The description is concise and front-loaded with the primary action. The second sentence is slightly redundant since the schema already marks keycode as required and the term 'keycode' in the first sentence already implies its role.

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

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

For a single-integer-parameter tool, this is minimally viable: an agent can infer it sends a key event using a keycode to the device. However, it lacks keycode domain knowledge, output behavior, and sibling differentiation, leaving room for wrong invocation without additional 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%, so the description must compensate. It only restates that keycode is the keycode of the key to simulate, which adds little beyond the parameter name. It does not explain valid Android keycode values, constants, ranges, examples, or how the keycode maps to device behavior.

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

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

The description clearly states the verb and resource: simulates a key event with a keycode on the connected Android device. It distinguishes from tap/swipe/text siblings, but does not explicitly differentiate itself from related siblings like input_press, input_back, or input_home.

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 generic keyevent tool versus specific siblings like input_back, input_home, input_press, or other input methods. There is no mention of when not to use it or what conditions favor this tool over alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains the basic action but does not mention keycode validity, whether a full press-and-release sequence is simulated, device-connection prerequisites, or any side effects. This is minimal disclosure for an unannotated mutating input 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 short and front-loaded with the primary action in the first sentence. The second sentence is somewhat redundant because it restates the required parameter, but the overall structure is efficient and contains no 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 one-parameter tool with no output schema, the description is adequate for a basic invocation. However, it lacks sibling differentiation, especially from input_keyevent, and does not specify acceptable keycode values. These gaps make the description only minimally complete rather than fully contextual.

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 0% because the schema only provides the parameter name and integer type. The description adds the meaning that keycode is the keycode of the key to press, which is helpful but mostly restates the parameter name. It does not provide valid Android keycode examples or constraints, leaving an agent to rely on external knowledge.

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 simulates a key press event with a given keycode on a connected Android device, so the verb, resource, and target are identifiable. However, it does not distinguish input_press from the closely related sibling input_keyevent, so it cannot earn the top score for sibling differentiation.

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

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

There is no guidance about when to use this tool instead of input_keyevent, input_tap, or input_text. The description only states that the keycode parameter is required, which is already in the schema, and offers no exclusions or alternative-routing 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 available, the description must carry the behavioral disclosure burden, but it only states that the tool simulates a rolling gesture and requires distances. It does not mention practical behavioral details such as units, sign conventions, whether this is a trackball-style roll, or whether the gesture has side effects on the device, leaving notable transparency gaps.

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

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

The main description is one focused sentence that leads with the action and parameter semantics, earning its place. The phrase 'Requires dx and dy parameters' is somewhat redundant with the schema's required fields, but the description is still appropriately sized and 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 two-parameter tool with no output schema, the description covers the essential action and parameter meanings, so it is minimally viable. It lacks broader context such as error conditions, whether the gesture triggers scrolling, or relationship to input_swipe, making it only partially complete.

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

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

Schema description coverage is 0%, so the description's phrase that dx and dy are 'rolling distances in the x and y directions' adds real meaning beyond the bare schema fields. However, it omits useful specifics like units, allowed ranges, sign meaning, or how the values map to on-screen movement, so it only partially compensates for the lack of schema descriptions.

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 ('simulates a rolling gesture') and a target ('connected Android device'), making the tool's purpose clear. It does not explicitly contrast itself with sibling tools such as input_swipe, so it misses the full differentiation step, but the verb and resource are identifiable enough to understand its function.

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 the tool is used: when a rolling gesture with dx/dy is needed, but it provides no explicit guidance about when to choose input_roll over the many related sibling tools such as input_swipe or input_tap. It offers no exclusions or alternative conditions, so an agent still has to infer the right context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the action simulates a swipe, but does not mention prerequisites like screen state or device connection details, potential side effects, failure modes, or what happens when duration is omitted.

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 front-loaded, stating the action before the parameter details. It is a single sentence with no filler, though the explicit 'Requires x1, y1, x2, y2' listing slightly overlaps with the schema's required fields.

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

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

Given that this is a relatively simple swipe gesture tool with five parameters and no output schema, the description covers the essential calling contract: coordinates, duration, and the target device. It could be improved by clarifying coordinate units and duration default behavior, but it is broadly sufficient 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 parameters. It does add meaningful semantics: x1/y1/x2/y2 are labeled as start and end coordinates, and duration_ms is specified as an optional duration in milliseconds. However, it omits details like coordinate units or bounds, and partially repeats schema 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 is clear and specific: it simulates a swipe gesture from (x1, y1) to (x2, y2) with optional duration on the Android device. The verb and resource are well defined, though it does not explicitly differentiate itself from sibling input tools like input_tap or input_roll.

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

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

There is no guidance on when to use this tool versus alternatives such as input_tap or input_roll. The description only explains what the tool does, leaving the agent to infer usage context without exclusions or decision criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the core effect (simulating a tap) and the target (the screen), but doesn't disclose any additional behavioral details such as coordinate-system origin, bounds, device screen state requirements, or error behavior. It meets the basic bar but adds little beyond a restatement of the function.

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 action is front-loaded and the parameter clarification is directly relevant. 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 simple two-parameter tool with no output schema, the description provides enough information for an agent to invoke a tap correctly. The only notable gaps are the lack of coordinate-system details and differentiation from input_press, but these are minor for such a basic interaction.

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 only integer fields named X and Y with 0% description coverage. The description compensates minimally by explicitly stating that x and y are the coordinates of the tap, which is meaningful. However, it doesn't mention units, valid ranges, or whether coordinates are in pixels or relative to the screen origin.

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 ('Simulates a tap gesture'), a clear resource ('connected Android device screen'), and the location (specified x,y coordinates). This clearly differentiates it from sibling tools like input_swipe and input_roll, which involve different 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 gives no explicit guidance on when to choose this tool over alternatives such as input_press or input_swipe. It implies usage by describing what a tap is, but it doesn't provide context, exclusions, or routing criteria. An agent must infer when a tap is the right action.

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?

There are no annotations, so the description carries the burden of behavioral disclosure. It clearly states that the tool simulates typing into the focused field, but it does not mention failure behavior, side effects, IME interaction, or what happens if no field is focused.

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

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

The description is concise and front-loaded with the main action. The second sentence about requiring the `text` parameter is slightly redundant given the schema already marks it as required, but it does add semantic clarification.

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 no output schema, the description provides enough context to call it: target, action, and parameter meaning. It could be slightly more complete by noting prerequisites or limitations, but it is not materially incomplete.

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

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

The schema provides only the parameter name and type, with no description coverage. The tool description compensates by explaining that `text` is the string to be typed, giving the single parameter its essential meaning.

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

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

The description states a specific action—typing text—and names the target resource: the currently focused field on the connected Android device. This clearly distinguishes it from sibling input tools like input_keyevent, input_tap, and input_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 text needs to be typed into a focused field. However, it does not explicitly advise against alternatives or mention cases where another input tool would be more appropriate, leaving some usage selection to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It says only 'installs an APK,' which signals a mutating operation, but it does not mention side effects, permissions, overwrite behavior, or how success or failure is communicated.

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 front-loaded: it states the action in the first sentence and immediately addresses the sole parameter in the second. There is no filler or redundant restatement.

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

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

For a single-parameter tool, the description covers the core action and required argument adequately. But since there is no output schema and no annotations, it omits return behavior, error cases, path-location details, and side effects, leaving moderate 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 description adds meaning beyond the schema by explaining that apk_path is 'the path to the APK file to be installed.' However, it leaves ambiguity about whether the path refers to a location on the host machine or the device, and does not clarify expected path format.

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 ('Installs an APK') and target ('connected Android device'), making the tool's purpose immediately understandable. It does not explicitly distinguish it from sibling tools, but the verb-resource pair is specific enough.

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

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

No guidance is given about when to use this tool versus alternatives or when not to use it. The description implies installation intent but provides no context about prerequisites, fallback tools, or exclusions.

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

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

No annotations are provided, so the description must carry the full burden of disclosing behavior. It states the action but does not explicitly confirm that the operation is read-only and non-destructive, nor does it mention any side effects or prerequisites (e.g., whether the package must be a valid app identifier). For a check operation, the lack of an explicit 'does not modify the device' statement leaves uncertainty, especially since the tool could be expected to perform queries.

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 two clauses in a single sentence. It front-loads the primary purpose and then clarifies the parameter. However, it redundantly mentions that the parameter is required ('Requires the `package_name` parameter') when the schema already marks it as required, adding slight bloat. Overall, it is efficient and well-ordered.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers the core purpose and parameter meaning. However, it does not mention the return value or result format (e.g., whether it returns a boolean), which is essential for an agent to interpret the outcome. It also lacks guidance on edge cases like system vs user packages, which could be inferred from siblings but would strengthen completeness. For a low-complexity tool, this is a moderate 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 schema description coverage is 0% – the schema only labels the parameter as 'Package Name'. The description adds semantic meaning by explaining that package_name is 'the name of the package to check', which clarifies what the string represents. While it does not elaborate on formatting or validation, it goes beyond the bare schema for a single required parameter, so it earns a 4.

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 ('Checks') and resource ('if the specified package is installed on the connected Android device'), and it distinguishes from sibling tools like install_apk or all_packages by focusing on a single package existence check. The sentence is unambiguous and immediately tells an agent what this tool does.

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

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

The description implies when to use the tool (when you need to verify a single package's presence), but it does not explicitly contrast with alternatives such as all_packages, user_packages, or get_all_packages, nor does it state when not to use it. Given the many package-related siblings, more explicit routing would improve clarity, but the core intent is understandable.

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 present, the description carries the full behavioral burden, and it does communicate a read-only state check with no side effects. However, it does not explicitly state the return type or behavior when no device is connected or when the keyboard state cannot be determined.

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 clean sentence, front-loads the purpose, and adds the parameter note without any filler or redundancy.

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

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

For a parameterless, single-purpose state check, the description is nearly complete and provides enough to invoke correctly. It only lacks an explicit return-semantics or error-case note, which is a minor gap.

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

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

The tool has zero parameters, and the schema already documents this completely. The description adds the useful confirmation that no parameters are required. This matches the zero-parameter baseline.

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

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

The description clearly states the action with a specific verb ('Checks if the virtual keyboard is currently open on the connected Android device') and identifies the exact resource being queried. It also distinguishes itself from all sibling tools, none of which are keyboard-state checks.

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 usage context is implied: use this tool when an agent needs to know whether the virtual keyboard is open. There are no explicit when-not-to-use guidance or explicit alternatives, though no sibling tool appears to serve the same purpose.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the primary action, but does not explain what happens if the app is already running, whether the app is brought to the foreground, what error behavior occurs for a missing package, or any side effects.

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. It front-loads the action and device context, and the redundant 'requires package_name' sentence is short and harmless.

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 tool with a simple action, the description provides the minimum needed to attempt a call. However, without annotations, output schema, or guidance on expected return/failure states, it is only minimally viable rather than complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds only a near-tautological explanation that package_name is the package name of the app to be launched, without format, examples, constraints, or guidance on how to find the package name.

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

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

The description states a specific verb ('Launches the app'), a specific resource ('the app with the specified package name'), and the device context ('on the connected Android device'). It is clear, though it does not explicitly differentiate itself from related sibling tools like install_apk or is_installed.

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, no exclusions, and no conditions such as 'use this when the app is already installed.' It only restates that the package_name parameter is required.

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. 'Returns' implies a read-only operation and 'connected Android device' implies a prerequisite, but it does not state side effects, output format, or failure behavior if no device is connected. It is minimally transparent but not rich.

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

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

A single sentence that states the action, the resource, and the invocation requirement without any filler. The key information is front-loaded and every word is useful.

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 read-only tool with no output schema, the description is mostly complete: it identifies the resource and the target device. It could add the exact return shape or error conditions, but for such a simple tool the current coverage is adequate.

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?

There are zero parameters and the schema is an empty object with 100% coverage. The description confirms 'No parameters are required,' which adds a small amount of guidance beyond the schema and earns the zero-parameter baseline.

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

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

The description names a specific verb ('Returns'), a specific resource ('device overlay configuration properties'), and a clear target ('the connected Android device'). It is distinct from sibling tools like get_properties or get_battery_level, which are more generic or target different data.

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 says no parameters are required, which helps invocation, but it gives no guidance on when to choose this tool over siblings or when not to use it. There are no exclusions, alternatives, or context cues beyond the tool's own behavior.

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

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

No annotations are provided, so the description carries the full burden. It states the required parameters and their roles, but does not disclose behavioral traits such as whether the local file will be overwritten, whether the remote path must exist, error conditions, or permission requirements. For a file transfer operation, this is a notable 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 that front-loads the action and then explains the parameters. Every word earns its place; there is no redundancy or filler.

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

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

For a simple two-parameter file transfer tool, the description covers the core purpose and parameter semantics. However, with no annotations and no output schema, it lacks behavioral details like overwrite behavior, error handling, and return value. It is adequate but not complete for an agent that needs to handle failures or side effects.

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 does explain that 'remote' is the path on the device and 'local' is the path on the local machine, which adds meaning beyond the bare schema property names. However, it does not specify path formats, whether directories are supported, or any constraints on the paths.

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 ('Pulls a file'), the source ('from the connected Android device'), and the destination ('to the local machine'). It distinguishes itself from the sibling push_file by direction, and the verb 'pull' is specific to this operation.

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 this tool: when you need to transfer a file from the device to the local machine. It does not explicitly state when not to use it or mention alternatives like push_file for the reverse direction, but the direction is clear enough for an agent to infer the correct 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 behavioral disclosure. It states the transfer direction but does not mention whether existing files on the device are overwritten, whether permissions are required, or what happens if the remote path does not exist. For a mutation-related tool, this is a significant 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 two sentences with no filler: the operation is stated first, followed by the parameter mapping. Every word serves a purpose, and the structure is front-loaded with 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?

The tool is simple with fully described parameters and no output schema, so the description covers the basics of invocation. However, lacking annotations, it omits behavior around overwrites, error conditions, and prerequisites. It is minimally viable but not fully complete for an agent facing a real device state.

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, and it does. It explicitly maps 'local' to the file path on the local machine and 'remote' to the device path, adding meaning beyond the bare schema properties. It could add more detail about path formats, but the core semantics are clearly conveyed.

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

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

The description names a specific verb ('Pushes') and resource ('file from the local machine to the connected Android device'), making the operation unmistakable. The directionality of the transfer clearly distinguishes it from sibling tools like pull_file. No ambiguity remains 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 description implies use when a file needs to be copied from the local machine to the device, but it does not explicitly mention alternatives such as pull_file for the reverse direction or execute_adb_shell for shell-based transfer. Usage context is clear but not contrasted with siblings.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It states it returns a list of package names, which is clear, but does not mention any side effects (unlikely) or permission requirements. It is a simple read operation, and the description's simplicity is adequate, but more could be added about the format or any 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?

The description is a single sentence, front-loads the core purpose, and wastes no words. It is perfectly concise for a zero-parameter tool.

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

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

For a tool with no parameters and no output schema, the description is sufficient: it tells the agent what it returns (list of system package names) and that no input is needed. The only minor gap is not naming sibling tools to help differentiate, but that is not critical for invoking 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 no parameters, and the schema is empty. The description confirms that no parameters are required, which adds value over the empty schema by telling the agent that no input is needed. Since there are no parameters to explain, the description fully covers parameter semantics.

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

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

The description clearly states the tool returns a list of system application package names, which is specific and distinct from siblings like all_packages and user_packages. However, it does not explicitly name those siblings, so differentiation is implied rather than explicit.

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 says 'No parameters are required' which implies it is a simple query, but does not explicitly state when to use this tool as opposed to all_packages or user_packages. The context of 'pre-installed apps' gives some guidance, but no explicit alternatives are named.

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

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

No annotations are present, so the description must disclose behavioral traits. It only says 'uninstalls' without noting the destructive nature (permanent removal, data loss), potential permission requirements, or behavior for system packages. This is a significant gap for a mutation 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 concise sentences, front-loading the core action and then clarifying the parameter. There is no fluff, and it reads naturally.

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, the description covers the essential purpose and parameter. However, it omits any note about side effects, error conditions, or constraints (e.g., cannot uninstall system apps), which an agent would benefit from knowing. It is adequate but not thorough.

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 parameter with 0% description coverage. The description adds meaning by specifying that package_name is 'the name of the package to uninstall,' but it does not provide format details (e.g., fully qualified name) or how to obtain it. It is minimal but present.

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 and resource: uninstalls a package from a connected Android device. It is immediately distinct from sibling tools like install_apk or is_installed, so the agent knows exactly what action this tool performs.

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

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

The description provides clear context for the action (uninstalling a package) and implicitly differentiates from install_apk and is_installed. It does not explicitly list when not to use or alternatives, but the uniqueness of the action makes the usage obvious.

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

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

With no annotations provided, the description carries the full burden. It clearly states the operation returns a list of package names and requires no parameters, which covers the core behavior. It doesn't disclose additional details like whether the list could be empty or any device-connection prerequisites beyond 'connected Android device.'

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

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

The description is a single concise sentence that front-loads the core purpose and includes the only usage note (no parameters). There is no wasted wording or irrelevant detail.

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, list-returning tool without an output schema, the description provides enough to invoke it correctly. A reader knows what it returns and that no arguments are needed. The only minor gap is that it doesn't distinguish it from the similar get_user_packages sibling.

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?

There are zero parameters and the schema coverage is effectively 100%, so the description needs to add little. It explicitly notes 'No parameters are required,' which reinforces the schema and leaves no ambiguity.

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 ('Returns'), a specific resource ('list of user-installed application package names'), and a clear scope ('on the connected Android device'). The 'user-installed' qualifier helps distinguish it from system_packages/all_packages, though it doesn't explicitly differentiate from the similarly named get_user_packages sibling.

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

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

The description clearly states that no parameters are required, implying this is a simple read-only call. However, it does not explicitly say when to choose this tool over all_packages or system_packages, nor does it mention alternatives.

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

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

With no annotations, the description carries the burden of explaining behavior. It signals a non-mutating read by saying 'Returns', but it does not disclose output units (e.g., dpi), possible failures if no device is connected, or the fact that this is an ADB-backed query. For a no-arg read command this is acceptable but not rich.

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

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

One concise, front-loaded sentence states both the function and the lack of parameters. Every word earns its place; there is no redundant boilerplate.

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-only tool, the description covers the core need. The main gap is that no return format or units are specified, which would matter for downstream logic, but overall an agent can safely invoke it.

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?

There are zero parameters and the schema covers 100% by declaring an empty properties object. The description additionally clarifies that no parameters are required, which removes any temptation to invent arguments.

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 ('Returns') and a clear resource ('the screen density of the connected Android device'), distinguishing it from sibling tools like wm_size, cpu_count, and get_battery_level. The zero-parameter note removes any ambiguity about invocation.

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

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

It clearly establishes the context: call this tool when you need the Android device's screen density, and it explicitly states no input is required. It does not spell out when not to use it or name alternatives, but for a trivial read-only query the 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?

With no annotations, the description carries the full burden. It discloses that the operation is read-only through 'Returns' and implicitly indicates no side effects. It does not, however, describe the return format, units, or what happens if no device is connected.

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 purpose is front-loaded, and stating that no parameters are required is a useful clarification with zero waste.

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 read-only query tool this is nearly complete: an agent knows what the tool returns and how to invoke it. The only minor gap is not specifying the expected format of the screen size, but the low complexity and empty schema keep it sufficient.

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

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

The input schema is empty and the description reinforces that no parameters are required. Since there are zero parameters, the baseline is 4, and the description fully satisfies the need without adding unnecessary detail.

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

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

The description states a specific verb ('Returns'), a specific resource ('screen size of the connected Android device'), and defines the scope (screen size specifically, not density or other device properties). This clearly distinguishes it from siblings like wm_density and get_properties.

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 makes the invocation trivially clear by stating 'No parameters are required.' However, it does not explain when to prefer this tool over related device-info siblings, nor mention any alternatives or exclusion cases.

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