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

No annotations are provided, so the description carries the full burden. It does disclose the returned content (version string plus resolved path) and implicitly signals a side-effect-free, read-only query, but it says nothing explicit about whether the adb binary is probed, what happens if adb is missing, or whether a device connection is required. Adequate but shallow.

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 front-loaded sentence with zero filler; both facts the caller needs are in the first clause. Nothing is repeated from the schema or elsewhere.

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 no-parameter, output-schema-backed informational tool, the description is complete: it says what is returned and which side (host vs device) it applies to. Return-value formatting is already covered by the output schema, so no further detail is required.

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 takes zero parameters, so per the rubric the baseline is 4. Nothing in the description contradicts or misrepresents the 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?

States a specific verb ('Return') and precisely names the two resources produced: the host adb client version string and the resolved adb path. The phrase 'host adb client' disambiguates it from device-side siblings like get_prop, get_device_properties, or get_state, none of which report client-side binary information.

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 when-to-use, when-not-to-use, or alternative named. Usage is only implied by the description itself (call it when you need the adb client version or its resolved path), which is the definition of implied guidance. For a trivial zero-argument informational tool this is tolerable, but nothing is stated.

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 implies a read-only operation by saying 'Return', but does not state permissions, whether it runs on a specific device, how the optional serial parameter affects behavior, or what happens on failure.

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

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

The description is a single front-loaded sentence with no wasted words. Its brevity is appropriate for a simple status lookup, though it is arguably too terse to be fully 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?

The tool has two parameters and no annotations, and an output schema exists so return-value details are not required. However, the description omits guidance on the serial parameter, usage context, and behavioral constraints, leaving meaningful gaps for an agent invoking it correctly.

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

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

Schema description coverage is 0%, so the description should compensate for undocumented parameters. It only indirectly references the required package parameter and gives no explanation of the optional serial parameter or its default/null 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 states a clear verb and resource: it returns package, pid, and running status for a package. This distinguishes it from broad listing tools like list_packages, though it does not explicitly differentiate itself from get_package_info or other status-related siblings.

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

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

There is no guidance on when to use this tool versus alternatives such as get_package_info, list_processes, or get_state. The description merely states what is returned and leaves the agent to infer the appropriate context.

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

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

With no annotations, the description carries the full burden; it usefully discloses the performance characteristic (slow, minutes) and that the output is a zip written to local_path. However, it omits whether root/adb authorization or a specific device state is required, and gives no sense of size or failure 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?

A single front-loaded sentence with the destination first and the timing caveat parenthetically; every clause earns its place with no redundancy.

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

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

An output schema exists so return values need not be described, and the description covers destination and latency. Still missing for a device-capture operation are authorization/root prerequisites and the meaning of the unexplained serial parameter.

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% for 2 parameters. The description clarifies that local_path is the zip destination, adding value, but the optional 'serial' parameter is left entirely unexplained and must be inferred from sibling patterns.

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 ('Capture') and resource ('full bugreport zip') plus the destination parameter ('local_path'), which an agent can distinguish from logcat_* and get_crash_log siblings. It is clear but stops short of explicitly contrasting itself with those narrower diagnostic siblings.

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

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

The '(slow; can take minutes)' note hints at a cost-based tradeoff but gives no explicit when-to-use guidance and never names alternatives like get_crash_log or get_anr_traces that produce faster, narrower diagnostics.

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 usefully discloses the return channel (inline PNG) and the conditional side effect of save_path, but says nothing about device/serial targeting, failure behavior when no device is connected, latency, or whether capture is safe/non-destructive.

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

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

Three short sentences with the core action and return value front-loaded, then the optional side effect, then the intended use case. No filler and nothing buried.

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

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

For a two-parameter tool with no output schema and no annotations, the description covers the important output channel and the save_path side effect, which is genuinely helpful. It is still incomplete on the serial parameter and on error/no-device behavior.

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%, so the description must compensate for both parameters. It explains save_path well ('also writes the PNG there'), but serial is never mentioned, leaving an agent to guess its meaning and default behavior.

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

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

The description names a specific verb and resource ('Capture a screenshot') and adds the return format ('inline PNG image'), which implicitly separates it from capture_screen_to_file and capture_screen_base64. It stops short of naming those siblings explicitly, so an agent must still infer which capture variant to pick.

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 gives a usage context ('Ideal for an observe->decide->tap loop / OCR'), which is more than nothing. However, it never states when NOT to use it or points to the closest alternatives (capture_screen_to_file, capture_screen_base64), so routing between the three capture tools is left 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?

No annotations are provided, so the description carries the full burden. It does disclose the return payload keys (format, bytes, base64), which is useful, but says nothing about device selection, permission/auth requirements, or what happens when 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 that states the action and the return shape with no filler. Nothing is wasted.

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

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

The tool is simple and an output schema exists, so return values needn't be re-explained. However, with zero annotations and an entirely undocumented 'serial' parameter, the description leaves device targeting and prerequisites unstated.

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 is one parameter, 'serial', with 0% schema description coverage, and the description does not mention it at all. It neither explains that it selects the target device nor what the default (null) resolves to, so it does not compensate for the schema gap.

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

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

States a specific verb and resource ('Capture a screenshot') and specifies the return payload shape ({format, bytes, base64}). The trailing clause implicitly distinguishes it from the inline-image variant (capture_screen), but does not name that sibling explicitly.

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?

Gives a clear selection condition: use when 'a raw base64 payload is preferred over an inline image.' This is a usable when-to-use rule, though it never names the alternative tool (capture_screen) or the file variant (capture_screen_to_file), leaving the routing partly inferential.

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

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

With no annotations, the description carries the full burden, and it does disclose the return shape ({status, path, bytes}) and confirms no inline image is returned. However it says nothing about whether an existing file at save_path is overwritten, whether parent directories are created, or what happens if the capture fails.

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 tight sentence plus a short parenthetical discriminator; the output artifact and the routing hint are front-loaded with zero wasted prose.

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?

An output schema exists so return details are covered, and the description adds the key behavioral fact (file-only, no inline image) plus the destination parameter. The only real gap is the undocumented `serial` parameter and file-overwrite behavior.

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 adequately explains save_path (the destination of the capture) but says nothing about `serial`, leaving the device-selection/default behavior undocumented in both schema and description.

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

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

States a specific verb and resource ('capture a screenshot and save it to save_path') and names the produced artifact. It also implicitly separates itself from the inline-image siblings by saying 'no inline image', though it never names capture_screen or capture_screen_base64 directly.

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?

'use when you only need the file' gives an explicit selection condition that routes the agent away from the inline-image variants. No exclusions or sibling names are given, but the criterion is concrete enough to choose correctly.

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

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

With no annotations, the description carries the full burden, and it does disclose the destructive nature and what is wiped (saves/cache/prefs). However, it omits whether root is required, whether the app must be stopped first, and whether the operation is irreversible or prompts for confirmation.

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 with zero filler; the destructive warning is embedded where it is immediately visible rather than buried.

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?

An output schema exists, so return values need not be described, and the destruction warning covers the biggest risk. Still missing for a mutation tool with no annotations are the serial parameter's meaning and any operational prerequisites or post-state behavior.

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% for two parameters. The description conveys that 'package' identifies the target, but the 'serial' parameter (device selection) is entirely unexplained in both schema and description, so the description does not compensate for the coverage gap.

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

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

States a specific verb ('clear') and resource ('ALL app data for a package'), and the parenthetical 'wipes saves/cache/prefs' sharpens the scope beyond a generic 'clear'. It does not explicitly differentiate from close siblings like uninstall or force_stop, which an agent might reasonably confuse with data wiping.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as uninstall (removes the app) or force_stop (stops it). The agent must infer that this is the reset-to-fresh-install operation from the name alone.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose that this is a destructive bulk removal of both forward and reverse rules, which is useful. However, it says nothing about required permissions/root, reversibility, or effects on active connections.

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 short sentence, front-loaded with the verb and the scope-critical word 'ALL'. Nothing extraneous.

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?

An output schema exists, so return values need not be described. But for a destructive, no-annotation tool with an undocumented parameter, the description leaves gaps around device targeting and operational prerequisites.

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% for the single 'serial' parameter, so the schema provides no meaning. The description only hints at device targeting via 'for the device' and never explains what serial does or that it defaults to null (current/default device).

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 (remove/clear) and resource (forward and reverse rules), and the scope qualifier 'ALL' distinguishes it from the single-rule siblings remove_forward and remove_reverse. It doesn't name those siblings explicitly, so differentiation is implied rather than stated.

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?

'ALL' implies the bulk-clear use case versus individual removal, but there is no explicit statement of when to use this instead of remove_forward/remove_reverse or list_forwards, and no prerequisites or exclusions are given.

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 behavioral burden, yet it discloses nothing about failure modes (unreachable host, timeout), whether an adb server must be running, authentication requirements, or whether this mutates persistent device state. The 'adb connect' passthrough hints at a network handshake but no operational detail is given.

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 compact line with the underlying command and purpose front-loaded; nothing is wasted and no filler sentences dilute it.

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?

An output schema exists, so return values need not be explained, and the tool is simple with one parameter. Still, for a network-connection operation with zero annotations, the description omits failure behavior and preconditions an agent would want before calling 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 0% schema description coverage, the description must compensate for the single 'host_port' parameter. It does add the crucial 'ip:port' format hint, which is genuinely useful, but stops short of documenting port defaults, address syntax edge cases, or IPv6 handling.

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 (attach) and resource (network device) and lists concrete examples (WSA, emulator, wireless), so an agent understands this connects to a device over the network. It does not explicitly differentiate from the sibling 'disconnect', which is its direct inverse, but the purpose itself is unambiguous.

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

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

The phrase 'attach a network device' implies the usage context (network-attached targets rather than USB/local), which is meaningful given the many device-management siblings. However, it never states when-not to use it or names an alternative, leaving the agent to infer that 'disconnect' is the inverse and 'get_devices' checks the result.

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 behavioral burden and does disclose two important traits: the operation is DESTRUCTIVE and it refuses obviously dangerous roots like '/', '/system', '/data'. It stops short of covering irreversibility or the root/permission requirements of the as_root path.

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

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

Two sentences, front-loaded with the core operation, with the destructive warning and guardrail surfaced immediately. 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?

An output schema exists, so return values need no explanation. For a destructive, unannotated file operation, the description covers the key safety signal and refusal behavior but omits permission/root semantics and irreversibility, leaving gaps an agent would want filled.

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% across 4 parameters, so the description must compensate. It only clarifies recursive=True; the meaning of remote, serial, and especially as_root (root escalation requirements) is left undocumented in both schema and description.

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

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

States a specific verb and resource ('Delete a device file or ... directory') and scopes it to device files, distinguishing it from the many app-management and I/O siblings (write_file, pull, push, make_dir). An agent can identify the operation immediately.

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?

Usage is implied by the description and the recursive flag is explained, but no alternatives are named (e.g., uninstall or clear_app_data for app data) and no prerequisites are stated for the as_root path. It does hint at a guardrail for dangerous roots, which is closer to behavior than usage guidance.

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

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

With no annotations, the description carries the full burden. It does disclose one meaningful behavior — that omitting host_port disconnects ALL devices, which is an important blast-radius fact. However, it says nothing about whether the device must be connected, error behavior, or reversibility (that reconnection requires `connect`).

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

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

One sentence, no filler, and the critical default behavior is placed immediately after the core action. Nothing is wasted or buried.

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?

An output schema exists, so return values need no explanation, and a single-parameter tool needs little else. The description covers the action and the null-default case; only error/prerequisite behavior is missing, which is a minor gap at this complexity level.

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

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

Schema description coverage is 0% and the schema only labels the field "Host Port" with a null default, so the description does the real work: it identifies host_port as the target device and explains that null means disconnect everything. That is exactly the semantics an agent needs and it goes 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 (disconnect) and resource (network device), and the mention of `adb` grounds it in the tool family. It doesn't explicitly name `connect` as its counterpart sibling, but the operation is unambiguous and distinguishable from the other 80+ tools.

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

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

The parenthetical explains the omitting-host_port case, which is a usage condition, but it is really a parameter behavior note rather than guidance on when to pick this tool over `connect` or when disconnection is appropriate. Usage is implied rather than stated.

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 does disclose one meaningful behavioral trait beyond the schema: that drag uses a longer default duration than swipe. However, it says nothing about the serial parameter's effect (target device), how duration_ms interacts with the 'default', or whether the gesture can fail/miss, leaving real gaps for a no-annotation gesture 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?

Two short sentences with the gesture and endpoints front-loaded, followed by the alias relationship. No filler, though the parenthetical '(slow swipe)' is redundant with 'drag'.

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?

An output schema exists so return values need not be explained. Still, for a 6-parameter gesture tool with zero annotation coverage and zero schema descriptions, the description leaves the serial and duration_ms parameters unexplained and gives no failure/fidelity context, which is only minimally 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?

Schema description coverage is 0% and there are 6 parameters, so the description must compensate and largely does not. It covers only the four coordinate arguments implicitly and never mentions serial (device targeting) or duration_ms beyond the vague hint of a 'longer default'. Two of six parameters remain semantically undefined.

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 (drag) plus the coordinate endpoints, and explicitly frames itself as an alias of swipe with a longer default, which lets an agent distinguish it from the sibling 'swipe' tool without opening either schema. The parenthetical '(slow swipe)' restates the gesture rather than adding new information, keeping it just short of 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 phrase 'Alias of swipe with a longer default' implicitly tells the agent to prefer drag over swipe when a slower gesture is desired, but it never states explicitly when to use drag versus swipe, nor any prerequisites (e.g., device selection via serial, coordinates relative to screen). Usage is inferable rather than spelled out.

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 usefully discloses the output shape ('raw text (capped)'), but says nothing about the read-only/diagnostic nature, side effects, permission requirements, or error behavior. It adds some context but is not rich for a no-annotation 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?

Two tight sentences, front-loaded with the command form and examples, with zero wasted words. The scoping caveat is placed at the end where 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?

An output schema exists, so return values needn't be detailed, and the 'raw text (capped)' note is a bonus. But for a four-parameter tool with 0% schema coverage and no annotations, the description should say more about `args` and `serial` to be 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 coverage is 0% for all four parameters. The description gives valuable examples for the required `service` param and hints at `max_chars` via 'capped,' but `args` and `serial` are left completely undocumented in both schema and description, so it only partially compensates.

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 gives a specific verb and resource ('Run `dumpsys <service>`') and concretely distinguishes itself from `run_shell` with 'not an arbitrary shell.' However it does not resolve overlap with siblings like get_battery, get_meminfo, or list_services, whose examples ('battery', 'meminfo') it echoes, so sibling differentiation is partial.

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?

'Scoped to a service name — not an arbitrary shell' implies the agent should use run_shell for arbitrary commands, giving a negative-scoping hint. But it never explicitly states when to prefer this over the overlapping diagnostic siblings (get_battery, get_meminfo), leaving usage 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?

No annotations are provided, so the description carries the full behavioral burden. It does disclose how the two boolean flags change the returned node set ('drops nodes with no text/id/description', 'keeps only clickable nodes'), which is genuine behavioral context, but it says nothing about device preconditions, the serial parameter, or whether a device must be 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?

Two tightly written sentences, front-loaded with the return shape and followed by the filter semantics. The inline field list is arguably redundant with the existing output schema, but it is compact and aids immediate comprehension.

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?

An output schema exists, so the description need not explain return values, and the parameter behavior is well covered for two of three flags. The remaining gap is the serial parameter and any device-connection precondition, which leaves the definition slightly short for a tool with zero annotation coverage.

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 for two of three parameters: non_empty_only and clickable_only are explained with meaning beyond their names, including the rationale ('usually layout containers'). The serial parameter is left entirely undocumented in both schema and description, keeping this short of a 5.

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 ('Dump the current on-screen view hierarchy as a flat list of elements') and even enumerates the returned element fields, so the purpose is unmistakable. It does not, however, differentiate itself from sibling inspection tools such as find_elements or tap_element, which an agent must choose between.

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 'use this when...' guidance or comparison to alternatives. Usage is only implied through the flag semantics: non_empty_only is for dropping layout containers and clickable_only is for isolating tappable targets, which hints at workflow but never says when this tool beats find_elements.

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 behavioral burden but only states the return shape, which the output schema already covers. It says nothing about whether this is a safe read-only probe, how as_root affects execution, or which device is targeted when serial 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?

Two tight sentences, purpose front-loaded, zero filler. Nothing to trim.

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

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

The output schema covers return values, so that omission is fine, but a 3-parameter tool with 0% schema coverage and no annotations leaves device targeting and root behavior undocumented. For a multi-device ADB surface this is a real gap.

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

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

Schema description coverage is 0% for all three parameters, so the description must compensate and does not. 'path on the device' loosely hints at remote, but serial (device selection) and as_root (privilege escalation) are never explained anywhere.

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+resource ('Check whether a path exists') and even names the return shape. It distinguishes itself from mutation siblings like write_file/delete_file, but does not explicitly differentiate from stat_file, which likely answers a similar question.

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

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

No guidance on when to prefer this over stat_file or list_files, and no mention of prerequisites such as needing an attached device or root access. The agent is left to infer context entirely.

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

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

With no annotations, the description carries the full burden and does fairly well: it discloses matching semantics (substring by default, exact=True for full match), that multiple criteria are OR-combined ('any of'), and the return shape (element records with bounds.center for tapping). It omits what happens on no-match or when no criteria are supplied, but for a read-only lookup this is a solid behavioral picture.

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

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

Three tight sentences with no filler; the match criteria and default matching mode are front-loaded before the return-shape note. The slash-separated selector list is dense but compact and readable.

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?

An output schema exists, so return values need not be detailed, yet the description usefully points to bounds.center for the follow-up tap. For a zero-required-parameter read tool this is nearly complete; only the undocumented serial parameter and absent when-to-use guidance keep it from being fully self-contained.

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% across 5 parameters, so the description must compensate. It explains the three selector parameters and the exact flag's matching semantics, but the 'serial' parameter is never mentioned, and the interaction between selectors and the default state of a null selector is left unstated.

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 ('Find on-screen elements') and names the exact match criteria (text / resource_id / content_desc). It also implicitly distinguishes itself from dump_ui by noting it returns 'the same element records as dump_ui', framing itself as the filtered counterpart. It stops short of an explicit sibling contrast, but the purpose is unambiguous.

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

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

Usage is only implied: a search-before-tap workflow is suggested by 'bounds.center for tapping', and the relationship to dump_ui is referenced. However, there is no explicit statement of when to call find_elements instead of dump_ui or tap_element, and no exclusions or prerequisites are given.

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 does disclose two genuinely useful behavioral traits: idempotency and the return shape {package, status}. It omits required permissions, whether the app's data/state is affected, and whether it applies to all device users.

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

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

Two short clauses, front-loaded with the action, with zero filler. Every element (action, idempotency, return shape) adds 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?

An output schema exists, so return values need no elaboration. For a 2-parameter mutation with no annotations and 0% schema coverage, the unexplained 'serial' parameter and absent permission/effect details leave real gaps.

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

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

Schema description coverage is 0% for two parameters. The description mentions only 'an app', leaving the 'serial' device-selection parameter entirely unexplained and adding no format or constraint detail for 'package' beyond the schema's type declaration.

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+resource ('Force-stop an app'), which is unambiguous. However, it does not distinguish itself from near-siblings like kill_background or clear_app_data, which an agent could plausibly confuse with force-stopping.

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 versus alternatives such as kill_background or clear_app_data, nor any stated prerequisites. The parenthetical '(idempotent)' implies safe retry but not selection criteria.

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

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

No annotations are provided, so the description carries the full burden. It explains the direction of forwarding but says nothing about persistence (does the forward survive disconnect?), required device connectivity, port conflicts, permissions, or cleanup via remove_forward/clear_forwards. For a state-mutating setup 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?

A single sentence that front-loads the adb equivalent and then clarifies the direction. No filler; every clause 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?

With no annotations and 0% schema description coverage, the description should do more. It covers the core semantics but omits prerequisites, lifecycle (persistence/removal), and error conditions, and never references the related remove_forward or clear_forwards tools. An output schema exists, so return values needn't be explained.

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 successfully maps local_port to the host port and remote_port to the device port via the `adb forward tcp:local tcp:remote` syntax, but the optional `serial` parameter is never mentioned, leaving one of three parameters undocumented.

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

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

States a specific verb and resource ('forward a HOST port to a DEVICE port') and explicitly defines the direction of traffic, which is the key distinction from the sibling reverse_port. An agent can tell it apart from reverse_port without opening either schema.

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

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

The description implies usage by explaining that host connects locally and traffic reaches the device, but it never states when to use this versus reverse_port, nor does it name any alternatives or prerequisites (e.g., device must be connected). Usage is inferable but not guided.

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 usefully discloses the root/permission requirement and the return shape, but says nothing about whether an existing local file is overwritten, transfer size limits, or what happens when no trace exists.

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 tight sentences with no filler, front-loading the action and the exact file paths before the caveat. Every clause 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?

An output schema exists, so return-value detail is optional (the description duplicates some of it anyway). The real gap is that a 2-parameter tool with zero schema coverage and no annotations leaves the agent without parameter guidance, making the definition only minimally 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% and the description never mentions either parameter. Neither 'serial' (device targeting) nor 'local_path' (destination) is explained; the mention of 'local' in the return object only hints at the latter. The description does not compensate for the coverage gap.

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

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

Specific verb ('Pull') plus a precisely named resource ('most recent ANR trace file') with concrete paths (/data/anr/traces.txt or /data/anr/). This clearly separates it from siblings like get_crash_log, capture_bugreport, or logcat_dump.

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?

Usage is only implied by the resource name (ANR diagnostics); there is no explicit when-to-use guidance, no mention of when to prefer it over get_crash_log or capture_bugreport, and no stated prerequisites beyond a parenthetical about root.

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 behavioral burden. It discloses the underlying source ('from dumpsys battery') and the read-only nature is implied by 'Return', but it says nothing about which device is targeted, behavior with multiple connected devices, or failure modes.

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 compact sentence that front-loads the verb and enumerates the payload; 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?

An output schema exists, so return values need not be explained, and the read-only nature is inferable. However, with zero annotation coverage and an undocumented 'serial' parameter, the description leaves device targeting and multi-device behavior unspecified.

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 sole parameter 'serial' is undocumented in both schema and description. The description never mentions device selection, so an agent gets no help in understanding what 'serial' does or how to pick a device.

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?

Specific verb ('Return') plus resource ('battery') and it enumerates the returned fields (level/status/health/temperature), which no sibling tool covers. It does not explicitly differentiate itself from siblings like get_device_properties or dumpsys, but the battery focus is unambiguous.

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

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

Usage is only implied by the tool name; the description gives no explicit when-to-use, prerequisites, or alternatives (e.g., use dumpsys for a full battery dump). Adequate but with a clear gap.

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, so the description carries the burden. It usefully discloses scope (native + Java crash buffer) and ordering (newest first), but says nothing about whether the buffer is cleared after dumping, device-selection behavior, or any auth/rate considerations.

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 tightly written sentence, front-loaded with the action and resource, with no filler. Backticks around `tail` tie it cleanly to the parameter name.

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

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

A low-complexity, two-parameter read tool with an output schema, so return format needn't be explained. The description covers the essentials; only the meaning of `serial` and post-dump buffer state are unaddressed.

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%, so the description must compensate. It clarifies `tail` as the count of newest records returned, which adds real meaning over the bare integer, but `serial` (device targeting) is left entirely to the agent's inference.

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

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

States a specific verb ('Dump') and resource ('crash' logcat buffer), and narrows scope by naming native + Java crashes. That scoping distinguishes it from the general logcat_dump/logcat_filter siblings without needing to name them explicitly.

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 when-to-use or when-not-to-use guidance. Given the dense sibling set (logcat_dump, logcat_filter, logcat_clear, get_anr_traces), the agent gets no help choosing between this and the other log-retrieval tools.

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

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

No annotations are provided, so the description carries the full burden, but the verb 'Return' at least implies a non-mutating read with no side effects. It says nothing about what happens when no app is focused, whether a locked/asleep screen affects the result, or how the optional device serial is resolved.

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 short, front-loaded sentence with zero filler; the core resource is named immediately and nothing is repeated from the schema or annotations.

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?

An output schema exists, so return values need no explanation, and the tool is a simple read. However, the undocumented serial parameter and the unspecified behavior when no foreground activity exists leave meaningful gaps for a tool whose whole job is device-scoped state lookup.

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 single parameter (serial, nullable, default null) is never referenced in the description. The agent gets no explanation of whether omitting serial targets the default device or all connected devices, which is exactly the gap the description should close.

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 ('Return') and a clearly scoped resource ('currently focused activity/package (foreground app)'), with a parenthetical that removes any ambiguity about what 'activity' means. It does not explicitly differentiate itself from lookalike siblings such as get_state, app_status, or list_processes, so it stops short of 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 when-to-use guidance and never names an alternative, so an agent must infer that this is the lightweight foreground-app query versus app_status or get_state. There is also no mention of the multi-device condition that the serial parameter implies.

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 exist, so the description carries the full burden. It usefully discloses the resolution source (runtime override or the ADB_SERIAL variable), which is real behavioral context beyond the schema. However, it does not confirm side-effect-free semantics, describe failure behavior when nothing is set, or note any fallback ordering beyond the two named sources.

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 returned value and adds one clarifying clause. No filler, no restatement of the tool name.

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

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

Zero parameters, an output schema that covers the return type, and a clear statement of what value is produced. For a trivial getter this is nearly complete; the only omission is what happens when no default is configured and how it relates to set_default_device.

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 takes zero parameters, so the schema has nothing to document and the baseline is 4. The description's mention of ADB_SERIAL usefully explains where the returned value originates rather than leaving the agent to guess.

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 and resource: returns the active default device serial. It distinguishes itself implicitly from the sibling set_default_device and from get_devices by naming the exact value returned. It does not explicitly contrast with those siblings, so it falls short of 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?

There is no when-to-use guidance and no routing to alternatives. With siblings like get_devices and set_default_device present, the agent gets no signal about when this narrow getter is preferable to enumerating devices or how the two relate. The parenthetical hints at resolution order but is not usage guidance.

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

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

No annotations are provided, so the description carries the full burden. 'Return' implies a read-only operation, and the pre-action targeting advice adds some context, but it does not disclose whether the call has side effects, how the optional serial parameter selects a device, or what the default target is when serial 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 two sentences and front-loads the main purpose. The field enumeration is informative, though the second sentence slightly repeats the first sentence's intent.

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

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

The tool is simple and an output schema exists, so return values are covered elsewhere. However, the description is incomplete for multi-device targeting because it does not explain the optional serial parameter or default device behavior.

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

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

The schema has 0% description coverage for the single optional 'serial' parameter, and the description never mentions it. The description therefore does not compensate for the missing schema documentation or explain that serial selects which device's properties are returned.

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 ('Return') and resource ('target environment'), then enumerates the returned fields. It is clear what the tool does, but it does not explicitly distinguish itself from siblings like get_devices, get_state, or get_screen_info.

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

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

The phrase 'Tells the agent exactly what it is targeting before acting' implies a usage context (pre-action reconnaissance), but there are no explicit when-to-use/when-not-to-use conditions and no named 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 full burden, and it delivers useful behavioral detail: the exact return fields and the non-obvious convention that serials containing ':' are network devices (WSA/emulators) for which is_usb is False. It omits anything about error states or empty results, but the read-only nature of a list operation is self-evident.

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

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

Two short sentences, purpose front-loaded, and the return-shape convention placed second where it is most useful. 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 zero-parameter listing tool with an output schema available, the description supplies everything needed: what is listed, what comes back, and the one non-obvious field semantics. Nothing an agent needs to call it correctly is missing.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly adds no parameter discussion, which is appropriate for a parameterless listing call.

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 ('List') and resource ('attached devices/emulators') plus the scope qualifier 'with state and transport'. It is clearly distinct from single-device siblings like get_state or get_device_properties, but it never names an alternative or explicitly contrasts itself with them.

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

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

Usage is implied by the purpose (enumerate devices before acting on one), but there is no explicit when-to-use guidance, no mention of ordering relative to connect/disconnect/wait_for_device, and no stated alternatives. Minimum viable.

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. The word 'Return' implies a read-only query, which is the key behavioral trait, and 'default wlan0' discloses defaulting behavior. However, it says nothing about error/empty behavior (e.g., no address on the interface) or connectivity requirements.

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

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

A single sentence that front-loads the action and resource, with the default parenthetically tucked in. 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?

An output schema exists, so return values need not be explained, and the tool is a simple read. But the 'serial' parameter and any failure conditions are left unaddressed, leaving the definition adequate 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 coverage is 0% for two parameters, so the description must compensate. It explains the 'iface' parameter ('on an interface, default wlan0'), which is genuinely useful, but says nothing about the 'serial' parameter, leaving half the inputs undocumented.

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

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

States a specific verb and resource: 'Return the device's IPv4 address on an interface'. An agent can tell this retrieves a network address, distinct from siblings like get_prop or get_device_properties. No explicit sibling differentiation, but the resource is precise.

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

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

There is no when-to-use guidance, no mention of alternatives (e.g., get_prop/get_setting for network values), and no prerequisites such as needing a connected device. Usage is only inferable from the purpose, which is thin for a tool among many get_* 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 present, so the description carries the full behavioral burden. It discloses the return shape (parsed fields + raw text) and the output unit (kB), which is real added context, but says nothing about permissions, device/serial targeting, or failure modes for an adb-backed 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?

Three short clauses, front-loaded with the core action and the branch condition, then the return shape. No filler sentences.

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?

An output schema exists, so return values needn't be detailed, and the description correctly focuses on scope and units. However, with zero annotation coverage and an entirely undocumented 'serial' parameter, an agent still lacks enough to target the right device confidently.

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%, so both parameters depend on the description. It explains what 'package' does (yields that app's total PSS in kB) but never mentions 'serial' at all, leaving device selection undocumented in both schema and description.

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

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

States a specific verb+resource ('Return memory info') and immediately branches into the two scopes it serves: per-package PSS with a package arg, global Total/Free/Used/Lost RAM otherwise. An agent can distinguish it from siblings like get_top or list_processes from the description alone.

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 conditional behavior ('With a package... otherwise') impliedly tells the agent which argument selects which mode, which is usable context. But it never says when to prefer this over get_top, list_processes, or dumpsys meminfo, and offers no exclusions or prerequisites.

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 usefully discloses the read-only nature via 'Return' and enumerates the returned data, which is genuine behavioral context. However it says nothing about permission requirements, whether the package must be installed, or rate/device-serial considerations.

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 that lists the return fields with zero filler. Every clause 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?

An output schema exists, so the description need not explain return values (though it does helpfully preview them). The remaining gap is the undocumented inputs at 0% coverage and absent read-only/permission semantics for a tool with no annotations.

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?

Two parameters exist at 0% schema description coverage, yet the description never mentions them. The meaning of 'package' (package name) and 'serial' (target device) is left entirely undocumented, so the description does not compensate for the schema gap.

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

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

States a specific verb (Return) and resource (structured package info) and enumerates the exact fields returned. It is clearly distinct from mutation siblings like launch_package or clear_app_data, though it does not explicitly contrast with list_packages or app_status.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as list_packages (batch listing) or app_status. The agent must infer context entirely on its own.

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 full weight. It discloses the key behavioral trait — dual return shape (single value vs dict of all props) — which is genuinely useful. But it offers nothing on permissions, rate limits, error behavior for a missing property, or serial targeting semantics.

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

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

One sentence, front-loaded with the primary action and immediately followed by the conditional mode difference. Every clause earns its place with zero 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 2-param read tool with no annotations and no output schema, the description covers the core call pattern and return shape but leaves the 'serial' parameter and any behavioral constraints undocumented. Adequate but with clear gaps.

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

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

Schema description coverage is 0% and neither parameter is documented in the schema. The description explains 'name' behavior well (omit to get all), but 'serial' — a meaningful parameter selecting the target device — is completely unmentioned in both description and 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 ('Read') plus the resource ('system property by name'), and explicitly distinguishes the two modes (single prop vs ALL props when name is omitted). The mention of parsing `getprop` grounds it against the large sibling set, including nearby tools like get_device_properties and set_prop.

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 implicitly clarifies when to call with vs without 'name' (omitting name returns all). However it gives no guidance on when to use this over get_device_properties or get_setting, despite those siblings clearly overlapping. No exclusions or alternative routing.

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 does disclose a genuine behavioral trait — that the Override display size is preferred over the physical size — which the agent could not infer from the schema. However, it says nothing about device-selection behavior (serial vs default device) or what happens when 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?

Two short sentences, front-loaded with the return shape and followed by the one non-obvious behavioral rule. Every sentence earns its place with 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?

An output schema exists, so return values need not be spelled out, though the description helpfully summarizes them. Given the tool's simplicity (one optional param), the main gap is the undocumented serial parameter and device-targeting behavior; the description is adequate but not complete.

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

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

The single optional 'serial' parameter has 0% schema description coverage and is not mentioned anywhere in the description. The description does not explain how serial selects the target device or that omitting it uses the default device, so an agent gets no semantic help for the only parameter.

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

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

States a specific verb ('Return') and resource ('effective display size and density') and enumerates the exact returned fields (width, height, density, raw). No sibling tool in the list returns display geometry, so an agent can identify this immediately as the display-metrics tool.

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

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

The phrase 'what input coordinates map to' hints at the tap/swipe coordinate-mapping use case, but there is no explicit when-to-use instruction, no mention of prerequisites (connected device / serial), and no routing to or away from alternatives. The general context is implied rather than stated.

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. 'Read' clearly implies a non-mutating operation, and the output schema covers return values. However, it does not disclose required permissions, error behavior, or the role of the serial parameter.

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

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

Two short sentences with no filler; the purpose is front-loaded and the namespace values are compactly presented.

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 an output schema, the description covers the core purpose and namespace options. It remains incomplete because key and serial are not explained, and no annotations clarify behavior.

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 meaning for namespace by listing valid values, but key and serial are not described at all, leaving most parameter semantics to inference.

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

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

The description states a specific verb ('Read') and resource ('Android setting'), making the tool's core function clear. It does not explicitly differentiate from sibling tools like get_prop or put_setting, so it stops short of 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?

It gives valid namespace values, which is useful context, but provides no guidance on when to use this tool versus put_setting or other getters. There is no explicit when/when-not or alternative 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 full behavioral burden. 'Return' implies a read-only query, and the enumerated states add some output context, but it does not explicitly state read-only behavior, permission requirements, or what happens when the serial parameter 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 one front-loaded sentence with no wasted words. It directly states the action and the possible result states.

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?

An output schema exists, so return values need not be explained in detail. However, for a simple device-query tool, the description omits important context: how to target a device when 'serial' is omitted, whether it falls back to a default device, and when to use this tool instead of related device-listing or waiting tools.

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% for the single optional 'serial' parameter. The description refers vaguely to 'a device' but never names or explains the serial argument, its optionality, or the default-null behavior. It adds little meaning beyond the schema.

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

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

The description states a specific verb and resource: 'Return the connection state of a device.' It enumerates the possible return states (device / offline / unauthorized), so the agent can infer scope. It does not explicitly differentiate this from siblings like get_devices or wait_for_device.

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 when-to-use guidance. It does not mention alternatives such as get_devices, wait_for_device, or connect/disconnect, nor does it state when this tool should be preferred. Usage is only implied by the phrase 'connection state of a device.'

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 usefully discloses that output is raw text and that the call is a one-shot snapshot rather than a live stream, but says nothing about permissions, device targeting, or cost/latency.

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 tight sentence with the key qualifiers (one-shot, by CPU, raw text) front-loaded; nothing is wasted.

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?

An output schema exists so return formatting need not be re-explained, and the description correctly flags raw text. However, for a device-oriented tool the unexplained `serial` parameter and absence of usage routing leave real gaps.

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

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

Schema coverage is 0%, so the description must compensate. It explains `count` (top count processes by CPU) but leaves `serial` completely undefined in both schema and description, despite it being the device-selection parameter.

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

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

States a specific verb (return), resource (top snapshot of processes by CPU), and scope (one-shot, top count). It is fairly distinct from list_processes, though it never names that sibling to sharpen the contrast.

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?

'one-shot' hints at a snapshot versus streaming, but the description gives no when-to-use guidance and never mentions the obvious alternative list_processes or get_meminfo for process/memory inspection.

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 does disclose the data sources, which implies a read-only, non-destructive informational query, and states the output shape (seconds + human string). It does not state device-connection requirements, behavior when multiple devices are attached, or failure modes, leaving meaningful behavioral gaps.

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

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

A single tight sentence with the action and output format front-loaded; every clause (return type, sources) adds information and there is 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?

An output schema exists, so return values need not be explained (and the description's format note is mildly redundant). The remaining gaps are the unexplained optional `serial` parameter and the absence of any context about device connection or default-device resolution, which an agent needs to call this correctly in a multi-device setting.

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 single `serial` parameter is never mentioned in the description, so there is no explanation of what it does or what happens when it is omitted (the null default implies a fallback to a default device, but this is unstated). The description therefore does not compensate for the schema's silence.

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 ('Return device uptime') and even names the underlying sources (/proc/uptime and the `uptime` command), which pins down exactly what is fetched. It is distinguishable from siblings like get_meminfo or get_state, though it does not explicitly contrast itself with them.

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

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

There is no when-to-use guidance, no indication of prerequisites (e.g., that a device must be connected/selected), and no mention of when to prefer a sibling such as get_state. The agent must infer usage entirely from the name and the sibling list.

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

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

With no annotations, the description carries the full burden, and it discloses little beyond naming `pm grant`. It does not say whether the grant takes effect immediately or requires an app restart, whether it persists across reboots, what happens if the permission is not declared in the manifest, or what errors look like.

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

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

A single tight sentence that front-loads the action and packs in the permission format plus the underlying ADB command. Nothing wasted.

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?

An output schema exists, so return values need not be explained, but this is a state-changing device operation with no annotations, no parameter documentation, and no prerequisites or side-effect disclosure. It is under-specified for a mutation 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?

Schema description coverage is 0% across three parameters. The description clarifies only the `permission` parameter via an example string; the `package` format (application ID) and the `serial` device-selector parameter are left entirely undocumented.

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

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

States a specific verb (grant) and resource (runtime permission) and even names the underlying command `pm grant`, with a concrete example permission string. It does not explicitly distinguish itself from the sibling revoke_permission, but the action is unambiguous.

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

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

Usage is only implied: the agent can infer this applies to granting runtime permissions to an installed package. There is no statement of when to use this versus revoke_permission, nor prerequisites such as the target app being installed or the permission being declared in the manifest.

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 usefully maps the boolean flags to their adb equivalents (replace=-r, grant_permissions=-g, downgrade=-d) and states the return shape, which is real behavioral value for a mutation tool. It still omits whether replacement destroys existing app data, permission requirements, and failure modes.

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 tight sentences, front-loaded with the core action and the multi-APK conditional, followed by compact flag mappings and return shape. No 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?

An output schema exists, so explaining {status, message} is redundant but harmless. For a 5-parameter mutation tool with zero annotation coverage and zero schema descriptions, the definition is still thin on the serial/path parameters and side effects on existing installs.

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%, so the description must compensate. It explains the meaning of replace, grant_permissions, and downgrade via adb flag equivalents, but leaves serial and apk_paths (including path format and whether multiple paths mean split APKs) undefined, so it only partially fills the gap.

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

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

States a specific verb+resource ('Install an APK') and additionally clarifies a distinct mode ('split-APK set via install-multiple when >1 path given'). It does not name or contrast with siblings, but the purpose is unambiguous and install has no close 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?

Provides one conditional rule: use the multi-APK path when more than one path is given. It does not address when to use this versus uninstall/reinstall workflows, prerequisites (device connection, serial resolution), or failure/retry guidance, so usage is implied rather than fully guided.

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, yet it discloses only the input format. It says nothing about side effects (e.g., that HOME/APP_SWITCH will change foreground state), what longpress does, whether a device serial is needed for multi-device setups, or what the tool returns. The behavioral profile is largely absent.

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 tight sentences with the core action front-loaded and the keycode examples immediately following. No filler, though the example list is dense and could be trimmed slightly.

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?

An output schema exists so return values need not be described, and the keycode format is well covered. But with no annotations, 0% schema coverage, and undocumented serial/longpress parameters, the definition is not complete enough for a tool whose key events can have meaningful device 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 coverage is 0%, so the description must compensate. It does a good job on keycode (numeric or named, with examples and the optional KEYCODE_ prefix), but 'serial' and 'longpress' receive no explanation at all, leaving two of three parameters undocumented in both schema and description.

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

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

States a specific verb and resource ('Send a key event') and enumerates accepted keycode forms. However, it does not distinguish itself from the many overlapping siblings (press_home, press_back, press_enter, tap, long_press), so an agent cannot tell from the description when to prefer this generic tool over those convenience wrappers.

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

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

The description explains input format but gives no when-to-use guidance, no prerequisites, and no mention of the sibling alternatives that do the same thing for specific keys. The agent must infer usage entirely from 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 carries the full burden. It usefully discloses the underlying mechanism (`am kill`) and the gentleness relative to force-stop, implying only background processes are affected. It does not say what happens to a foreground process, what privileges are needed, or confirm the operation is non-destructive to app data.

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 with the mechanism and the differentiator packed in; nothing is wasted and the key routing cue comes last where it is easy to catch.

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?

An output schema exists, so return values need no explanation. However, for a tool with 0% schema description coverage and no annotations, the description leaves the device-targeting `serial` parameter and any permission/foreground-app behavior unaddressed.

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

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

Schema description coverage is 0%, so the description must compensate for two undocumented parameters, and it does not. 'An app's' loosely implies the required package, but the `serial` parameter (device targeting) is never mentioned in either the schema or the description.

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

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

States a specific verb and resource ('Kill an app's background processes') and explicitly distinguishes itself from the sibling force_stop by calling itself 'gentler than force-stop.' An agent can pick between kill_background and force_stop without opening either 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?

Names the alternative (force-stop) and gives the condition that favors this tool (gentler behavior). It stops short of an explicit when-not-to-use rule, e.g. that a foreground app or data-clearing need should route to force_stop or clear_app_data.

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

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

With no annotations, the description carries the full burden, and it does disclose the underlying command semantics (`am start -n`) and what it returns (am output and pid if resolvable). However, it says nothing about side effects of launching an activity, failure/error behavior, or interaction with an already-running activity, which are relevant for a state-changing operation.

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

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

Two tightly written sentences, front-loaded with the action and example, with zero filler. Every clause (command form, return value) 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?

An output schema exists, so return values needn't be spelled out. But for a mutation tool with no annotations and 0% parameter coverage, the description should at least address the `serial` parameter and basic failure behavior; it is adequate but 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?

Schema coverage is 0% for both parameters. The description partially compensates by showing the expected format of the required `component` parameter, but the `serial` parameter is completely undocumented in both schema and description, leaving a real gap.

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

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

The description states a specific verb (Start) and resource (an explicit activity), and gives the concrete component format 'com.app/.MainActivity' plus the underlying `am start -n`. It is clear what the tool does, though it never explicitly contrasts itself with the sibling launch_package, so differentiation is only implied by the word '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?

There is no when-to-use, when-not-to-use, or alternative guidance. The agent is left to infer that this is for launching a named component versus launch_package for a package name; no prerequisites or exclusions are stated.

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 behavioral burden. It usefully discloses idempotence, but omits permission requirements, device serial behavior, error cases, and whether launching brings the app to the foreground.

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 compact sentences, front-loaded with purpose and idempotence, then the return shape. It is well-sized, though the return shape duplicates the output schema and therefore does not fully earn 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?

With no annotations, 0% schema coverage, and an output schema, the description is only partially complete. Purpose and idempotence are covered, but the serial parameter and usage relative to launch_activity are absent.

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 identifies 'package' but never mentions the optional 'serial' parameter or what it controls, leaving half the parameters undocumented.

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

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

States a specific verb ('Launch'), resource ('app by package'), and mechanism ('LAUNCHER intent'), which differentiates it from launch_activity in the sibling set. An agent can identify the right tool from this description alone.

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 explicit when-to-use guidance or named alternatives. The phrase 'by package' implies a condition, but it does not say when to prefer launch_activity or how to handle missing packages.

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 behavioral burden. It does add real value: it discloses that as_root shells out via `su -c ls` and that symlinked directories are dereferenced rather than returned as links. However it omits permissions required, behavior when the directory does not exist, and whether traversal is recursive.

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?

Front-loaded with the operation and its output shape, followed by two focused behavioral notes. Every sentence earns its place; only the slight informality of the second sentence keeps it from a 5.

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?

An output schema exists, so the description need not document return values, yet the behavioral notes about root execution and symlink dereferencing add context an agent would otherwise lack. Missing error/permission behavior is a minor gap for a read-only list 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?

Schema description coverage is 0%, so the description must compensate across three parameters. It explains as_root's mechanism well, but says nothing about what `serial` selects (target device) or the format/scope of `remote_dir`, leaving two of three parameters undocumented in both schema and description.

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

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

States a specific verb+resource ('List a device directory') and even specifies the return shape, which separates it from single-file siblings like stat_file or file_exists. It does not explicitly name or contrast with those siblings, so it stops short of 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?

Usage is implied by the verb and the directory scope, but there is no explicit guidance on when to prefer this over stat_file, file_exists, or read_file, nor any prerequisites (e.g. device connection state). Adequate but with a clear gap.

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 behavioral burden. The qualifier 'active' hints that inactive/dead rules are excluded, but the description does not state safety profile, permissions, or operational side effects for a tool in a device-mutating adb suite.

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 with zero filler; the scope ('active') and return preview are packed efficiently. Nothing needs trimming.

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?

An output schema exists, so return values need no explanation. However, the lone `serial` parameter is undocumented in both schema and description, and there is no routing guidance among the many forward/reverse siblings, leaving real 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?

There is one optional parameter (serial) with 0% schema description coverage, and the description never explains what it does (device scoping/filtering). The `{serial, local, remote}` snippet describes the output shape, not the parameter, so it fails to compensate for the schema gap.

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

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

States a specific verb (List) and resource (active `adb forward` rules) and even previews the return shape. It is distinguishable from siblings like list_reverses, forward_port, remove_forward, and clear_forwards, though it never names them.

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

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

Usage is only implied by the verb 'List' and the word 'active'. There is no explicit when-to-use, no condition selecting it over forward_port/list_reverses/remove_forward, and no note that it is a read-only inspection step.

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 more burden. It mentions that include_paths changes the return shape to {package, apk}, which is useful behavioral detail. However, it does not clarify default behaviors of bools (e.g., only_enabled defaults to false) or potential side effects, though it's a read-only listing.

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

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

Three concise sentences, zero waste, front-loaded with the main action and then parameter semantics. Very efficient.

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

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

Output schema exists, so return format needn't be fully described, but the description adds a return shape note. It covers key parameters but omits serial and only_enabled semantics. Given no annotations, some gaps remain, but overall sufficient for a list 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?

Schema coverage is 0%, so description must compensate. It explains filter (case-insensitive substring), only_third_party (excludes system apps), and include_paths (adds apk path). It doesn't explain serial or only_enabled, but covers the most ambiguous ones.

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 'List' and resource 'installed package names', clearly distinguishing from siblings like list_files or list_processes. The scope 'installed' is 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?

Usage is implied by the description (e.g., filter to narrow results, only_third_party to exclude system apps), but no explicit when-to-use or when-not-to-use guidance or alternatives is given. Adequate for a simple list tool.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the returned fields and the filter semantics, which is useful. However, it doesn't state that this is a read-only, non-destructive operation, nor any device/connection prerequisite, which is a gap for a tool in a mutation-heavy sibling set.

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 dense sentence plus a clause, front-loaded with the verb and resource. Every token earns its place, with the return shape and filter semantics packed in without 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?

With an output schema present, the description needn't detail return values, and it does not need to. But given two parameters with 0% schema coverage and no annotations, the undocumented `serial` parameter and absent safety/device context leave the definition only minimally viable.

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 explains `filter` as a name substring, which is helpful, but the `serial` parameter (device targeting) is completely undocumented in both schema and description. The description adds meaning for one of two parameters but leaves the other unexplained.

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

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

States a specific verb (List) and resource (running processes), and anchors it to the familiar `ps -A` equivalent. The return shape [{pid, ppid, name, user}] makes the output concrete and distinguishes it from any other list_* 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?

Explaining that `filter` is a name substring implies the intended use case, but there is no explicit when-to-use guidance or exclusions (e.g. no note that this is device-side and requires a connected device). Implied usage only.

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 behavioral burden. It does not state that this is a read-only operation, what happens when serial is omitted (all devices?), or how active rules are defined, though it does hint at the return shape.

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 tight sentence with the resource front-loaded and a compact shape hint appended. Nothing is wasted.

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?

An output schema exists, so the return-value shape need not be spelled out in prose. However, the description omits the meaning of the one parameter and the multi-device behavior, which are not covered anywhere else.

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 single `serial` parameter (nullable, default null) is never mentioned. The description does not explain whether serial scopes the query to one device or defaults to all, leaving a meaningful gap.

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

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

States a specific verb and resource: 'List active `adb reverse` rules', which clearly identifies the reverse-port mapping inventory. It distinguishes itself from list_forwards/list_forwards by resource name, but does not explicitly contrast with those near-identical siblings.

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

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

No guidance on when to use this versus list_forwards, remove_reverse, or clear_forwards, and no prerequisites or context. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full behavioral burden, and a single sentence leaves it largely unmet. It implies a read-only listing with no side effects, but says nothing about how the target device is chosen when multiple devices are connected, or about authentication/ADB availability.

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 with zero filler. The purpose is delivered immediately and nothing is wasted.

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 enumeration tool with an output schema covering return values, the description is minimally sufficient. However, the undocumented 'serial' parameter and the absence of any usage context leave it short of complete for a multi-device ADB toolkit.

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 is one parameter ('serial') with 0% schema description coverage, and the description never mentions it. The agent gets no signal that 'serial' selects a specific device when more than one is attached, so the description fails to compensate for the schema gap.

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

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

States a specific verb ('List') and resource ('dumpsys service names') with clear scope ('available on the device'). It is easy to distinguish from list_packages, list_processes, and dumpsys, though the description does not explicitly contrast itself with the closely related dumpsys tool.

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

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

No when-to-use guidance is provided. A natural question is when to use list_services versus dumpsys (to dump a specific service), and the description offers no routing between them or any prerequisite on 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?

No annotations are provided, so the description carries the full behavioral burden. It never states that this is a destructive, irreversible operation that discards existing buffered logs, nor whether it affects all devices or only the default/serial-specified one.

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 with the operation and the equivalent adb command; 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?

An output schema exists so return values need not be explained, and the tool is simple. However, for an unannotated destructive operation with an undocumented parameter, the description leaves notable gaps about scope and effect.

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 single `serial` parameter is undocumented in both schema and description. The description adds no meaning about how to target a specific device or what the null default implies.

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?

Names a specific verb (Clear) and resource (device logcat ring buffers), and the parenthetical `logcat -c` pins down the exact underlying operation, distinguishing it implicitly from logcat_stop and logcat_dump. It stops short of explicitly contrasting with those siblings.

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

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

There is no statement of when to clear versus when to use logcat_start/logcat_stop/logcat_dump, nor any prerequisite or context. The agent must infer that this resets the buffer before a capture.

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

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

With no annotations, the description carries the full burden, and it delivers: it discloses the buffer-vs-one-shot source behavior and defines the semantics of each filter (tags as substring match, priority as min level). It omits any note on result ordering, rate limits, or permission requirements, but for a local read tool this is solid disclosure.

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

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

The return shape is front-loaded, then the buffer behavior, then a compact parameter legend. Dense and mostly waste-free, though the single-line parameter list is slightly run-on.

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?

An output schema exists so return values need not be explained, yet the description still names the record fields helpfully. Combined with the buffer/one-shot behavior and filter semantics, the only real gap is the undocumented 'serial' parameter.

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 defines four of the five parameters meaningfully (tags, priority, message_contains, tail). The 'serial' parameter is never mentioned, so an agent has no guidance on how to target a specific device.

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 ('Return recent logcat lines as records') and enumerates the record shape. It clearly reads as a dump/read operation, distinguishable from the mutation-oriented siblings (logcat_start, logcat_stop, logcat_clear), though it never explicitly names the nearest alternative logcat_filter.

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 gives useful context ('Reads the running capture's buffer if active, else does a one-shot logcat -d'), which tells the agent what happens in each state. However, it offers no explicit when-to-use guidance relative to logcat_filter or get_crash_log, leaving sibling 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?

No annotations are provided, so the description carries the full behavioral burden. It conveys that this is a read-style filtering wrapper via analogy to logcat_dump, but says nothing about buffer behavior, whether it captures live or buffered logs, permissions, or how tail affects results.

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

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

A single front-loaded sentence with zero filler; the tag example earns its place. Appropriately sized, though it is arguably too terse given the undocumented parameters.

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?

An output schema exists so return values need not be described, but with three parameters at 0% schema coverage and no annotations, the description is too thin to be self-sufficient. It should at least clarify tail and serial.

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%, so the description must compensate for all three params. It gives a useful example for tags (['Unity','libc','DEBUG']) but leaves tail and serial completely unexplained, so the compensation is only partial.

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 resource relationship: it is logcat_dump filtered to given tags, which cleanly separates it from logcat_dump and the other logcat_* siblings. The verb 'filtered' plus the tag example makes the operation concrete, though it is framed as a 'convenience' rather than an independent action.

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

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

The phrase 'logcat_dump filtered to the given tags' implies you reach for this instead of logcat_dump when you only want specific tags, but it never states when-not to use it or names the alternative explicitly. Usage is inferable but not spelled out.

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, so the description carries the burden. It discloses that capture is backgrounded, writes to a temp file, and only one runs at a time – useful. However it omits what 'clear' does (wipes existing buffer before starting?), whether start fails/no-ops when a capture is already running, and permission requirements.

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

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

Three short sentences, zero filler, front-loads the action and then the workflow. The buffers note is placed last where it belongs.

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

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

Covers lifecycle and concurrency well, and an output schema exists so return values need not be explained. Gaps remain around the semantics of `clear` and `serial`, and the exact behavior when a capture is already active.

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%, so the description must compensate. It explains `buffers` with an example ('main,system,crash'), which is real added value. But `clear` (default true) and `serial` (default null for device selection) are left entirely undocumented in both schema and description.

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

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

States a specific verb and resource: 'Start a background logcat capture to a temp file.' This clearly distinguishes it from siblings like logcat_dump, logcat_filter, and logcat_stop by role in the lifecycle.

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

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

Explicitly names the workflow: read with logcat_dump/logcat_filter, end with logcat_stop, and notes 'Only one capture runs at a time' – a real constraint that governs when to call it. Names alternatives and the condition that selects 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?

No annotations are provided, so the description carries the entire behavioral burden and it is thin. It never says whether buffered logs survive the stop, what happens if no capture is running, or whether the operation is idempotent or requires any permission.

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

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

One sentence, zero waste, front-loaded with the action and scoped by the sibling reference. Nothing could be removed without losing 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 output schema covers return values, so the description need not explain them, and the start/stop pairing is captured. What is missing is lifecycle behavior for a stateful capture operation with no annotations to fall back on, such as the fate of already-captured logs and the no-op case.

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 takes zero parameters, so there is nothing for the description to disambiguate beyond confirming that stopping needs no arguments. Baseline 4 applies 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?

States a specific verb (Stop) and resource (the background logcat capture) with clear scope, and ties itself to the sibling that initiates it. An agent can immediately distinguish it from logcat_start, logcat_dump, logcat_filter, and logcat_clear without opening a 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 clause 'started by logcat_start' gives a clear precondition that tells the agent when this tool is applicable. It does not, however, name exclusions or alternatives (e.g. logcat_dump for reading logs without stopping capture), so it stops short of full routing guidance.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does add a genuinely useful behavioural detail — that the gesture is implemented as a zero-distance swipe — but says nothing about side effects, what a long-press triggers, or how interruption affects it.

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

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

A single front-loaded sentence with zero filler; the coordinate, the duration and the implementation caveat all earn their 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?

An output schema exists, so return values need not be explained, and the core gesture is clear. Still, with no annotations and an entirely undocumented serial parameter, the definition stops short of fully equipping an agent to call it correctly in multi-device scenarios.

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

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

Schema description coverage is 0%, and the description maps x, y and duration_ms to their roles in the operation, which is more than the bare schema titles give. However, it never mentions the serial parameter or the units/meaning of duration_ms, leaving part of the parameter set undocumented.

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

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

States a specific verb (long-press) and the exact resource/coordinates, and the parenthetical implementation note distinguishes it from sibling gestures like tap, swipe and drag. An agent can tell what this does and how it differs from the neighbouring gesture tools.

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

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

The name and description imply the gesture's purpose, but there is no explicit guidance on when to choose long_press over tap, swipe or drag, nor any prerequisites. Usage is inferable rather than stated.

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

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

With no annotations, the description carries full behavioral burden. The `mkdir -p` parenthetical usefully discloses recursive creation and non-failure if the directory exists, but it omits permission requirements, the effect of as_root, and device-connection expectations.

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 with zero wasted words. The key operation and shell equivalence are stated immediately, making it highly efficient 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 mutation tool with three undocumented parameters and no annotations, the description is too thin. An output schema exists so return values need not be explained, but parameter semantics and usage context are missing.

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

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

Schema description coverage is 0% across three parameters, and the description does not explain remote, serial, or as_root. It adds no meaning beyond the bare schema, leaving required parameters effectively undocumented.

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

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

States a specific verb (Create) and resource (directory on the device), and the `mkdir -p` reference clarifies the operation. It is readily distinguishable from sibling file tools like list_files or delete_file, though it does not explicitly name alternatives.

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 when-to-use guidance, no exclusions, and no alternatives. It implies creating a directory, but leaves the agent to infer when this tool is appropriate versus other filesystem operations.

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 says nothing about whether this requires a connected device, what happens if no back stack exists, whether it blocks, or what the response contains. The output schema exists, so return values need not be explained, but operational context is missing.

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

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

The description is a single, front-loaded sentence with zero waste. It is appropriately sized for the simplicity of the operation, though it borders on being too terse to be 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 device-control action in a large sibling set, the description is inadequate. It does not say when to use it over press_home or keyevent, does not mention the device serial parameter, and provides no behavioral context. The existence of an output schema covers return values, but the description remains too thin for an agent to invoke confidently without external knowledge.

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 is only 1 parameter (serial) and it is optional with schema description coverage at 0%. With 0 required params and a single nullable serial parameter, the baseline is 4. The description does not mention the serial parameter, but for such a simple optional target selector, the schema's presence is largely self-explanatory and no compensating detail is strictly required.

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

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

The description states a specific action (press the BACK button), which is clear enough as a hardware key simulation. However, it is a near-tautology of the tool name 'press_back' and does not distinguish itself from sibling navigation tools like press_home, press_recents, or keyevent. It communicates the verb+resource but adds no scope or 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 on when to use this tool versus alternatives. An agent working with press_home, press_recents, keyevent, or tap_element gets no routing information. For a one-line description, usage context is entirely absent.

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