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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It does state that it returns an error if the element is found, which is a key behavior. However, it does not mention the type of error, the return value on success (e.g., a pass message), or the timeout behavior. For a simple assertion tool, this is reasonably transparent but incomplete for an agent expecting to handle outcomes.

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

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

Two sentences, each earning its place. The core purpose is stated first, and the key behavioral consequence (returns an error if found) is immediately captured. No filler or redundant phrasing, making it highly efficient.

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

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

This is a simple tool with optional parameters and no output schema, so the description covers the essential purpose and key behavioral effect. The parameters are fully documented in the schema, so the agent can invoke it correctly. However, it doesn't specify the return type on success (e.g., a boolean true or a pass message), which is a minor gap for an agent that needs to interpret the result. But given the simplicity, the description is largely complete.

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

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

The schema already documents all three parameters with examples and regex guidance, and with 100% coverage, the description adds nothing extra about parameter meaning. The description does not describe which combination of text and resource_id is required (e.g., AND/OR logic) or whether both can be used together. However, the schema alone is sufficient for basic parameter semantics.

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

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

The description clearly states that the tool asserts an element is NOT visible, which is distinct from its sibling assert_visible. It uses a specific verb ('Assert') and resource (element visibility), and the note about returning an error if found adds clarity. This is sufficient to distinguish it from assert_visible and other assertion tools.

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

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

The description implies when to use it: when you expect an element to be absent, and it contrasts with assert_visible, but it doesn't explicitly state 'use assert_visible when you expect the element to be present' or list other alternatives. Sibling tools like is_element_visible and find_element exist, but no explicit routing guidance is given. This is clear context but 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?

With no annotations, the description carries the full burden of explaining behavior, but it does not disclose whether the assertion waits, fails the test, returns a boolean, or throws an error. The word 'Assert' implies a check, but the observable effects and failure semantics are left unspecified.

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

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

The description is a single, tightly worded sentence that immediately conveys the tool's purpose. There is no filler or redundant information; every word contributes to understanding.

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 an assertion tool with no output schema and no annotations, the description lacks critical context about success/failure behavior, waiting semantics, and how it differs from wait_for_text. An agent cannot fully predict the tool's runtime behavior from this definition alone.

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 the baseline is 3. The description essentially restates the relationship between resource_id and expected_text without adding new meaning beyond the schema, so no higher score is warranted.

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

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

The description clearly states a specific verb ('Assert') and resource ('an element with a given resource ID contains the expected text'), making the tool's core function evident. It does not explicitly distinguish it from siblings like wait_for_text or assert_visible, 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 guidance is provided about when to use this tool versus alternatives such as wait_for_text, is_element_visible, or assert_visible. The description only states what the tool does, not under what conditions it should be chosen or avoided.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses an error when the element is not found, but leaves undefined what happens when the element exists but is not visible, despite 'visible' being the core concept. It also does not state whether the check is immediate or has a timeout, which matters given the wait_for_element sibling.

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

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

Two short sentences with no filler. The primary assertion is front-loadedтное and the error condition is stated immediately, making the tool's purpose easy to scan.

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

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

No output schema and no annotations mean the description should clarify success returns and ambiguous invocation cases. It does not say what a successful assertion returns, and because all parameters are optional in the schema, it does not warn that some locator is still needed. The distinction between 'not found' and 'not visible' is also unresolved, leaving an agent without enough information to confidently invoke the 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 100%, so the schema already explains text, resource_id, and device_id including regex semantics. The description adds no parameter-level meaning beyond referring to 'an element', so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Assert') and the target condition ('element is currently visible on screen'), and it identifies the failure mode (returns an error if not found). It does not explicitly contrast with siblings like assert_not_visible or is_element_visible, so it stops short of full differentiation.

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

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

There is no guidance on when to use this tool versus alternatives such as is_element_visible, wait_for_element, or assert_not_visible. No conditions, exclusions, or when-not-to-use guidance is provided; only the word 'assert' weakly implies a validation context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Audit' strongly implies a read-only operation, and the mention of 'Compose testTag fix' suggests it provides advice rather than applying changes. However, the description does not explicitly state that it never modifies anything, nor does it describe the output or return value. It also doesn't clarify any prerequisites (e.g., a connected device) or side effects. Given the absence of annotations, this is a moderate gap; the description gives some context but not full transparency.

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

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

The description is a single, well-structured sentence that front-loads the core purpose and then details the counts and the Compose fix. It includes the platform caveat and documentation reference without fluff. Every clause earns its place: the main action, the specific metrics, and the platform-specific note. It is concise (~50 words) and immediately usable, earning a top score.

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

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

The tool is relatively simple (one optional parameter, no output schema), but the description omits important context: it does not describe the output format (does it return a report? JSON? a count?), the meaning of 'device_id', or any prerequisites like a connected device or active screen. It does provide platform guidance, but the missing parameter semantics and return-value information leave the description incomplete for a thorough understanding. Given the simplicity, it could easily have been more complete, so a 3 is appropriate.

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%, meaning the input schema provides no descriptions for the single parameter 'device_id'. The tool description does not mention 'device_id' at all, so it adds no meaning beyond the schema's bare name. Since the description must compensate for low schema coverage, its failure to explain what 'device_id' refers to (e.g., an Android device identifier) leaves the agent guessing. This is a significant gap for even one parameter, so a score of 2 is warranted.

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 ('Audit'), a clear resource ('the current screen'), and a specific goal ('locator stability'). It breaks down exactly what it does: counts how many actionable elements have a stable id, which don't, and mentions the Compose testTag fix. This clearly distinguishes it from all sibling tools, which are actions (tap, swipe, etc.) or queries (dump_ui, find_element). No ambiguity about its purpose.

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

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

The description gives clear platform context: 'Android; on iOS, id-coverage is not meaningful — see docs/ios-testing.md'. This serves as an explicit exclusion for iOS and directs to documentation. However, it does not explicitly compare this tool to any alternative tools (like dump_ui or describe_element) or state when to use it vs. them. It implies usage (when you need to audit stability) but lacks explicit 'use this instead of X when...' guidance. Overall, it provides solid context without enumerating alternatives, earning a 4.

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

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

With no annotations provided, the description carries the full burden, and it does disclose the key behavioral trait: this is a destructive operation that wipes app data, explicitly naming cache, databases, and shared preferences. It does not cover irreversibility or side effects on a running app, but the core destructive scope is clear.

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

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

The description is one concise, front-loaded sentence with a parenthetical clarifying exactly what data is cleared. Every word earns its place, and there is no redundant 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?

The description is sufficient for a simple two-parameter destructive action, and the schema covers inputs. However, given the large set of sibling tools, it does not provide any guidance on choosing this over uninstall_app or force_stop, nor does it indicate what return or confirmation the caller should expect.

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 package and device_id are already documented in the schema. The description adds no extra parameter semantics, but none are needed beyond what the schema provides.

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

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

The description clearly states a specific action ('Clear all data') and a specific resource ('for an app'), with explicit examples of what is affected: cache, databases, and shared preferences. However, it does not explicitly differentiate itself from sibling tools like uninstall_app or force_stop, which also operate on app state.

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

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

No guidance is given for when to use this tool versus alternatives such as force_stop or uninstall_app. The description does not mention prerequisites, destructive consequences, or when a less invasive operation would be more appropriate.

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

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

No annotations are present, so the description carries the full behavioral burden. It states the connection mechanism but does not disclose side effects, success/failure behavior, prerequisites such as the device already listening on the port, or whether the connection persists.

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 no filler, and the Android and wireless-debugging qualifiers add useful context. It is appropriately concise, though it has no structured detail beyond the core 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?

Given the low parameter complexity and complete schema coverage, an agent can likely invoke the tool correctly. However, the description omits when the connection should be established, what a successful connection looks like, and what errors might occur, which are meaningful gaps for a stateful connection action.

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 the schema already documents both parameters and the default port. The description adds only the TCP/IP/wireless debugging context, which is helpful but does not materially extend the parameter definitions.

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

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

The description names a specific action ('Connect'), a resource ('a device over TCP/IP (wireless debugging)'), and scopes the tool to Android. It is clear and not tautological, though it does not explicitly contrast with siblings such as list_devices or device_info.

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

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

There is no guidance about when to use connect_device versus alternatives, when not to use it, or what setup is required first. The wireless-debugging context implies a use case, but the description never states it.

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

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

No annotations are present, so the description carries the disclosure burden. It clearly declares 'Read-only' upfront, explains that it returns one block per match including the flow-selector `index`, and how ambiguity is handled (shows all candidates instead of picking the first). It also notes the link to flow selector qualifiers. Minor omissions like behavior on no match or the exact output format are the only gaps.

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

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

The description is front-loaded with the core purpose ('Read-only: dump EVERY attribute...') and then proceeds logically: return format, qualifiers, use case, and alternative. Every sentence adds value, and the length is justified given the tool's complexity. There is no wasted text or repetition of schema content.

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

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

Given the absence of an output schema and annotations, the description covers most essential details: what is returned, how ambiguity is handled, the relationship to flow selectors, and a usage example. It doesn't specify the output format for `bounds` or the behavior when no elements match, which would be helpful for an agent to interpret results correctly. Overall, it is nearly complete but has small 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 86%, so most parameters already have semantic descriptions. The description adds meaningful context beyond the schema: it explains that the qualifiers (enabled/checked/focused/selected) are the same as a flow selector's, and that the reported index corresponds to the one that selector will use. This clarifies how the parameters interact and what the output will be. It doesn't describe each parameter individually, but the schema already does that, so the added value is sufficient.

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

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

The description clearly states a specific action (dump every attribute) on a specific resource (matched elements), enumerating exactly what is returned (state flags, resource-id, class, bounds). It also distinguishes itself from find_element by noting it is the larger, more exhaustive alternative for ambiguous selectors, making it easy for an agent to tell apart from siblings 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?

Explicitly specifies when to use: 'Use it while authoring to answer

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 disclosure burden. The verb 'Get' implies a non-mutating read and 'connected Android device' names a precondition, but the description does not disclose return contents, error behavior, or what happens when no device_id is provided. It is not misleading, but it is minimal.

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

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

The description is a single sentence with no filler, and it front-loads the verb and object. It is appropriately compact for a one-parameter getter, though a brief clarification of what 'detailed information' includes would make it more useful while still remaining concise.

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 has one optional parameter, but there is no output schema and no annotations to describe the return contract. 'Detailed information' is too generic to tell an agent exactly what it will receive, and no caveats are mentioned beyond the device being connected. This is a minimum-viable definition 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 100%, and the device_id parameter is already fully documented in the schema, including fallback to the default device. The description adds no meaningful parameter semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and a concrete resource ('detailed information about a connected Android device'), with an explicit '(Android)' platform prefix. It is clearly distinguishable from the UI-action siblings, though it does not specify what 'detailed information' includes or explicitly contrast itself with list_devices/connect_device.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_devices, connect_device, or get_current_activity. It states only the operation, leaving the agent to infer the appropriate context and no exclusions or prerequisites are given.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the core function and the visible-element scope. It does not disclose whether the tool is read-only, whether it requires an accessibility or instrumentation setup, or what performance/impact it may have.

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

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

The description is one focused sentence with no filler, and the platform and primary action are front-loaded. Every phrase ('current', 'structured representation', 'visible elements') contributes meaning.

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

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

This is a simple tool with one optional parameter, but the absence of an output schema and annotations means the description should explain more about the returned structure and how to use the result. It also does not address the closely related observe_ui sibling, leaving selection and output interpretation 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?

The input schema already documents device_id at 100% coverage, including the default-device behavior. The description adds no extra parameter semantics, so the schema-baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('dump'), the resource ('current UI hierarchy'), and the output ('structured representation of all visible elements'), so an agent can tell what the tool does. It does not differentiate itself from the overlapping sibling observe_ui, 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 guidance is given about when to use dump_ui instead of alternatives like observe_ui, find_element, or describe_element. The '(Android)' prefix is useful context but not a selection rule, and there are no exclusions or conditions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose key behaviors: returns the first match, returns 8 attributes, and includes bounds. However, it does not specify what happens on no match (e.g., null, error), the exact return structure, or whether the operation is read-only (implied but not stated). These gaps leave some uncertainty for an agent.

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

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

The description is two sentences with zero waste. The first sentence states the purpose and output, and the second immediately pivots to the sibling comparison and usage guidance. It is front-loaded and 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?

The tool has no output schema, so the description must compensate by explaining the return value. It mentions 'attributes and bounds' and '8 attributes' but does not enumerate which attributes or describe the return format in detail. It also omits error behavior and the default device behavior (though schema covers device_id default). For a read-only find operation, this is adequate but not complete.

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

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

The schema description coverage is 100%, so each parameter already has a meaningful description (e.g., text is visible text or content-desc with regex full-match). The tool description adds no extra parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('find'), a resource ('UI element'), and the search methods ('text, resource ID, or class name') along with the output ('attributes and bounds'). It explicitly contrasts with describe_element by noting it returns the FIRST match with 8 attributes, clearly distinguishing the two tools.

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

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

The description explicitly names the alternative tool (describe_element) and the conditions that should trigger its use: when a selector may be ambiguous or when a state flag is in question. This gives the agent clear when-to-use and when-not-to-use guidance without ambiguity.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It clarifies that this is a reference retrieval with no side effects and is local (no file lookup), which is useful. However, it doesn't describe the return format details or performance characteristics, but since it's a static reference, the key behavioral traits are 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?

The description is two sentences with no redundancy. The purpose is front-loaded and actionable, with the usage hint appended efficiently. Every word contributes value.

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

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

For a zero-parameter reference tool, the description is complete. It specifies the content of the returned reference, when to call it, and that no additional setup is needed. Nothing is missing that an agent would need 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?

The tool has zero parameters, and the schema coverage is 100% (empty object). The description adds semantic value by indicating what the returned reference contains, which helps the agent understand what to expect. With no parameters, a baseline of 4 is appropriate.

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

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

The description clearly states what the tool returns: a compact YAML-flow grammar reference, listing specific components (commands, selectors, env, switchContext, examples). This is distinct from sibling tools, which are action or query tools rather than reference tools.

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

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

The description gives clear guidance on when to use this tool: 'Call this before authoring a flow' and notes that no file lookup is needed. This is explicit usage context, though it doesn't mention alternatives or when not to use it, which is acceptable given the tool's unique reference nature.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It states the action but does not mention consequences like forced termination losing unsaved data, or that the app must be running. The description is minimal and omits critical side effects.

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

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

The description is a single, concise sentence that is front-loaded with the core action. It is appropriately brief for a simple tool, though it could include more context without becoming verbose.

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 mutation tool with no output schema, the description is minimally sufficient but lacks key behavioral details such as data-loss implications or whether the action is reversible. Given the tool's simplicity and schema coverage, this is adequate but not thorough.

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

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

Schema description coverage is 100% – both 'package' and 'device_id' are already documented in the input schema. The description adds no extra meaning beyond what the schema provides, 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 'Force stop a running app' uses a specific verb ('force stop') and resource ('a running app'), clearly distinguishing it from siblings like launch_app or clear_app_data. The purpose is immediately obvious and unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as clear_app_data or uninstall_app. It does not mention prerequisites, exclusions, or typical use cases, leaving the agent to infer context.

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

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

With no annotations, the description carries the transparency burden. 'Get' implies a read-only action and the description makes the target state clear, but it does not mention behavior when no activity is resumed, device connection requirements, or any error conditions.

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

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

One sentence containing only the essential information: the action, the target, and a clarifying synonym. No padding or repetition.

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

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

For a simple one-parameter read tool with full schema coverage, the description plus schema is nearly complete. It could state the return type explicitly since no output schema exists, but 'name' already signals the expected string result.

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

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

The sole parameter, device_id, is already fully documented in the schema ('Target device ID. If omitted, uses the default device'). The description adds no parameter-level meaning, so it stays at the baseline for full schema coverage.

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

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

The description uses a specific verb ('Get') and a clear resource ('name of the currently resumed activity'), further clarified by the parenthetical '(foreground screen)'. This distinguishes it from related siblings like wait_for_activity, which waits rather than retrieves.

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

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

No guidance is given about when to use this tool instead of related alternatives such as wait_for_activity, dump_ui, or observe_ui. The description states what the tool returns but does not describe the calling context or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable behavior beyond 'type': using ADBKeyboard, waiting for the screen to settle, and returning a fresh snapshot with annotation if never settled. This is meaningful context, though it omits details about failure modes 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?

The description is two sentences, front-loaded with the primary action ('Type text into a field'), and every sentence adds useful behavioral information. No filler or redundancy.

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

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

For a tool with no output schema and no annotations, the description explains the return behavior (fresh snapshot, optionally annotated), which is important. It also covers the typing method and settling behavior. It could be more complete by explaining what happens on failure, but the essential context for calling the tool correctly is present.

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

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

Schema coverage is 83%, so the schema already documents most parameters. The description's mention of 'optionally focus it first by selector' adds context for the selector parameters (id, text, index) but does not explain value, optional, or device_id beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool types text into a field and can optionally focus it first by selector, which is a specific verb and resource. However, a sibling tool named 'type_text' exists and the description does not differentiate input_text from it, so the agent cannot tell them apart from the description alone.

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

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

The description gives no guidance on when to use this tool versus alternatives like 'type_text' or other input methods. It does not state typical use cases, exclusions, or prerequisites, leaving the agent to infer when this tool is the right choice.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It does not mention side effects like overwriting an existing app, prerequisites such as device connectivity and permissions, or possible failure modes. The description only states the core action without additional behavioral context.

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, direct sentence with no filler or redundant wording. It front-loads the action and object, making it immediately scannable.

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 schema fully documents the required and optional inputs, making basic invocation possible. However, with no output schema and no annotations, the description does not clarify success/error reporting, installation side effects, or device prerequisites, leaving gaps for an agent deciding how to handle failures.

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 covers 100% of the parameters with descriptions for both apk_path and device_id, so the baseline is 3. The tool description adds no extra semantic detail beyond what the schema already provides, such as path format or how the default device is selected.

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

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

The description uses a specific verb ('Install') with a clear resource ('APK file') and target ('connected Android device'). This clearly differentiates it from sibling tools like launch_app, uninstall_app, and clear_app_data.

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

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

The intended use is implied by the name and description, but there is no explicit guidance about when to prefer this tool over alternatives, or any exclusions such as needing the device to be unlocked or having an existing installation. No when-not-to-use conditions are mentioned.

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

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

With no annotations, the description carries the behavioral burden. It does convey that the check is of the current screen state and identifies elements by text or resource ID, which adds some meaning beyond the tool name. However, it does not state the return contract, behavior when no element matches, or whether this can throw.

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

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

The description is one tight, front-loaded sentence with no filler. It states exactly what the tool checks and the element-identification criteria, making it easy to scan.

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

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

The core use is clear, but the description does not specify the return value or behavior when the element is not present, and it does not clarify what happens if neither text nor resource_id is provided. Given no output schema and no annotations, this is minimally adequate rather than complete.

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

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

Schema description coverage is 100%, so the schema fully documents text, resource_id, and device_id including regex and default-device semantics. The description only restates that text or resource ID can be used, adding no extra parameter meaning beyond the schema.

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

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

The description identifies a specific operation ('check if ... currently visible') and a clear resource (element identified by text or resource ID). It is unambiguous, but it does not explicitly differentiate itself from siblings like assert_visible or wait_for_element.

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

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

No guidance is given on when to use this tool versus assert_visible, wait_for_element, or find_element. The 'currently visible' wording implies a direct, non-waiting check, but the agent is left to infer the right context and there are no explicit exclusions or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Launch an Android app' but does not describe side effects, failure conditions (e.g., app not installed), whether an existing task is resumed, or what the tool returns. This is a minimal statement of the operation, not a disclosure of behavior.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. Every word contributes to the core purpose and parameter usage, making it efficiently scannable for 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?

The tool is simple and the schema covers all parameters, but there are no annotations and no output schema. The description does not mention return behavior, error cases, or any side effects of launching an app, so it is minimally adequate but not fully complete for an agent that needs to predict the tool's full effect.

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

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

The input schema has 100% descriptive coverage, so the schema already explains each parameter, including the default launcher activity behavior. The description adds no additional semantic value beyond restating that an activity may optionally be specified, which keeps this at the baseline of 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?

The description states a specific verb ('Launch') and resource ('Android app') and includes the key parameters (package name, optional activity). It clearly distinguishes launch_app from siblings like install_apk, uninstall_app, and force_stop by naming the core operation directly.

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

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

The description gives no guidance on when to use this tool versus alternatives, and does not mention any exclusions or prerequisites. The intended usage is only implied by the tool's name and the nature of the operation, not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description says it lists devices, but does not reveal whether it returns only connected devices, whether it needs adb/emulator tools initialized, whether it can block/wait for devices, what happens when no devices are present, or whether the list is ordered or filtered. For a zero-parameter discover command this is a moderate gap, so it merits a 2 rather than a 1.

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

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

The description is a single concise sentence that conveys the action, the resource, and the platform scope in 9 words. There is no redundancy, and the key scope delimiter (Android/iOS, devices/emulators/simulators) is included without bloat.

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

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

Given the tool's simplicity (0 params, no output schema, no annotations), the description captures the primary purpose. However, it does not mention the command's value as a prerequisite for other operations (e.g., connect_device), nor hints at the output shape (device IDs, names, states). For a list command, knowing what gets returned matters to an agent, but the absence of an output schema raises the need for at least a short comment on output format.

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

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

There are no parameters, and schema description coverage is effectively 100% (empty schema with no required properties). The baseline for a 0-parameter tool is 4. The description does not need to explain parameters; it correctly implies the tool requires no input.

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

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

The description states a specific action ('List') and resource ('connected Android devices/emulators and iOS simulators'). This clearly distinguishes it from siblings, most of which act on the current device rather than enumerating available ones. It lacks an explicit head-to-head differentiation clause with a sibling, but the verb+resource scope is clear enough on its own.

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

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

There is no explicit 'use this when...' guidance or mention of alternatives such as connect_device or device_info. However, from the sibling names, listing devices is a natural precursor to connecting or acting on a device, and the zero-parameter design implies it is a discovery operation. No exclusions or when-not-to-use conditions are stated, so guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only states the action, not effects like whether it blocks until the press completes, if it requires a visible element, or if it could fail. The agent has no information about side effects, system behavior, or postconditions.

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

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

The description is a single, front-loaded sentence with no filler. It states the verb and object concisely, and each word earns its place. It could not be meaningfully shorter.

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 action with fully described parameters and no output schema, the description is minimally adequate. However, it omits any context about when to choose this over sibling gestures, and the lack of annotations leaves safety and side-effect behavior entirely unaddressed. Given the many sibling tools, a bit more context would improve completeness.

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 all parameters are already documented with descriptions. The tool description adds no additional meaning beyond emphasizing 'specific screen coordinates,' which is already clear from the parameter names. Baseline of 3 applies because the structured schema does the heavy lifting.

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 'Long press at specific screen coordinates' uses a specific verb and resource, clearly stating the gesture and where it applies. It distinguishes from siblings like tap_xy and swipe because 'long press' implies a different duration and behavior, 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 guidance is provided on when to use this tool instead of alternatives such as tap_xy, swipe, or press_key. The description does not mention context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It does reveal that the snapshot is compact, token-frugal, current-screen-based, and that actionable elements include refs. However, it does not mention side effects, failure conditions, or whether it relies on the accessibility hierarchy, though 'snapshot' suggests a read-only 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?

One compact sentence that front-loads the key behavior and adds a useful detail about refs. There is no filler or 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?

The tool has no output schema and no annotations, so the description should explain enough about return values and the optional device_id parameter to allow correct invocation. It leaves device_id undocumented and does not describe what the snapshot contains beyond refs, which is incomplete for a tool in a large sibling family.

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

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

The single parameter device_id has no schema description and the tool description does not mention it at all. Since schema description coverage is 0%, the description was required to compensate and failed to explain what device_id means or how it affects the snapshot.

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

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

The description clearly states a specific action (Capture) and resource (a compact, token-frugal snapshot of the current screen), and the parenthetical about actionable elements receiving [ref=eN] distinguishes it from siblings like take_screenshot and dump_ui. An agent can identify what this tool does without opening the schema.

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

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

There is no explicit guidance about when to use observe_ui versus alternatives such as dump_ui, take_screenshot, or find_element. The phrase 'token-frugal' implies a use case, but no when-to-use or when-not-to-use conditions are stated.

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

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

With no annotations, the description carries the full burden. It discloses the platform-specific opt-in requirements, the selection behavior (most content), and the targeting behavior via `match`. It does not describe the exact shape of the DOM snapshot or failure modes when no debuggable WebView exists, but the core behavioral traits are well 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?

The description is dense but well-organized: it front-loads the main action, then gives prerequisites, then parameter guidance, then the alternative. Every sentence earns its place and no filler is present.

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

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

For a tool with no output schema and no annotations, the description covers the main action, prerequisites, parameter semantics, and the sibling alternative. It could mention what happens when no debuggable WebView is found or how the DOM snapshot is returned, but the essential information for selecting and invoking the tool is present.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining that `match` is a URL substring/regex and that `package` is the host app, and it clarifies the device_id behavior (iOS simulator UDID required, Android optional). This is meaningful added context.

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 ('List' and 'return'), a clear resource (debuggable WebView pages / DOM snapshot), and a distinctive selection criterion (the page with the most content, css-selectored). It also names the sibling alternative (switchContext) for pinning a page, which helps distinguish it from other webview tools.

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

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

The description explicitly explains when to use this tool: to list debuggable WebView pages and get a compact DOM snapshot, and it gives the opt-in prerequisites per platform. It also tells the agent to pass `match` to target a specific page and to use switchContext for pinning a page in a flow, which is a clear alternative.

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

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

No annotations are present, so the description carries the full burden. It transparently states the core action (pressing a hardware/software key), but it does not disclose side effects, whether the press targets the foreground app, or how it behaves with device_id omitted. Still, it is not misleading and gives the basic behavioral intent.

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

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

The description is a single sentence with no wasted words, front-loads the action, and uses examples efficiently. It is appropriately sized for a simple input 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?

Given the tool's low complexity, the schema fully documents both parameters, and there is no output schema requiring return-value explanation, this description is largely complete. The main gap is the lack of sibling differentiation for when to use this tool.

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

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

Schema description coverage is 100%, so the input schema already documents the key and device_id parameters. The description adds only the generic 'hardware/software key' framing and examples, which adds minimal value beyond the schema.

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

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

The description uses a specific verb ('Press') and a clear resource ('hardware/software key') with concrete examples like BACK and HOME. It is not a tautology and is clearly separable from coordinate or element-based sibling tools, though it does not explicitly name those siblings.

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

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

No guidance is given about when to use press_key versus alternatives such as long_press, tap_xy, or tap_element. The description implies key-based input but provides no exclusions, prerequisites, or context for selecting this tool.

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

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

With no annotations, the description carries the transparency burden, and it does disclose determinism, no AI, report generation, and pass/fail return. However, it does not mention the flow's side effects on the device, prerequisites like a connected/booted device, or error/failure behavior, so coverage is partial.

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-load the core purpose, then the output, then the reference to flow_reference. No redundant phrases or filler; every sentence earns its place.

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

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

The tool has five parameters, no annotations, no output schema, and a clear sibling validate_flow, yet the description omits the validation/execution workflow and failure behavior. It is adequate for basic invocation but not complete for safe, correct end-to-end use.

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%, so the schema already explains all five parameters; the description adds no parameter-level detail beyond restating 'YAML flow' and 'device.' Baseline 3 applies because the schema does the semantic heavy lifting.

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

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

Description opens with a specific verb-resource pair: 'Run a validated YAML test flow on a device,' immediately distinguishing execution from sibling validation/reference tools. The added 'deterministic, no AI' and the output statement (HTML report, pass/fail summary) make the tool's job unambiguous.

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

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

The description tells the agent to call flow_reference for YAML grammar, which is useful routing for one sibling. It does not explicitly address when to use run_flow versus validate_flow or state exclusions/prerequisites, leaving much of the decision to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the mechanical action without mentioning any side effects, scroll extent, speed, or whether it operates on the whole screen or a focused element. This is minimal disclosure for a UI control tool.

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

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

The description is a single, clear sentence with no filler. It is front-loaded with the primary action and adds the gesture detail efficiently.

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

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

For a simple scrolling action, the description provides the essential information. However, with no annotations and no output schema, an agent might benefit from knowing whether this scrolls the entire screen, whether it waits for scrolling to finish, or how far it scrolls. These gaps make it adequate but not complete.

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

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

The single parameter device_id is fully described in the schema (covers 100%), and the description adds no extra meaning. Since schema coverage is high, the baseline of 3 is appropriate; the description does not compensate further.

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

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

The description clearly states the action (scroll down) and the specific gesture (swipe from bottom to top). This distinguishes it from the sibling scroll_up, which would imply the opposite direction, so an agent can immediately infer the tool's purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives like swipe or scroll_up. It doesn't state any context, prerequisites, or conditions that would help an agent decide between this and other scrolling-related tools.

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

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

With no annotations, the description carries the burden of explaining behavior. It does disclose the physical gesture direction ('swipe from top to bottom'), which is useful, but it omits details like scroll distance, duration, or edge behavior. For a simple gesture tool, this is adequate but not fully transparent.

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

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

The description is a single concise sentence with the core action front-loaded and the clarifying gesture in parentheses. Every word earns its place; there is no redundancy or filler.

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

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

For a one-parameter, no-output-schema tool, the description plus schema are mostly sufficient to invoke the tool. However, it does not mention the scroll amount or how it relates to the more general swipe tool, leaving a minor but real completeness gap.

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

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

The schema already covers the only parameter, device_id, including the default-device behavior. The description adds no parameter-specific detail, and with 100% schema description coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Scroll up on the screen.' The parenthetical 'swipe from top to bottom' disambiguates the gesture and distinguishes this from scroll_down or generic swipe usage.

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

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

No guidance is given about when to use this tool versus alternatives like scroll_down or swipe. The tool's name and direction imply its use, but the description does not state conditions, exclusions, or alternative tools.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. The description only says 'swipe from one point to another' and fails to disclose that this is a user-like gesture that may trigger animations, scroll actions, or require screen stability. It does not explain potential side effects or prerequisites (e.g., device must be unlocked). This is a significant gap for a UI interaction tool.

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

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

The description is a single sentence, which is efficient and front-loaded with the core action. It is not verbose, but it is also under-specified, which is why it scores 4 rather than 5. Every word earns its place, but there is no extra context to help the 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?

The tool has 6 parameters, no output schema, and no annotations, yet the description is extremely brief. Critical missing context includes coordinate system specifics, duration meaning, device targeting, and potential side effects. For a gesture tool, the description is incomplete for an agent to invoke it correctly without additional knowledge.

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

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

Schema description coverage is 100%, so the schema describes each parameter's meaning (e.g., x1 is start X coordinate). However, the description adds no additional semantics, such as coordinate system origin (e.g., pixels from top-left), how duration affects behavior, or that device_id can target a specific device. Baseline 3 is appropriate since the schema covers the basics, but the description does not compensate for missing context like coordinate origin.

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

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

The description clearly states the action (swipe) and the resource (screen), but it is generic and does not distinguish from sibling tools like scroll_down or scroll_up, which are specific types of swipes. An agent might confuse 'swipe' with scroll gestures without additional context.

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

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

The description provides no guidance on when to use this tool versus alternatives such as scroll_down, scroll_up, or tap_xy. There is no mention of use cases like swiping for navigation, dismissing elements, or scrolling through lists. The agent is left to infer when this tool is appropriate.

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

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

With no annotations, the description carries full responsibility for behavior. It discloses that the output is a large image, which is a meaningful trait, but it does not mention any other potential side effects or caveats (e.g., speed, resolution, or capture scope). For a read-only screenshot tool, this is adequate but not rich.

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

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

The description is two short sentences, with the core action front-loaded and the usage caveat following. Every clause serves a purpose, with no redundancy or filler.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the action, the output type, and when to use it. The only minor gap is that it doesn't specify the exact format or size beyond 'large image', but that is not critical for invocation. Overall, it is sufficiently complete.

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

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

The input schema provides 100% coverage for the single optional device_id parameter, so the description does not need to add parameter details. It does not add any extra meaning beyond the schema, which is acceptable given the baseline of 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?

The description states a specific action ('Take a screenshot') and the subject ('device screen'), and clearly indicates the output is an image. It also differentiates from siblings by naming observe_ui / observe_webview as preferred alternatives, so an agent can distinguish this from text-extraction 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?

Explicitly instructs when to use: 'prefer observe_ui / observe_webview text — use only when those cannot answer.' This gives clear conditional guidance and names the alternatives, leaving no ambiguity about selection.

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

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

There are no annotations, so the description carries the behavioral burden. It usefully discloses that the tool waits for the screen to settle, returns a fresh snapshot, and annotates the snapshot if it never settled. It does not cover error behavior or edge cases, but the optional parameter partially signals miss 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?

The description is a single efficient sentence with the primary action front-loaded. Every phrase adds value, and there is no redundant or filler content.

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

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

For a tool with optional parameters and no output schema, the description adequately explains core behavior and return value. It is missing explicit sibling differentiation and failure-mode details, but it is sufficient for basic invocation.

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

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

Schema coverage is high at 80%, and parameter descriptions already explain id, text, index, and optional. The description adds only general selector context and does not clarify the undocumented device_id parameter or add meaningful semantics beyond the schema.

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

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

The description identifies a specific verb and resource: find an element by selector and tap its center. It also communicates a clear postcondition (returning a fresh snapshot). However, it does not explicitly distinguish itself from the similarly named sibling tap_element.

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

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

The description explains what the tool does but gives no guidance about when to use it versus alternatives like tap_xy, tap_element, or long_press. An agent is left to infer selection from tool names rather than from explicit usage context.

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

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

With no annotations, the description carries the full burden, but it only discloses that the tap lands at the element's center. It does not mention what happens when multiple elements match, what occurs if no element is found, or that class_name is ignored in M1. The mention of class_name as a lookup method is potentially misleading given the schema says it is ignored.

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

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

The description is a single front-loaded sentence that conveys the core action, target, and selector types without wasted words. Every phrase contributes to understanding what the tool does.

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 action with no output schema and no annotations, the description is too thin to be fully actionable. It lacks guidance on alternative tool selection, behavior on multiple/no matches, and the fact that class_name is not currently functional in M1. The rich parameter schema helps, but the surrounding context is still 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 100%, so each parameter is already documented. The description adds a useful summary of the selector parameters but no new meaning beyond what the schema provides, and it omits parameter-specific notes like regex matching and the deprecated/ignored nature of class_name.

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

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

The description states a clear verb-target relationship: find a UI element by text, resource ID, or class name, then tap its center. This is specific enough to distinguish it from coordinate-based taps, though it does not explicitly name sibling tools or explain how it differs from 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 guidance is given for when to prefer tap_element over alternatives like tap_xy, long_press, or find_element. The description implies useful selection criteria (text/resource-ID/class-name) but provides no exclusions, prerequisites, or conditions for when this tool is the right choice.

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 behavioral disclosure on its own. It clearly indicates the tap is at raw screen coordinates and does not involve element lookup, but it omits details like coordinate origin/units and out-of-bounds 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?

Two short sentences deliver the core purpose first and the alternative second, with no redundant wording.

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

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

The tool is simple and the schema documents all parameters, but there is no output schema or behavior notes about coordinate system or failure cases. The description is adequate for basic invocation but leaves a few operational details implicit.

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%, so the description doesn't need to repeat parameter definitions. It adds the useful clarification that x/y are raw screen coordinates rather than element-relative, though it does not specify units or origin.

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

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

The description states a clear action ('Tap') and a specific resource ('raw screen coordinates'), distinguishing this tool from selector-based tapping. The explicit contrast with the 'tap' tool makes its purpose 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?

It explicitly tells the agent when not to use this tool: to tap an element by selector, use the 'tap' tool instead. This gives a direct routing rule from raw-coordinate tapping to selector-based tapping.

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

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

With no annotations, the description carries the burden of behavior. It mentions Unicode support with ADBKeyboard, which is useful, but it does not disclose what happens if no field is focused, whether it clears existing text, or if it performs a tap first. This is a moderate disclosure.

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

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

The description is a single, concise sentence, front-loading the primary action and including a useful caveat about Unicode support. No filler words; every word earns its place.

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

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

For a simple 2-param tool with full schema coverage, the description is adequate. However, there is no guidance on the focused field requirement or fallback behavior, and no output schema, so an agent might be uncertain about success conditions. It is not missing critical info but could be richer.

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%, with descriptions for both parameters. The description adds the Unicode detail and the focused input context, but these are not parameter-specific. The schema already explains text and device_id, so the description adds minimal extra param meaning.

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

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

The description clearly states it types text into the currently focused input field, which is specific and distinguishes it from tap, swipe, and other input tools. It could be improved by noting that it requires a focused field, but overall it is clear.

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

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

The description implies when to use it (when typing text is needed) but does not explicitly contrast with sibling tools like input_text or webview_input, nor does it provide exclusion conditions (e.g., when text field is not focused). It gives no guidance on when not to use it.

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

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

No annotations are present, so the description carries the safety burden. 'Uninstall' clearly signals destructive removal, but the description does not explicitly mention that app data is deleted or that the operation is irreversible, which would strengthen transparency.

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

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

One front-loaded sentence with no filler. Every word contributes to identifying the action, the target, and the environment.

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

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

For a simple two-parameter tool with a fully documented schema, the description plus schema is sufficient for correct invocation. It could add a note about return values or data-loss side effects, but those are refinements rather than missing essentials.

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

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

The input schema already documents both package and device_id with 100% coverage. The description adds no parameter-level meaning beyond what the schema provides, so it earns the baseline score for fully covered schemas.

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 action 'Uninstall' and the resource 'app', scoped to 'a connected Android device'. This is clearly distinct from sibling tools like install_apk, clear_app_data, and force_stop.

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

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

The description gives clear context: use it when you need to remove an app from an attached Android device. It does not name alternatives or exclusions, such as using clear_app_data when the app should remain installed, so it stops short of explicit 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 the full burden. It discloses that validation is static and lists the checks performed, but it does not state whether the operation is read-only, what it returns on success/failure, or any error behavior. For a validation tool, this is a meaningful gap, though the word 'statically' hints at no side effects.

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

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

Two sentences with no filler. The primary purpose is front-loaded, and the pointer to flow_reference is a useful one-line addition. Every word earns its place.

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

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

The description covers the tool's core validation scope but omits the return format (e.g., error list, exit code) and does not explicitly confirm it is read-only. Given there is no output schema, the description should have explained what the agent can expect as a result. The absence of that detail leaves a notable gap.

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

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

Schema coverage is 100%, and the parameter description already states 'Path to the .yaml flow file.' The tool description does not add further meaning about path syntax, file naming conventions, or required permissions. The baseline of 3 applies because the schema fully documents the 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?

The description opens with a specific verb and resource: 'Statically validate a YAML test flow file.' It lists concrete validation aspects (schema, lint, subflow resolution) and explicitly contrasts with sibling flow_reference by directing the agent there for grammar. The 'No device needed' qualifier further separates it from device-dependent siblings like run_flow.

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

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

The description gives clear context: static validation without a device, and points to flow_reference as the alternative for grammar. Although it doesn't explicitly state 'use this instead of run_flow when you only need to check validity,' the 'No device needed' phrase strongly implies that distinction. This is enough for an agent to infer when to choose this tool.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It states the core behavior (wait until foreground) but omits critical details: it does not mention that the tool blocks until the timeout, what happens on timeout (error vs return), whether it returns any value, or how it interacts with device_id. For a blocking wait operation, this is a significant transparency gap.

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

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

The description is a single, clear sentence that front-loads the essential purpose. There is no wasted wording, and it is appropriately concise for a simple wait operation.

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

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

Given the absence of annotations and output schema, the description is too thin. An agent needs to know whether the tool raises an exception on timeout, what it returns upon success, and whether it targets a specific device. The current description does not address these, leaving an agent uncertain about failure modes and postconditions. For a tool with 4 parameters and no other documentation, 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 coverage is 100% (all four parameters have descriptions in the schema), so the baseline is 3. The description adds minimal value beyond the schema: it confirms the 'activity' parameter is the target of the wait, but it does not explain semantics of timeout_ms or poll_interval_ms beyond what the schema already states. No additional guidance on partial matching or device targeting is provided.

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

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

The description clearly states the action: wait until a specific activity becomes the foreground (resumed) activity. It names the resource (activity) and the condition, and it is distinct from sibling tools like wait_for_element or wait_for_text which wait for UI elements/text. However, it does not explicitly differentiate from get_current_activity which polls the current activity, so a small gap remains.

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

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

No guidance is given on when to use this tool versus alternatives. The description only states what it does, with no exclusions, no mention of alternative tools, and no context about prerequisites or typical scenarios. An agent would have to infer that this is for waiting on activity state changes, but no explicit direction is provided.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It does add 'polling at regular intervals,' but it does not say what happens on timeout, whether the element must be visible or merely present in the hierarchy, or whether the tool returns a boolean or raises an error. This is a significant gap for a blocking wait operation.

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

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

The description is a single sentence with no wasted words. It front-loads the core action and then adds the polling detail. Every clause contributes meaning.

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 wait tool with no output schema and no annotations, the description is incomplete. Schema covers parameters, but the description lacks timeout failure behavior, return/error semantics, and any comparison to sibling wait or visibility tools. An agent cannot fully predict how the tool behaves in edge cases.

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

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

Schema coverage is 100%, so the schema fully documents text, resource_id, timeout_ms, poll_interval_ms, and device_id. The description's generic 'matching the query' adds no parameter detail beyond the schema, which is acceptable at 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?

The description states a specific verb and resource: 'Wait until a UI element matching the query appears on screen' with explicit polling behavior. It distinguishes this from sibling wait_for_text, wait_for_activity, find_element, and assertion tools without requiring schema inspection.

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

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

The description gives no guidance about when to prefer this tool over wait_for_text, assert_visible, find_element, or is_element_visible. It also does not state exclusions or mention that wait_for_text is a specialized alternative. An agent must infer the intended use from the name and sibling list.

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

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

With no annotations and no output schema, the description carries the burden of explaining behavior. It only states that the tool waits for text; it does not disclose what happens on timeout (exception vs false return), whether the text is searched in visible/rendered content only, or whether it might throw if text is not found. Schema parameters hint at polling and timeout, but the outcome behavior remains 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?

The description is a single, front-loaded sentence with no filler or redundancy. It efficiently conveys the essential operation and scope.

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

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

For a tool with no annotations and no output schema, the description leaves meaningful gaps: return/termination behavior on timeout, how 'text' is matched, and when to choose this over wait_for_element or assert_text. The schema covers parameters well, but the operational contract is incomplete for an agent deciding whether to call it and what to expect.

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 the schema already documents text, device_id, timeout_ms, and poll_interval_ms. The description adds no new parameter-level meaning beyond implying the text is the target condition, so a baseline score is appropriate.

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

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

The description clearly states the action ('Wait until') and resource ('specific text appears anywhere on the screen'), so an agent can understand the core function. It does not explicitly differentiate from siblings like wait_for_element or assert_text, but the 'text appears anywhere' phrasing provides enough distinction to be more than simply restating the name.

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

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

The description implies the usage context: use when you need to block until text appears on screen. However, it offers no explicit when-to-use versus alternatives such as wait_for_element, assert_text, or wait_for_activity, and no exclusions or conditions 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?

No annotations are provided, so the description is the only source of behavioral disclosure. It reveals that the tool focuses the field and sets the value rather than merely sending keystrokes, and that it returns the updated WebView DOM. This exceeds a bare action statement, though it does not cover side effects or failures.

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 that front-loads the core action and the distinctive return behavior; no filler or repeated schema information.

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

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

The description gives the essential action, return behavior, and focus/value mechanism, but with no annotations and no output schema it leaves the selector requirement and remaining parameters (match, package) implicit. Adequate for basic use but not fully 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 only 33%, so the description must compensate. It clarifies that css or text is a selector mechanism and value is typed text, but it does not explain match or package semantics, leaving several parameters under-specified.

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

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

Description opens with a specific verb and resource ('Type text into a WebView field') and names the selector mechanism and return value. This cleanly distinguishes it from generic siblings like type_text/input_text by targeting WebView fields.

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?

Clear context for when to use: interacting with WebView fields using a css/text selector, returning updated DOM. It does not explicitly state when not to use or name alternatives, but the WebView scoping is enough to route an 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?

The description mentions auto-waits and scrolls into view, which are useful behavioral details beyond what the schema provides. Since annotations are absent, this is a positive addition, but it doesn't cover potential failure modes or side effects of tapping.

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

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

The description is a single sentence with the core action and key usage context. It's concise and front-loads the primary verb and resource, but it could be clearer about parameter specifics.

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

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

The tool has 5 parameters, moderate complexity, and no output schema. The description covers main use cases and return value, but lacks details on error handling, edge cases, or the exact structure of the returned DOM. It's adequate but not exhaustive.

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 40% coverage, with descriptions for text and device_id. The description adds meaning for css (from observe_webview) and match (target specific page), but package and device_id are not fully elaborated. It partially compensates for the schema gap, but not completely.

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

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

The description clearly states the tool taps an element in a WebView using a css or text selector, distinguishing it from generic tap tools. It mentions returning the updated DOM and references observe_webview for context, which helps differentiate from siblings like tap_element.

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

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

It instructs to use css from observe_webview and to pass match for a specific page, which gives some usage context. However, it does not explicitly state when to use this over tap_element or other tapping tools, nor mention any alternatives.

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