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

With no annotations provided, the description carries the full behavioral burden, and it discloses nothing: no read-only/no-side-effect statement, no indication of whether the device must be connected or authorized, and no note about behavior when multiple devices are present. Only the returned fields are listed.

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 phrase with zero filler, front-loading the returned values. It is a fragment rather than a sentence, but 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 the description covers what data comes back, which substitutes for the absent output schema. However, for a tool with no annotations it should at least confirm this is a side-effect-free read and clarify device-selection behavior, which it does not.

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

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

Schema description coverage is 100% for the single 'device' parameter, so the schema already explains serial usage and the single-device omission rule. The description adds nothing about the parameter, so the baseline 3 applies.

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

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

The description names the specific resource and the exact data returned (battery level, charging status, temperature), which clearly separates it from siblings like device_info and storage. It lacks an explicit verb, but for a single-purpose telemetry tool the intent 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?

There is no statement of when to use this tool versus device_info or other device queries, and no mention of prerequisites or alternative tools. The agent must infer usage 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?

No annotations are provided, so the description carries the full disclosure burden. It does reveal the scope of returned data, including the non-obvious 'currently focused activity', which is genuine behavioral content, but it never states that this is a side-effect-free read operation or that it is instantaneous/safe to call repeatedly.

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 compact clause with zero padding; the most informative item (focused activity) is included and nothing is wasted. It loses a point for being a sentence fragment rather than a clear statement of action.

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

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

There is no output schema, so the description usefully compensates by enumerating the returned fields, and the sole optional parameter is fully covered by the schema. It is nearly complete for a simple read tool; only the absence of any usage context keeps it from a 5.

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

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

Schema description coverage is 100% and the single 'device' parameter is fully documented in the schema, including the omit-when-single-device rule. The description adds nothing about the parameter, so the baseline of 3 applies.

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

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

The description is a noun phrase with no verb, so it never states that the tool *retrieves* device information, though that is strongly implied by the name and the listed fields. It enumerates the returned data (model, Android version, screen size, focused activity), which adds content beyond the bare name, but it does not differentiate itself from adjacent info siblings like battery or storage.

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 at all — no statement of when an agent should call device_info versus battery, storage, or list_devices. The only implicit cue is that the tool reports device state, which the agent must infer from the field 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 behavioral burden and does not meet it. It implies a state-changing kill of a live process but says nothing about irreversibility, unsaved state loss, whether a non-running package errors, or 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?

A single short sentence with zero filler and the action front-loaded. It is arguably too terse for the operation it performs, but there is no wasted structure.

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-annotation, no-output-schema mutation tool, an agent could call this correctly using the schema alone, but the description omits device-scoping context and any failure behavior. It is adequate but clearly thin relative to the operation's destructive nature.

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 50%: the device parameter is documented in the schema (including the omit-when-single-device rule) while package has none. The description partially compensates by stating the app is identified 'by package name', giving the format of the required parameter, but adds nothing about device targeting.

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 (force-stop) and resource (running app identified by package name), which is unambiguous on its own. It does not, however, distinguish itself from the adjacent launch_app sibling or clarify how it relates to list_packages, 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?

No when-to-use, when-not-to-use, or alternative is given. An agent must infer that this is the counterpart to launch_app and that it applies only to currently running apps, with nothing in the text confirming that.

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 say what happens if the app is already running, whether an existing instance is brought to foreground or restarted, what occurs if the package is not installed, or whether an error is returned – all relevant for a launch/mutation tool.

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

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

A single tight sentence with the verb and required input front-loaded and the optional parameter appended. 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?

No output schema exists, so the description should cover behavior and returns. For a simple device-control action the core intent is conveyed, but error/edge-case behavior and the interaction with device selection are left unstated, leaving it 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 coverage is 33% (only 'device' is documented), so the description must compensate for the undocumented params. It does add meaning for 'package' (identifies the app) and 'activity' (optional component to target), but gives no format examples or guidance on finding a package name via list_packages.

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 ('Launch an app by package name') with the optional activity scope, which is enough to distinguish it from siblings like open_url, force_stop, and list_packages. It does not explicitly name a sibling, 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?

There is no when-to-use guidance, no mention of prerequisites (device connection), and no routing against alternatives such as open_url for deep links or force_stop for restarting an app. Usage is only inferable from the tool name.

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 for a zero-parameter read-only listing the risk surface is small. 'List' implies a non-mutating read and 'visible to adb' hints at a live adb-server dependency, yet the description never states the read-only nature, error behavior when no devices exist, or whether it triggers a device scan.

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 short sentence with the resource and the scope qualifier front-loaded; nothing is padded or repeated.

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 trivial no-arg, no-output-schema listing tool the description is nearly sufficient: it says what is enumerated and that emulators are included. The only missing context an agent might want is the adb-server prerequisite and the empty-result case, which are minor for a tool of this complexity.

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

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

The tool takes zero parameters, so there are no parameter semantics to explain and the baseline of 4 applies. The description correctly does not invent or imply any arguments.

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

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

Specific verb+resource ('List Android devices') with a scope clarifier ('visible to adb, including emulators') that tells the agent what population is returned. It does not explicitly differentiate itself from the sibling device_info, which an agent might reasonably confuse with device enumeration.

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

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

Usage is only implied: an agent can infer this is the discovery step before calling per-device tools like device_info, battery, or screenshot. There is no explicit when-to-use statement, no mention of prerequisites (e.g. adb server running), and no routing to 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 behavioral burden. It does disclose meaningful behavior beyond the schema: the default third_party_only=true restricts results to third-party apps, and setting false includes system apps. However, it says nothing about ordering, result format, or whether the device must be specified first beyond what the schema states.

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 resource and immediately followed by the only non-obvious parameter guidance. No filler or repetition, though the opening fragment is elliptical rather than a full statement.

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 read tool with no output schema and no annotations, the description covers the essentials but omits return shape and any prerequisite ordering (e.g., call list_devices first to obtain a serial). It is minimally viable rather than complete.

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

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

Schema description coverage is 50%: device is documented in the schema, third_party_only is not. The description compensates by explaining the semantics and default effect of third_party_only, which is genuinely additive rather than a restatement. It adds nothing for device, whose meaning is already given.

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 the specific resource (installed package names) and the implicit list operation, which is enough to distinguish it from siblings like list_devices (hardware devices) or shell. It is a noun phrase rather than a verb+resource construction, so it is clear but not maximally sharp.

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 use this tool, when not to, or what alternative exists. The agent must infer that this is the tool for enumerating installed apps versus, say, shell with a pm command.

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

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

With no annotations present, the description carries the full behavioral burden. It never says whether this is a read-only snapshot, a live follow stream, how long it blocks, or whether it needs a connected device or adb permissions. 'Tail' hints at recency but leaves key behavioral traits unspecified.

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

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

Two short sentences, front-loaded with the core action and followed by the filter syntax hint. Nothing is wasted, though the second sentence is purely parameter help rather than an expansion of purpose.

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?

No output schema and no annotations mean the description should carry more: the return format of a 'line', whether results are bounded by the 'lines' param, and the blocking/streaming behavior are all unstated. The device param's own schema note helps, but the definition is only minimally complete for a device-log 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 only 33%, so the description needs to compensate. It does add real meaning for filter_spec by giving adb syntax ('*:E' for errors only), but 'lines' has no description anywhere and gets no help from the text. Partial compensation merits the baseline 3.

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

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

States a specific verb and resource ('Tail recent logcat lines'), which clearly identifies the tool as the Android log reader among siblings like shell and screen_dump. It does not explicitly contrast itself with siblings, but the resource name 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?

No when-to-use or when-not-to-use guidance is given; the agent must infer that this is for inspecting device logs. The only usage hint is the adb-style filter_spec example, which is a syntax detail rather than 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 behavioral burden. It discloses only that a URL opens in a browser or app, saying nothing about side effects, return values, device connection requirements, or error handling.

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 no filler or redundancy. It is appropriately sized for the tool's simplicity.

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 device action with no output schema and one schema-documented parameter, the description is minimally adequate. However, with no annotations, it omits key context such as the need for a connected device and what the action returns.

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 only 50%: the 'device' parameter is documented in the schema, but 'url' is a bare string with no description. The description does not clarify URL format, scheme handling, or device selection, so it fails to 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?

The description states a specific verb and resource ('Open a URL') plus the mechanism ('default browser or matching app'). It implicitly distinguishes from launch_app, which launches packages, but never names or contrasts any 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?

There is no guidance on when to use this tool versus launch_app, shell, or tap. The purpose implies a use case, but prerequisites and alternatives are left unstated.

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. 'Press' implies a state-changing input injection, but the description says nothing about whether a device connection is required, what happens on an unrecognized key, or whether keys like power/sleep are blocking or destructive. It only documents accepted input values, which is input semantics rather than behavior.

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

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

A single front-loaded sentence defining the action, followed by the necessary enumeration of valid values. The long value list is functional rather than padding, though a compactly formatted list would read more cleanly.

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

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

For a simple two-parameter input tool with no output schema and no annotations, the definition covers valid key values and links to list_devices via the schema. However, it omits error behavior for invalid keys and any indication of device-connection prerequisites, leaving gaps for an unannotated mutation-style 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 50%: the device parameter is documented in the schema, but the key parameter has no schema description. The description compensates well by listing all accepted key names and noting that raw KEYCODE_* names are also accepted, which is real added meaning for the undocumented 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 and resource ('Press a hardware key') and enumerates the accepted key names, so an agent immediately understands the operation. It does not explicitly contrast itself with sibling tools like tap or tap_text, which also inject input, 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 enumerated key list (the agent can infer this is for device navigation keys rather than screen coordinates), but there is no explicit when-to-use statement nor any guidance on choosing this over tap/tap_text/shell. Minimum viable 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?

No annotations exist, so the description carries the full behavioral burden. It does a good job disclosing the shape of the returned data, but it never mentions that output is truncated (the `limit` parameter defaults to 60 with a max of 200), which is critical behavior for a screen with many nodes, nor does it mention refresh/freshness 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?

Two tight sentences: the first front-loads what is returned, the second front-loads the operational rule. No filler, no repetition 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?

With no output schema, the description does the necessary work of enumerating the returned fields, which is exactly what an agent needs to parse a dump. The only meaningful gap is the unmentioned truncation/default limit behavior, which affects whether the agent sees the whole screen.

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 50%: `device` is documented in the schema, but `limit` has no description anywhere. The description never mentions `limit`, its default of 60, or that raising it returns more nodes, so it does not compensate for the coverage gap on the one parameter that governs completeness of the result.

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 ('Read the current screen') and enumerates exactly what is returned: text, content description, resource id, tap coordinates, clickable/scrollable flags. This cleanly separates it from the sibling 'screenshot' (image) and 'device_info' (device metadata).

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 this before tapping anything so you act on real element positions instead of guessing' gives a clear trigger condition and rationale. It stops short of explicitly contrasting with 'screenshot' or saying when a screenshot is preferable over a structured dump, so the alternative routing is only implied.

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

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

With no annotations, the description carries the full burden, and it does disclose the key trait that this is a write-to-disk operation producing a local PNG. It also reveals the return payload (path plus pixel dimensions) and, usefully, why it matters for coordinate scaling. It omits any permission or device-availability caveats.

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 operation front-loaded and the return-value rationale second; 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?

For a two-parameter tool with full schema coverage and no output schema, the description covers purpose and return content adequately. The main gap is the absence of routing guidance relative to screen_dump.

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

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

Schema description coverage is 100%, so both parameters (path, device) are already documented. The description only restates the save-to-path behavior and adds nothing about formatting or device selection semantics beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource ('Capture the screen and save it to a local PNG path'), which is clearly distinct from most siblings. It does not, however, differentiate itself from the confusingly similar sibling screen_dump, which an agent could easily mistake for this tool.

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

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

The description offers no when-to-use guidance, no prerequisites, and no comparison to alternatives like screen_dump. The only routing hint (omit device when one is connected) lives in the schema, not the description.

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

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

With no annotations, the description carries the full burden. It usefully discloses that coordinates are derived from the real screen size so it works on any resolution, but says nothing about the fact that this simulates an input gesture, whether it animates/waits for the scroll to settle, or what it returns.

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

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

Three short sentences, front-loaded with the action, then the usage hint, then the resolution note. No filler, though the middle sentence is narrower than a general usage statement.

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 3-parameter gesture tool with no annotations and no output schema, the description covers the mechanics but omits the scroll-vs-swipe relationship and any behavioral detail about gesture execution. 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 coverage is 67% ('amount' and 'device' are documented in the schema; 'direction' only has an enum). The description reinforces the meaning of 'direction' with a concrete example and explains that the travel amount is resolution-independent, but adds nothing for 'device' 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 and resource ('Scroll the dominant axis of the screen'), which is concrete and unambiguous. It does not, however, distinguish itself from the sibling tool 'swipe', which is the obvious adjacent gesture and could be confused with it.

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 offers a hint for one parameter value ('Use direction \'down\' to reveal content further down the page'), which implies intended usage, but gives no guidance on when to choose scroll over swipe, no prerequisites, and no exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. The 'escape hatch' / 'arbitrary' framing does signal that this is unrestricted and can reach beyond read-only operations, and it discloses the return channel (stdout), which is useful context. However, it says nothing about destructive potential, required permissions, timeouts, exit-code/error behavior, or output truncation — significant gaps for a tool that can execute anything.

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

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

Two sentences with zero waste; the escape-hatch scope is front-loaded before the example. 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?

For a low-complexity escape-hatch tool with no annotations and no output schema, the description covers purpose, routing guidance, and the return channel. It is close to complete, though an agent would still benefit from knowing about timeouts, error/exit-code handling, and that unrestricted commands may mutate device state.

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

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

Schema description coverage is 50%: 'device' is documented in the schema, but 'command' has no description anywhere. The example command string usefully illustrates the expected syntax (bare command, seemingly without the 'adb shell' prefix), which is marginal added value, but it does not fully compensate for the undocumented required 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 and resource ('run an arbitrary adb shell command and return stdout') and frames it precisely against the sibling set as an 'escape hatch' for anything the dedicated tools don't cover. An agent can immediately tell this is the raw/unrestricted fallback versus tap, swipe, logcat, etc.

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

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

Explicitly says when to use it ('anything not covered by the dedicated tools') and reinforces the rule with a concrete allowed example ('settings get secure enabled_accessibility_services'). The condition that selects this tool over its 17 siblings is stated, not inferred.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies a read-only query but says nothing about return format (bytes, percent, used vs free breakdown) or what happens when the device argument is omitted and multiple devices are attached.

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 short sentence with zero waste, and the scope qualifier (/data partition) is front-loaded. It is appropriately terse for a simple query 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 one-parameter, no-output-schema read tool, the description covers the subject but not the return shape or units. Adequate but with a clear gap for an agent trying to interpret results.

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

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

Schema coverage is 100% and the single optional device parameter is fully documented in the schema, including the omit-when-one-device rule. The description adds nothing beyond that, so the baseline 3 applies.

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

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

States a specific resource (storage) and narrows it to the /data partition, so the agent knows exactly what is measured. The verb is implied rather than stated and it does not reference siblings, but none of the siblings overlap with this concern, so confusion is unlikely.

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 alternatives named. The agent can infer this is a read-only storage check, but the description never says when this is preferable to device_info or battery.

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

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

No annotations are provided, so the description carries the full burden. It discloses only that duration_ms governs drag speed; it omits that this injects real touch input on a device (which can trigger destructive UI actions), whether it is cancellable, how the target device is chosen, and what is returned.

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 zero padding and the core gesture semantics front-loaded ahead of the tuning detail. It is very short relative to a 6-parameter tool, but nothing written 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 6-param device-gesture tool with no annotations, no output schema and 17% schema coverage, the description is under-specified. An agent gets no guidance on device targeting, return behavior, or disambiguation from 'scroll' and 'tap'.

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 17% (only 'device' is documented), so the description must compensate. It does map x1,y1→x2,y2 as start/end points and adds real meaning to duration_ms ('increase for slow drags'), but leaves the device parameter and duration_ms units/default 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+resource ('Swipe/drag') with the coordinate endpoints, which is concrete and unambiguous. However, it does not differentiate from the sibling 'scroll', which is a closely overlapping gesture tool an agent would plausibly confuse it with.

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?

Only guidance offered is 'Increase duration_ms for slow drags', which is a tuning hint rather than a when-to-use rule. It never says when to prefer swipe over scroll or tap, nor when the optional device parameter must be supplied, leaving 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 does not disclose that this injects a synthetic input event (a mutating action), whether it blocks until the tap completes, what happens on out-of-bounds coordinates or a disconnected device, or any failure/return behavior.

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

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

A single nine-word sentence with zero filler, and the distinguishing detail (absolute pixel coordinates) is front-loaded 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?

For a three-parameter tool with no output schema, the definition is minimally adequate but omits the device-selection constraint (only covered in the schema for the optional device param) and any hint about coordinate validity or post-tap 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 only 33% – x and y have no descriptions at all, so the description must compensate. 'Absolute pixel coordinates' does add real meaning for x/y (pixel units, absolute rather than normalized or relative), but gives no ranges, origin reference, or screen-size dependency, leaving the semantics partially documented.

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

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

States a specific verb (tap) and target (the screen) plus the coordinate system (absolute pixels), which is enough to distinguish it from gesture siblings like swipe and scroll. It stops short of naming tap_text, the closest sibling, so the agent must infer the text-vs-pixel split itself.

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

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

Usage is only implied: 'absolute pixel coordinates' hints that this is for when you already know exact coordinates, and tap_text is the obvious alternative when you don't, but neither the alternative nor the condition is stated. No exclusions, prerequisites, or coordinate-origin guidance 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?

With no annotations, the description carries the full burden, and it does disclose two useful traits: it performs a fresh screen dump (a latency/side-effect cost) unless the previous dump is reused, and it taps the element's centre rather than an arbitrary point. It omits failure semantics (no match found, multiple matches), any permission/accessibility-service requirements, and whether the dump is cached across calls.

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 differentiator. Every clause carries information; nothing is redundant or padded.

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 coordinate-free tapping tool with no annotations and no output schema, the description covers the core mechanism and the screen-dump cost, but leaves notable gaps: behavior when no element matches, disambiguation beyond the schema's 'nth', and the meaning of 'exact'. Adequate but not 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?

The description adds real meaning to 'text' by clarifying it matches visible text, content description, or resource id, which goes beyond the schema's thin 'Label to look for'. However, the 'exact' parameter has no description in the schema and receives no explanation here (exact vs substring matching), leaving one of four parameters semantically unaddressed at 75% coverage.

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

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

States a specific verb and resource ('Find an element by its visible text, content description or resource id and tap its centre') and immediately distinguishes itself from the sibling 'tap' by framing itself as the robust alternative to coordinate guessing. An agent can route between tap and tap_text 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?

Explicitly positions this as the preferred over-coordinate approach ('the robust alternative to guessing coordinates'), which tells the agent when to pick it over 'tap'. It also notes the screen-dump behavior. It stops short of stating exclusions or fallback behavior (e.g., what to do when no match is found), so it is clear context but not complete when/when-not 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 full burden. It usefully discloses that spaces and shell metacharacters are auto-escaped, which affects how callers pass input, but omits whether text replaces or appends to existing content and what happens when no field is focused.

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

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

Three short imperative sentences, front-loaded with the action and immediately followed by the prerequisite and the escaping caveat. 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 simple two-parameter, no-output tool, the description covers the action, the prerequisite step, and an important input-handling behavior. Only edge cases (no focused field, replace vs append) 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 coverage is 50% — the required 'text' parameter has no schema description. The description partially compensates by noting escape handling, but says nothing about expected text format, length limits, or newline behavior, so it adds only marginal meaning.

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

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

States a specific verb and target: 'Type into the currently focused text field.' This clearly separates it from tap_text (which taps an element) by scoping it to an already-focused field, though it doesn't name a 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?

'Tap the field first' gives an actionable prerequisite that tells the agent the required prior step, implicitly routing it to tap/tap_text. It stops short of explicit when-not guidance (e.g., what to do if no field is focused).

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