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

No annotations are provided, so the description carries the full burden. It states that the tool evaluates and returns ok + per-condition detail, and mentions optional waiting, but does not disclose side effects, permission needs, error behavior, or what happens if conditions are not met within a timeout.

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

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

The description is a single compact sentence with the core action front-loaded, followed by return information. Every phrase contributes 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?

For a 3-parameter tool with no annotations and 0% schema description coverage, the description is too sparse. It does not explain what a 'mapped screen' is, what conditions are evaluated, how 'device' affects the operation, or basic behavioral context. The output schema covers return values, but input semantics and safety context remain 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% for 3 parameters. The description indirectly covers the 'screen' parameter via 'mapped screen' and the 'timeout' parameter via 'optionally waiting', but the 'device' parameter is completely unexplained, and no format or expected values are given for any 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 'Evaluate' and resource 'mapped screen', and adds that it returns ok + per-condition detail. It implies differentiation from generic look/screenshot tools by referring to a mapped screen, 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?

No explicit guidance on when to use this tool vs siblings like 'look' or 'screenshot'. The parenthetical 'optionally waiting' hints at a use case for waiting on conditions, but there is no when/when-not 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?

No annotations are provided, so the description carries the full burden. It does hint at behavior by noting 'which serials adb sees right now' (a live, dynamic snapshot) and the devices.yaml config source, which implies a non-mutating read. However, it never explicitly states read-only semantics or what happens if adb is unavailable.

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 no waste and the key content front-loaded ('Registered devices'). It is arguably under-specified rather than over-long, but every phrase contributes 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-value explanation is not needed, and the no-param schema is trivial. The remaining gap is contextual: the description does not clarify what 'the default' means or how an agent should act on the returned config, leaving the practical purpose slightly under-defined for an agent choosing among many siblings.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is 100% and the input object is empty.

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 fragment rather than a verb+resource statement, but it does enumerate the returned content: registered devices from devices.yaml, the default device, and currently adb-visible serials. An agent can infer this is a device-inventory/status read, though 'the default' is left dangling and unexplained against siblings that are all action 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?

There is no when-to-use guidance at all — no statement of when an agent should consult device inventory versus calling shell or launch directly. The relationship to sibling tools like launch or check is entirely 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 burden. It does not say whether a device must be targeted, which device is used when 'device' is omitted, whether the press is blocking, or what happens on an invalid key — all significant for a state-mutating input tool.

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

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

A single short sentence with the action front-loaded and the value list immediately after. The trailing ellipsis is a minor flaw since it hints at additional valid keys without naming them.

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 key set is covered. Still missing: the meaning of the 'device' parameter, whether it is required in practice, and any failure behavior — gaps that matter for a device-input 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?

Schema description coverage is 0% and the 'name' property has no enum, so the description's list of valid keys is genuinely load-bearing. However, it never explains the optional 'device' parameter or what its null default selects, 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 (press) and resource (a key) and enumerates the accepted key values, so an agent understands this injects a hardware/system key event. It is distinguishable from siblings like tap and type_text, though it never names 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?

The enumerated key list implies usage (device navigation and system buttons), but there is no explicit when-to-use, no when-not-to-use, and no pointer to alternatives such as type_text for text entry or shell for other input.

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 explain whether the app must be installed, what happens if it is already running, what stop_first does, device-selection behavior, or whether the call waits for launch completion.

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. However, its brevity reflects under-specification rather than efficient coverage of the tool’s behavior.

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 do not need explanation. Still, for a three-parameter action tool with no annotations and no parameter descriptions, the definition omits too much about device targeting and stop_first behavior 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 description coverage is 0%, and the description only clarifies the package parameter implicitly. It says nothing about the device or stop_first parameters, 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?

The description states a specific verb and resource: starting an app by package name. It is clear what the tool does, though it does not distinguish itself from nearby automation tools such as tasker_run or run_routine.

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 no explicit when-to-use guidance, no alternatives, and no prerequisites or exclusions. The agent must infer that this is the tool for launching apps rather than running tasks or routines.

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 implies a read-only enumeration but never states read-only semantics, pagination, ordering, or whether the result is scoped to the current workspace/session. Only the returned payload shape (maps + anchors + screens) is touched on.

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 fragment with no padding, and the key content (maps, anchors, screens) is front-loaded. It is terse almost to a fault, 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?

With an output schema present, the return structure need not be explained, and a zero-parameter list tool is simple. Still, with no annotations the description should say at minimum that this is a non-destructive read and what its scope is; that context is 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?

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate beyond confirming no filtering input is expected.

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?

Combined with the name 'list_maps', the fragment 'All maps with their anchors and screens' tells the agent this enumerates map objects and includes their anchors/screens. However, it is a noun phrase with no verb and no statement of scope, and it does not distinguish itself from siblings like list_routines beyond the resource noun.

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 call this versus alternatives — for example, whether it should precede tap_anchor or save_anchor, or whether maps are workspace-scoped. The agent must infer usage entirely from the 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?

With no annotations, the description carries the full behavioral burden, yet it does not say whether this is a safe read, whether it is paginated, how many routines are returned, or what happens on an empty workspace. It adds one genuinely useful fact (stages are resume points), but that is a domain gloss rather than operational transparency.

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

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

It is one short fragment with no padding, but it is under-specified rather than genuinely concise — a complete sentence naming the verb and the sibling relationship would cost the same space. The parenthetical clarification of 'stages' is the one part that clearly earns its place.

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

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

The tool is simple (no params, output schema present so return values need not be described) and the parenthetical explains the domain term 'stage'. However, with no annotations and a discoverable sibling like run_routine, the omission of any read-only assurance or selection guidance leaves 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?

The schema has zero parameters, so there is nothing parameter-wise for the description to explain; the baseline for a no-param tool is 4. The mention of 'params and stage names' describes the returned entity's shape rather than inputs.

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 ('Known routines with params and stage names') rather than a verb+resource statement; the verb 'list' is only inferable from the tool name. It does convey the resource and its useful contents, but it never states plainly that this retrieves/enumerates routines, leaving the purpose implied rather than declared.

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, and the obvious sibling run_routine — which the agent must distinguish this from — is never mentioned. The only hint of usage is the parenthetical about stages being resume points, which is semantic information 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 burden. It discloses the output line format (#idx class 'text' id=res @(x,y normalized) [tap]), which is genuinely useful behavioral context, but says nothing about read-only semantics, how 'limit'/'everything' affect results, or what happens with multiple devices. Significant gaps remain for a zero-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?

The description is short and front-loads the purpose, which is good. But the second sentence is an unexplained format legend ('[tap]' is never defined) that reads as cryptic shorthand rather than self-contained guidance.

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 re-explained, but for a core inspection tool with three fully undocumented parameters and no annotations, the description is far too thin to let an agent invoke it correctly (e.g., when to set 'everything' or how to target a 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?

Three parameters (limit, device, everything) with 0% schema description coverage, and the description mentions none of them. It does not explain pagination via limit, device targeting, or what 'everything' expands, so the parameters are 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?

The description names the resource ('current app + compact UI node list') and effectively tells the agent this is a text-based UI inspection returning nodes, which distinguishes it from the image-based 'screenshot' sibling. However, it uses no clear verb and the phrasing 'Look' plus the cryptic format legend leaves the actual action somewhat vague.

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 alternatives. The sibling set (tap, tap_node, screenshot, devices) strongly implies this is the node-discovery step preceding tap_node/tap_anchor, but the description never says so, leaving the agent to infer the workflow.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses that uiautomator is stopped and accessibility returns, but says nothing about permissions, reversibility, side effects, or what happens when the target process is not running.

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

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

The description is a single front-loaded sentence with no filler or redundant restatement. Every phrase contributes to describing the action and its outcome.

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?

Although an output schema exists, there are no annotations and no parameter descriptions in the schema. The description omits usage conditions and parameter semantics, so an agent lacks key context needed to invoke the tool correctly in all situations.

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

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

Schema description coverage is 0% for the single optional 'device' parameter. The description only says 'on the device' generically and does not explain the parameter's string/null options, default behavior, or whether omitting it targets the 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?

The description states a specific verb ('Stop') and resource ('uiautomator') plus the intended effect of restoring Tasker/AutoInput accessibility. It does not name or contrast itself with any sibling tool, but an agent can tell what action this tool performs.

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

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

The phrase 'so Tasker/AutoInput accessibility comes back' implies a use case: calling it when accessibility needs to be restored after uiautomator is active. However, it gives no explicit when-to-use, when-not-to-use, or alternative-tool 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 of behavioral disclosure. It usefully states what is returned on failure (failed stage, snapshot dir, resume hint), but omits side effects, required permissions, idempotency, and whether running a routine is mutating or destructive—critical for a 'run' 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 sentences with no filler, and the failure behavior is front-loaded after the core purpose. It is structurally efficient, though arguably too terse given the four 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?

The existing output schema covers return values, so the description need not explain them. However, input semantics are entirely absent and no usage context is provided. For a four-parameter execution tool with zero schema coverage and no annotations, this is 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 description coverage is 0% and the description names no parameters. It loosely alludes to a 'resume hint' but never maps it to the resume_from parameter, and says nothing about name, device, or params, leaving all four 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 clear verb 'Run' and resource 'routine', but provides no scope or differentiation from siblings such as tasker_run or list_routines. An agent cannot tell from the description why it should choose this tool over tasker_run.

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 prerequisites, and no alternatives named. The sibling list_routines is presumably how routines are discovered, but the description does not say so. Usage is only implied by 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 behavioral burden. 'Remember' implies persistence, but it never states whether saving under an existing name overwrites, whether the anchor is scoped per map/device, or whether any prerequisites apply. For a write tool with zero annotation coverage, this is a real 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?

Two tight sentences with the core action front-loaded and the input variants following. No filler, though the terseness contributes to the coverage gaps rather than being purely economical.

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 7-parameter mutation tool with no annotations and 0% schema coverage, the description is too thin. Missing are the map_name scoping semantics, overwrite behavior, and how this connects to `tap_anchor`/`look` in the workflow.

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 7 parameters, so the description must compensate. It touches x, y (as 'normalized'), and node, but leaves map_name, name, notes, and device entirely unexplained, including the required map_name scope. It covers only part of the surface it needs to.

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 ('remember') and resource ('tap target'), and clarifies the two source forms: a `look` node or raw normalized x,y. That is enough for an agent to understand it persists a tappable location. It stops short of distinguishing itself from siblings like `tap_anchor` (which presumably consumes what this saves).

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 implies two usage modes ('From a `look` node ... or raw normalized x,y'), which is useful context for how to call it. But there is no explicit when-to-use guidance, no statement of the relationship to `tap_anchor`, and no mention that a map must already exist via `list_maps`.

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 one important behavior: output is downscaled to save tokens, which warns the agent about reduced fidelity. It does not cover permissions, device selection, or default behavior, leaving meaningful gaps for a capture 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 with no wasted words; the primary purpose and the routing condition are both front-loaded.

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

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

For a zero-required-parameter, no-annotation, no-output-schema tool, the description adequately covers what it returns (PNG) and when to use it. It falls short on parameter meaning, which is the only other thing an agent needs to call it well.

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 (`scale`, `device`) is explained in the description. 'Downscaled' loosely gestures at `scale`, but the default value, units, and the meaning of `device` are 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?

Names the resource (screen) and output format (PNG) unambiguously, and explicitly distinguishes itself from the sibling `look`. The verb is implicit (a noun phrase rather than 'capture the screen'), which keeps it just short of a perfect verb+resource statement.

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 an explicit routing rule against a named alternative: use this when `look` can't see the target, with concrete examples (games, canvases). The inverse condition is implied strongly enough that an agent knows to prefer `look` normally.

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. 'Raw' suggests unparsed, unrestricted command execution with destructive potential, but the description does not warn about side effects, permissions, device selection, or what state the command runs against — significant omission for an arbitrary-command executor.

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, front-loaded sentence with zero filler. Its brevity is stylistically clean, though here it borders on under-specification rather than economy.

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 raw arbitrary-command tool with no annotations and no parameter documentation, the description is far too thin — an agent gets no safety, scoping, or device-targeting context.

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

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

Schema description coverage is 0%, so the description must compensate and does not. The word 'adb shell' loosely contextualizes `cmd` as a shell command string, but the `device` parameter (which device the command targets when null-defaulted) is entirely unexplained 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 the mechanism ('raw adb shell') and frames it as an 'escape hatch', which distinguishes it in spirit from the structured interaction tools (tap, swipe, type_text). However, it never says what resource or device it operates on, and the differentiation from siblings 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?

The phrase 'escape hatch' hints this is a fallback for cases the structured tools don't cover, but there is no explicit when-to-use or when-not-to-use guidance, and no sibling is named as the preferred alternative for common 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 behavioral burden. It says nothing about whether the gesture blocks until complete, how duration is interpreted, whether a device must be selected first, or what the return payload contains. For an input-simulating mutation against a UI, this leaves key behavior undisclosed.

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 the trailing example earns its place by demonstrating real argument values. 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 described. But with zero annotation coverage and 0% schema description coverage, the description omits meaningful gaps: duration units/default behavior and the purpose of the device parameter. For a 6-parameter gesture tool this is thin.

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. It usefully clarifies that coordinates may be fractions or pixels and the example pins the positional order (x1,y1,x2,y2), which covers the four required params. The 'device' and 'duration' parameters are left entirely unexplained, so 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 verb+resource ('Swipe between two points') with the coordinate space clarified (fractions or pixels). It is distinguishable from the gesture siblings (tap, key, type_text), though it does not explicitly name which alternative to prefer.

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 worked example ('Scroll down = swipe(0.5,0.75,0.5,0.25)') implies a common usage and disambiguates the argument order, which is genuinely helpful. However, there is no explicit when-to-use versus tap/tap_node, and no prerequisites such as needing an active device session.

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 supplied, so the description carries the full behavioral burden. It reveals only the coordinate interpretation convention, saying nothing about whether the tap blocks, waits for element visibility, error conditions, or that it mutates UI state; an output schema exists so return values are at least covered.

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 terse sentences with no padding beyond the redundant "Tap." opening. The substantive coordinate rule is stated directly and is easy to front-load 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?

For a UI-mutation tool with zero annotations, zero schema descriptions, and three close sibling tools (tap_node, tap_anchor), the definition is too thin. It omits the device parameter, selection guidance, and any behavioral context, which an agent needs to invoke 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 coverage is 0%, so the description must compensate. It usefully explains x/y as screen fractions in [0,1] or pixels and marks fractions as preferred, but the third parameter, device, is never mentioned in either schema or 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?

"Tap." simply restates the tool name, so the description itself is tautological. The only substantive content is coordinate formatting, and it never distinguishes this coordinate-based tap from the near-identical siblings tap_node and tap_anchor.

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 a parameter format preference (floats over pixels) but gives no guidance on when to choose this tool over tap_node, tap_anchor, or swipe. No context, prerequisites, or exclusions are provided.

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

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

With no annotations, the description carries the full burden, and it does disclose the one non-obvious behavior: resolution order ('selector first, saved point as fallback'). However, it says nothing about what happens when the anchor is missing, whether the tap can fail silently, or the effect of timeout/device.

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

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

A single front-loaded sentence with no filler, and the ref syntax is presented before the resolution detail. It is arguably too terse for a 3-parameter tool, but nothing in it 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 values need not be described, but with no annotations and 0% parameter description coverage, the definition leaves `device`, `timeout`, and failure behavior entirely unexplained. For a mutation action (~tap) this is under-specified.

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 3 parameters. The description explains only the `ref` value format ('map:name'); `device` and `timeout` (with its 3-second default) are undocumented in both schema and description, so 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?

Names a specific verb ('tap') and a specific resource ('a mapped anchor'), with the ref format 'map:name'. This is distinguishable from the bare `tap`/`tap_node` siblings by scope, though the description never explicitly contrasts 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?

No when-to-use or when-not-to-use guidance and no named alternative, despite `tap`, `tap_node`, `swipe`, and `save_anchor` being close siblings. The ref format implies a saved map must exist, but that inference is left to the agent.

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 bears full behavioral burden. It reveals only that the node index comes from the last `look` on the device, but says nothing about side effects, error conditions (e.g., no prior look, invalid index), permissions, or what happens after the tap. This is a significant gap for an interactive UI 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, front-loaded sentence with no filler. It communicates the action, the target, and the source in minimal words, which is exactly what conciseness should achieve.

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. The core operation is clear enough for an agent that already knows what a `look` result contains, but the description leaves the `device` parameter undefined and does not clarify what a 'node' is or what happens when no prior look exists. It is minimally adequate for a simple tool but has 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%, so the description must compensate. It hints at the `index` parameter ('node #index') and the `device` parameter ('on this device'), but does not explain the expected format of `device`, the meaning of a null default, or exactly what range or source of node indices are valid. The added meaning is marginal.

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 ('Tap'), resource ('node #index'), and source ('from the last `look` on this device'), which clearly identifies the operation and ties it to a sibling tool's output. It does not explicitly distinguish itself from `tap` or `tap_anchor`, but the node-index reference is specific enough for an agent to select it correctly in most cases.

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

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

The description implies a prerequisite (a prior `look` must have been run) but offers no explicit guidance on when to use this tool versus `tap`, `tap_anchor`, or `screenshot`. There are no stated alternatives, exclusions, or conditions beyond the implicit reliance on the last look.

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 full burden. It discloses what is returned (matching tasks with actions and calls), the presence of hazard flags, and the safety consequence of those flags — genuinely useful behavioral context beyond the schema. It does not state read-only safety explicitly, permission/auth needs, or that the search is a substring match on the query only.

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 core capability followed by the return shape and the safety rule. No filler; only minor friction from the backticked command reference which may not mean much to an agent.

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

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

An output schema exists, so return values needn't be restated, and the hazard-flag semantics are covered. However, with 0% parameter description coverage and no annotations, the description leaves the agent without guidance on limit/pagination or the project filter, which is a real gap for a 3-parameter search 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% and none of the three parameters (query, project, limit) are documented. The description only indirectly implies the query parameter is a name substring and gives no meaning for project or limit (default/pagination behavior), leaving most parameter semantics 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 (search) and resource (the Tasker catalog built by `dgm catalog`) with the matching rule (task/profile name substring). It also explicitly distinguishes itself from tasker_run, which fires tasks, so an agent can separate the two without opening schemas.

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

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

Gives clear context (look things up in the catalog) and an explicit prohibition with rationale ('Never fire a task marked hazard; tasker_run refuses them anyway'), naming the alternative tool. It stops short of saying exactly when to prefer this over tasker_run (e.g. 'call this first to resolve a task name'), so not a full 5.

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

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

With no annotations, the description carries the full burden; it does add meaningful context by disclosing the broadcast mechanism and the DGM Dispatch profile requirement (an auth/setup constraint the schema cannot express). It does not say whether the call blocks, how failures surface, or what a broadcast actually does if the target app is absent, which are exactly the traits an agent needs here.

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 action, no filler. The trailing parenthetical pushes key setup information into a docs reference rather than stating it inline, which is a small structural weakness.

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 4-parameter, no-annotation tool the description omits parameter meaning, blocking behavior, and failure modes. An agent could invoke it only by guessing at device/params/wait_result.

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

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

Schema description coverage is 0% across four parameters, so the description must compensate and largely does not: it implies 'task' but says nothing about device, params, or wait_result (including the notable default of 0). The profile requirement is a useful side note but not parameter semantics.

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

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

States a concrete verb+resource ('Fire a Tasker task via broadcast'), which is specific enough to distinguish it from tasker_lookup (read) and run_routine (different subsystem). It does not explicitly name its closest sibling tasker_lookup, 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 one real prerequisite ('needs the DGM Dispatch profile') plus a docs pointer, which is useful invocation context. It never says when to prefer this over tasker_lookup or when a task should be run via another path, so it stays at implied usage.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not say whether existing text is replaced or appended, how the target device is chosen, whether text is committed/sent, or what happens if no field is focused. Only the bare action is conveyed.

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

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

A single, front-loaded sentence with no wasted words. It is efficient, though its brevity reflects under-specification rather than meaningful concision.

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 with zero annotations, 0% parameter coverage, and an undocumented 'clear' flag, the description is far too thin for a mutation-style UI control tool. It omits the device/focus prerequisites an agent needs to call it correctly.

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

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

Schema description coverage is 0% across 3 parameters, and the description mentions none of them. The 'clear' parameter (whether to erase existing content before typing) and 'device' targeting are fully undocumented in both places, leaving an agent to guess at their 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 focused field'), which is a clear action. However, it gives no differentiation from siblings like 'key' (which also inputs text/keys) or 'tap', so an agent cannot confidently choose between them. Purpose is understandable but underspecified.

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 'key', 'tap', or 'tap_node', nor any prerequisite such as first focusing a field. The phrase 'focused field' faintly implies a precondition but is never stated as an instruction.

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 — the workspace and its contents are 'created and seeded if missing,' implying a side effect on first access — but says nothing about permissions, what the seeded contents are, or idempotency.

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, and the key resource-location fact is front-loaded. Slightly telegraphic but appropriately sized for a simple tool.

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

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

An output schema exists, so return values need not be explained. Still, with no annotations and an ambiguous action, the description leaves the agent unsure what calling the tool actually does — a notable gap for even a zero-parameter tool.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate.

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 identifies the resource ('where devices.yaml, maps/ and routines/ live') but never states the tool's action or verb — an agent cannot tell whether invoking it returns a path, performs setup, or both. It is not pure tautology (it adds file-location detail beyond the name/title), but the purpose remains vague.

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?

'Edit devices.yaml there' is an implied usage directive, giving the agent some sense of what to do with the workspace. However, there is no explicit when-to-use-vs-alternatives guidance relative to siblings like devices, list_maps, or list_routines.

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