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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the destructive scope ('all data and cache'), which is genuinely useful, but omits irreversibility, whether the app must be stopped first, and any permission constraints required to perform the wipe.

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 with the destructive verb and resource front-loaded, and the clarifying parenthetical placed after the core claim. Nothing is wasted.

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

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

For a single-parameter tool with an output schema (so return values need no explanation), the description covers what the operation does and its scope. The only meaningful omission is that the operation is irreversible and that all app state is lost permanently, which matters for a destructive tool with no annotations.

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

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

Schema coverage is 100% and the single package_name parameter is fully documented in the schema with an example. The description adds no format or syntax detail beyond that, so the baseline of 3 for schema-driven parameter documentation 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+resource (清除 = clear, 应用的所有数据和缓存 = all app data and cache) and pins the semantics with the parenthetical equivalence to the platform's 'Clear data' operation. It is immediately distinguishable from siblings like force_stop_app or install_apk. It stops short of explicitly naming an alternative sibling, so it is clear but not maximally differentiated.

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

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

Usage is only implied: the agent can infer this is the tool to call when app data must be wiped, and the '相当于清除数据操作' note anchors it to a known user action. There is no explicit when/when-not guidance and no mention of alternatives (e.g., use force_stop_app for a mere restart).

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 implies abrupt termination but does not explain effects on unsaved data, required permissions, or whether the action is reversible, leaving significant gaps for a mutation/kill 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?

A single, front-loaded sentence that states the action and target with zero wasted words. It is appropriately sized for a simple one-parameter tool.

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

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

Given low complexity (one parameter, output schema present) the description need not explain return values. However, the absence of annotations means the description should carry behavioral context and usage guidance, which it largely omits, leaving it minimally complete.

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

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

The schema already documents the single parameter with a description and example, achieving 100% coverage. The description adds no additional meaning 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?

States a specific verb (force stop) and resource (Android app) with the required package name, making the action clear. However, it does not explicitly distinguish itself from sibling tools like clear_app_data or launch_app, so an agent must infer the difference.

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, nor when not to use it. The description only states what it does, leaving usage context entirely to the agent.

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

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

No annotations are provided, so the description carries the full burden. '列出...列表' implies a read-only enumeration, but it does not disclose ordering, permissions, or whether the result is plain package names versus richer objects. The behavior is largely inferable but not explicitly stated.

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

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

A single, front-loaded sentence with zero filler or redundancy. It is efficient, though at the cost of adding no supplementary context.

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, read-only listing tool with an output schema and full schema coverage, the description covers the essential purpose. Missing only minor operational context such as result ordering or the system-app default when the flag is omitted.

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

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

Schema description coverage is 100% and the single parameter include_system_apps is fully documented in the schema, so the description need not explain it. The description adds no parameter-level meaning beyond the schema, which is the expected baseline here.

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: listing the package names of installed apps on the device. It is clearly distinguishable from siblings like get_device_info or get_memory_info by resource, though it does not explicitly contrast with any sibling that might also enumerate apps.

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

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

There is no guidance on when to call this tool versus alternatives, nor any stated preconditions. The only scoping hint (system vs third-party apps) lives in the schema, not the description.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only query but never states that it is non-mutating or what happens if no Activity is in the foreground; with zero parameters and a getter semantics the risk is low, limiting the gap.

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

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

A single front-loaded sentence with no redundancy; the resource and its purpose are stated immediately.

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

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

For a parameterless read tool with an output schema already documenting the return value, the description is largely sufficient; only explicit read-only/edge-case behavior is missing.

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

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

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

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

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

States a specific verb and resource: fetching the name of the current foreground Activity. It is clearly distinguishable from siblings like get_device_info or get_screenshot, though it does not explicitly name a sibling to contrast against.

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

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

The clause '用于定位当前所在页面' (used to locate the current page) implies a use case, but there is no explicit when-to-use vs when-not guidance or mention of alternatives such as get_ui_dump for page structure.

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 behavioral burden. It does disclose the output format (JSON string) and the precondition that the device must be 'connected', which is genuinely useful context, but it says nothing about failure modes when no device is attached or whether it is a safe read-only call.

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 purpose and field list come first, the return format second. Every clause earns its place.

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

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

An output schema exists, so return values need no explanation, and the empty parameter set removes input ambiguity. The only small gap is the absence of any note about device-connection requirements or error behavior, which is minor for a simple read query.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify; baseline 4 applies. The description correctly avoids inventing inputs.

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

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

Clear verb+resource with an explicit field enumeration (型号、系统版本、分辨率、序列号) that tells an agent exactly what data comes back. It implicitly separates itself from get_memory_info by scoping to device attributes rather than memory, but it never names a sibling to make the distinction explicit.

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

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

The list of returned fields implies the usage context (use it when you need hardware/OS identity), but there is no statement of when to prefer it over get_memory_info or get_current_activity, and no prerequisites such as requiring a connected device to be selected.

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

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

No annotations are provided, so the description carries the full behavioral burden. It adds useful scope (only the last 100 lines) and the prerequisite that the device must be connected. However, it does not state that this is a read-only operation, nor does it mention permissions, blocking behavior, or rate limits.

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

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

A single front-loaded sentence with no wasted words. It is appropriately sized for a simple read tool and gives the key scope constraint immediately.

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

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

An output schema exists and schema coverage is full, so the description need not explain parameters or return values. With no annotations and no usage context, however, it leaves gaps around when to use the tool and its safety profile for an agent to infer.

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 app_package and log_level. The description mentions no parameter details and adds no meaning beyond the schema. 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 states a specific verb and resource: get the most recent 100 lines of logcat output from a connected Android device. The resource is unique among siblings, so the purpose is clear even without naming an alternative. It lacks explicit sibling differentiation, which is the only gap.

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

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

No when-to-use, when-not-to-use, or alternative tool guidance is given. The description only states what the tool does, leaving the agent to infer that it is for log retrieval. There is no routing context toward or away from siblings.

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

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

No annotations are provided, so the description carries the full burden. Naming PSS/RSS tells the agent what kind of data comes back, and 'get' implies a read-only operation, but it says nothing about required permissions, whether the app must be installed/running, or failure modes. With an output schema present, return-value explanation is not needed, but the operational prerequisites are unaddressed.

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

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

A single front-loaded sentence with no filler; the parenthetical metric list is the only elaboration and it earns its place by clarifying output scope. Sized appropriately for a one-parameter read tool.

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

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

For a simple read-only tool with a fully documented parameter and an output schema, the description covers the core purpose. It is still thin on prerequisites (app must exist / be running) and permission requirements, which an annotation-free tool would ideally disclose.

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

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

Schema description coverage is 100% and the single parameter (package_name) is fully documented in the schema with a format example. The description adds no syntax or format detail beyond what the schema already provides, 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?

States a specific verb (获取/get) and resource (内存占用信息/memory usage info) scoped to an application, and even names the metric types (PSS, RSS). It does not need to distinguish from siblings since none of the other tools read memory, but it also offers no explicit 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 statement of when to use this tool versus alternatives, no prerequisites (e.g. whether the app must be running), and no exclusions. Usage is only implied by the tool name and description.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only screenshot capture, but does not disclose the return format, where the image is stored, permissions or connection requirements beyond 'connected device,' or any side effects. It adds usage context but not enough behavioral detail.

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

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

The description is two short, front-loaded sentences with no filler. The primary purpose appears first, followed immediately by the relevant usage distinction. Every sentence earns its place.

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

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

For a simple zero-parameter screenshot tool, the description covers selection and the main alternative. However, with no annotations or output schema, it could be more complete about what the tool returns and any device-side prerequisites. It is adequate but has minor remaining gaps.

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

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

The tool has zero parameters, and the schema coverage is 100% while adding no meaningful parameter descriptions beyond an empty object. Per the calibration rule, a zero-param tool receives a baseline of 4 because there are no parameters for the description to clarify.

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: obtaining a screenshot from a connected Android device. It also explicitly distinguishes this tool from the sibling get_ui_dump by assigning element identification to that alternative. An agent can identify the tool's function 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?

It states when to use this tool: checking the visual appearance of the interface. It also names the alternative get_ui_dump and the condition that selects it: when element recognition is needed. This gives clear when-to-use and when-to-prefer-an-alternative 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 and does disclose the key behavioral trait that output is XML hierarchy data. However, it says nothing about whether the call mutates device state (it does not, but that is not stated), the potential size/latency of a full dump, or any rate limits. Adequate but incomplete for an unannotated tool.

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

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

A single tight sentence that front-loads what is returned (XML UI hierarchy) before the purpose. Nothing is padded or repeated.

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

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

For a one-parameter read tool with full schema coverage and an output schema, the description covers purpose and output format adequately. It could still be strengthened with a read-only assurance and a pointer to get_screenshot as the visual alternative, given the absence of annotations.

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

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

There is one parameter with 100% schema description coverage, including a concrete comma-separated example ('bounds,class,text,clickable,resource-id'), so the schema already does the heavy lifting. The description adds no extra meaning about the parameter, making the baseline 3 correct.

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

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

States a specific verb and resource ('获取 XML 格式的 UI 视图层级') plus the intent behind it ('理解屏幕结构和定位元素'), which is far more than a restatement of the name. It implicitly separates itself from get_screenshot by specifying XML hierarchy output, but never names or contrasts a sibling tool, so it falls short of the top band.

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

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

The clause '用于理解屏幕结构和定位元素' implies when this tool is useful, but there is no explicit when-to-use vs when-not guidance and no mention of the obvious alternative (get_screenshot) or of how the two complement each other. Usage is left to inference.

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

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

No annotations are provided, so the description carries the full burden. It does not mention permission prerequisites, whether an already-granted permission is idempotent, possible failures (unknown package, unknown permission), or that this is a write operation affecting device state.

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

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

A single concise sentence that front-loads the action and target. No filler, though it is very short for a mutation tool.

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

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

An output schema exists, so return values need not be explained, and the input schema is fully documented. However, for a state-changing permission operation with no annotations, the description omits prerequisites, idempotency, and failure modes, leaving key behavioral context missing.

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

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

Schema description coverage is 100% with examples for both parameters, so the schema already documents them fully. The description adds no parameter detail beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb (grant) and resource (runtime permission for a given app), which is distinct from siblings like install_apk or launch_app. It is clear but not explicitly differentiated from any particular sibling.

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

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

No when-to-use or when-not-to-use guidance, and no alternatives named. The agent must infer purpose 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?

No annotations are provided, so the description carries full behavioral burden. It states the action and target device, but does not disclose mutation side effects, permission requirements, error behavior, or what happens when replacing an existing app.

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

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

One efficient sentence, front-loaded with the action and target. No wasted words or redundant clauses.

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

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

An output schema exists and parameter schema coverage is complete, so return values and parameters need not be explained. The description covers the core action and target, though it could mention more prerequisites or side effects given the absence of annotations.

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

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

Schema description coverage is 100%, so the schema already fully documents both apk_path and replace_existing. The description adds no additional parameter meaning; 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?

Specific verb '安装' (install) and resource '本地 APK 文件' (local APK file) with target '已连接的 Android 设备' (connected Android device). Clear what it does, but it does not explicitly differentiate from siblings like push_file.

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

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

No when-to-use guidance, no alternatives, no prerequisites. Usage is only implied by the tool name and the action described.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose the launch mechanism (monkey command), which is useful context a schema cannot express, but it says nothing about permissions required, what happens on a missing/invalid package, or whether the launch is blocking.

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 tight sentence with the action front-loaded and the implementation detail parenthesized at the end. Nothing is wasted and no ambiguity is introduced.

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

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

For a single-parameter, single-purpose launch tool with a full schema and an output schema present, the description is nearly sufficient. The only missing pieces are prerequisites (app installed/device ready) and failure behavior, which are minor at this complexity.

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

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

Schema description coverage is 100% and the single parameter is documented with an example format (com.example.app), so the schema does the heavy lifting. The description only restates that the package name identifies the target app, adding no format or edge-case detail beyond that.

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

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

States a specific verb (启动/launch) and resource (指定包名的 Android 应用) with the package name as the target, so the agent knows exactly what the tool does. It is distinguishable from siblings like install_apk or force_stop_app by implication, but never names an alternative or contrast explicitly, so it falls short of a 5.

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

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

There is no guidance on when to use this versus related tools such as install_apk, force_stop_app, or get_current_activity, nor any stated precondition (e.g., app must be installed, device must be connected). Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the implementation detail that the press is simulated via a zero-distance swipe, which is genuine behavioral context, but it says nothing about side effects (context menus, drag initiation), whether the call blocks, or required permissions.

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

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

A single compact sentence with no filler; the core action and coordinate scope are front-loaded. Nothing is wasted.

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

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

An output schema exists and parameter coverage is complete, so return values and inputs need no elaboration. However, with zero annotations on a device-input action, the missing side-effect and preconditions information leaves a real gap for correct invocation.

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

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

Schema description coverage is 100% – x, y, and duration_ms (with a documented 1000ms default) are all fully specified in the schema. The description adds no coordinate or duration semantics beyond that, so baseline 3 applies.

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

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

States a specific verb+resource: perform a long press at given screen coordinates, and even explains the mechanism (zero-distance swipe simulation). It is distinguishable from tap_screen and swipe_screen by name, but the description does not explicitly contrast itself with those siblings.

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

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

No indication of when to use this instead of tap_screen, swipe_screen, or other input tools, and no prerequisites or context (e.g., UI states where long press is required). The agent must infer usage purely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies the effect of each action (navigate back, go home, open recents) but says nothing about permissions, side effects, reversibility, or device state requirements for what is a mutating UI 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?

A single, front-loaded sentence with no padding. It is efficient, though the brevity contributes to the missing usage and behavioral detail.

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

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

For a simple one-parameter tool with an output schema, the core action set is conveyed. However, with zero annotations it omits permission/side-effect context and any routing guidance among the many sibling interaction tools.

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

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

Schema coverage is 100% and the single 'action' parameter is already documented with the same values (BACK/HOME/RECENT_APPS) in the schema. The description adds no meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb (执行/execute) and resource (系统级操作/system-level actions), and enumerates the concrete actions: back, home, recent tasks. It does not name or contrast a sibling tool (e.g., tap_screen or long_press), 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?

Usage is only implied through the action examples; there is no explicit when-to-use guidance, no exclusion of overlapping siblings like tap_screen/swipe_screen, and no stated preconditions.

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

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

No annotations are provided, so the description carries the entire behavioral burden. It does not disclose whether an existing local file is overwritten, what happens on a missing device path, whether large files stream or buffer, or what error surface the caller should expect — all material for a file-transfer mutation that also writes to the local filesystem.

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

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

One short sentence with zero filler; the source-to-destination direction is front-loaded. It is arguably too terse for a transfer operation, but the dimension rewards absence of waste rather than depth.

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

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

An output schema exists, so return values need not be described, and both parameters are fully documented. What remains missing is behavioral context around failure modes and overwrite semantics, leaving the definition just barely sufficient for a simple two-parameter transfer tool.

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

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

Schema coverage is 100% and both required parameters carry their own descriptive text with concrete examples (/tmp/test.txt, /sdcard/Download/test.txt), so the description adds nothing beyond structured data. Baseline 3 applies when the 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 states a specific verb and resource ('拉取文件' — pull a file) plus the direction of transfer (from Android device to local), which inherently distinguishes it from the sibling push_file. It stops short of the 5-level by never naming that sibling as the contrasting operation, forcing the agent to infer the pairing.

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 indication of when to prefer this tool over push_file or any other transfer path, nor any prerequisites (device connected, ADB permissions, path must exist). The direction of transfer is the only usage signal, and it is implicit in the verb rather than framed as guidance.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it says almost nothing behavioral. It does not mention overwrite semantics for an existing device_path, required permissions, root restrictions, file-size limits, or whether the device must be rooted/authorized. For a filesystem-mutating tool with zero annotation coverage this is a real gap.

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

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

A single front-loaded sentence with no filler or repetition. It is efficiently structured but so terse that brevity shades into under-specification rather than disciplined conciseness.

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

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

An output schema exists, so return values need not be explained, and with only two fully documented parameters the structural side is covered. However, with no annotations at all the description should have spent a sentence on overwrite/permission behavior, leaving the definition only minimally complete.

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

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

Schema description coverage is 100%, so both parameters are already documented with absolute-path and example-path guidance in the schema. The description adds no syntax, format, or constraint details beyond that, so the baseline of 3 applies.

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

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

The description gives a specific verb (推送/push) and resource (本地文件/local file) with a clear destination (Android 设备). It is unambiguous about what happens, but does not name or differentiate itself from the sibling pull_file, which is the natural opposite operation an agent might confuse it with.

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

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

There is no guidance on when to use this versus pull_file, no prerequisites (e.g. device connectivity or ADB availability), and no exclusions such as whether the file must already exist or whether the destination must be writable. The agent is left to infer usage entirely from the name.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one genuinely useful limitation (no Chinese support). However, it omits other important traits: whether text appends to or replaces existing content, whether the target must be in the foreground, and whether it requires focus to be set first.

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

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

Two tight sentences, front-loaded with the primary action and immediately followed by the critical limitation. 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?

An output schema exists, so return values need not be explained. For a simple one-parameter text-input tool the description is largely sufficient, though the missing focus prerequisite and append/replace behavior leave 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 description coverage is 100% for the single parameter, so the schema already documents 'text_to_send'. The description adds nothing about format, length limits, or escaping beyond what the schema provides, making the baseline 3 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?

States a specific verb (send text via simulated keyboard) and the precise resource/target (the currently focused input box). This clearly distinguishes it from the touch-oriented siblings like tap_screen, long_press, and swipe_screen, which manipulate coordinates rather than text content.

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

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

Gives a clear when-not condition plus an alternative: Chinese text is unsupported and should go through another input-method approach. It does not, however, state the prerequisite that the target input must already be focused (via tap_screen), which an agent needs to sequence calls correctly.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state which app/device state is required, whether the gesture interpolates intermediate points, how duration affects the outcome, or what the tool returns, leaving the mutation's behavior largely opaque.

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

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

A single short sentence, front-loaded with the action, with no filler. The only inefficiency is the second clause, which duplicates information already implied by the parameter names.

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

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

An output schema exists, so return values need not be described, and the 100%-covered schema handles the parameters. The remaining gap is the absence of any usage context or behavioral notes in a tool with zero annotations, which leaves the definition only minimally sufficient.

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

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

Schema description coverage is 100% and every parameter (x1, y1, x2, y2, duration_ms) is individually documented in the schema, so the baseline is 3. The description adds no coordinate-format or duration-tuning meaning beyond what the schema already supplies.

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

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

States a specific verb (执行滑动) and resource (屏幕), making the swipe gesture unambiguous next to siblings like tap_screen and long_press. However, the trailing clause '从起点滑动到终点' merely restates the required coordinate parameters and adds no differentiating information.

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

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

The description gives no guidance on when to swipe versus tap_screen or long_press, nor does it mention that duration_ms controls gesture speed (e.g., a fast flick vs. a slow drag). The agent must infer all usage context.

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

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

No annotations are provided, so the description carries the full disclosure burden. It only says a click is performed; it does not mention side effects, permissions, failure conditions, or what happens after the tap, leaving significant behavioral gaps.

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

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

Two short sentences with zero waste. The core action is front-loaded, and the coordinate-source guidance follows directly.

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 tap tool with an output schema and full schema coverage, the description supplies the action and the coordinate source. It is nearly complete, though it could mention alternatives or interaction side effects since no annotations are 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?

The schema already covers 100% of parameter descriptions, so the baseline is 3. The description adds useful meaning by specifying that x and y should be dynamically obtained from get_ui_dump's bounds property, beyond the schema's minimal coordinate labels.

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: 在屏幕指定坐标执行点击操作 (perform a click at specified screen coordinates). It also references the sibling get_ui_dump as the coordinate source, which helps distinguish it, but it does not contrast with long_press or swipe_screen.

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

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

It gives a clear prerequisite for obtaining coordinates from get_ui_dump's bounds, which implies when to use it after a UI dump. However, it does not state when to prefer tap_screen over alternatives like long_press or swipe_screen, nor any exclusions.

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