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

With zero annotations the description carries the full burden and does substantial work: it names the output fields (llm_success, llm_result, llm_error), explains what happens when the model is not loaded versus when inference throws, and warns about the Habitat built-in quirk where 'Error:'-prefixed text is returned with llm_success=true. It stops short of stating any authorization or cost/latency characteristics.

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?

Purpose and prerequisites are front-loaded, which is good, but the text is dense and contains a doubled punctuation artifact ('。。') plus a redundant re-explanation of the failure path after the output-field list. Every idea is relevant, yet the packaging is less tight than it could be.

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

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

There is no output schema and no annotations, so the description must explain the return contract — and it does, covering success flag, result, error text, and the misleading-success edge case. Minor gaps remain around how 'require' and node_timeout_ms interact with the described failure handling, though those are documented in the schema.

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 all five parameters including the on_error enum and the output_var default. The description adds only that string parameters support ${var} interpolation (already noted on 'prompt') and that results are returned as a variable-snapshot JSON, which is marginal added meaning.

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

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

States a specific verb and resource: invoke an on-device local LLM for a chat turn and store the reply into a variable. Among the siblings (HTTP request, TTS, text operations) it is clearly the LLM-inference tool, though it never explicitly names a contrasting 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?

Prerequisites are given in parentheses (host must inject an LLM service and the local model must be loaded), which implies when the tool can be used at all. However there is no explicit 'use this instead of ACTION_HTTP_REQUEST' guidance and no statement of when this tool is inappropriate.

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

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

No annotations exist, so the description carries the full burden and does a solid job: it names the exact result keys (app_list, app_count, app_search_success, app_search_error), the per-item fields, the variable-snapshot return model, and the visibility limitation. It omits permission requirements and any note on performance or pagination for large app sets.

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?

Purpose is front-loaded and the remaining sentences each add a distinct fact (output keys, item fields, visibility caveat, params requirement, interpolation). Slightly run-on with a doubled '。。' artifact, but no real padding.

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

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

With 8 optional parameters and no output schema, the description compensates by enumerating the return structure and the per-item shape, plus the params-field invocation trap. Enough to call it correctly; only error semantics (what app_search_error looks like) and permission prerequisites are unaddressed.

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

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

Schema description coverage is 100%, so every parameter (query, require, sort_by, on_error, output_var, max_results, include_system, node_timeout_ms) is already documented. The description only adds the cross-cutting note that string parameters accept ${var} interpolation and that app_list is always written, which is marginal on top of 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?

Opens with a specific verb+resource: search installed apps, returning a JSON array. The scope (installed apps only, per-item fields listed) makes it distinguishable from ACTION_GET_APP_INFO or ACTION_LAUNCH_APP, though it never names those siblings explicitly.

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

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

Gives an important usage caveat (Android 11+ package visibility hides apps without launcher icons) and a hard invocation requirement (the node must carry a params field, else it does nothing). It does not say when to prefer this over ACTION_GET_APP_INFO or ACTION_LAUNCH_APP, so routing guidance is only implied.

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

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

With no annotations supplied, the description carries significant behavioral context: it discloses that value, item, and index do not perform ${var} interpolation, elements are always stored as strings, and the array is written back to var. It also names the output variable and says results are returned as a variable snapshot JSON, though it does not describe error handling or timeout behavior beyond what the schema already provides.

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 compact and front-loads the operation list, so an agent can quickly see the tool's scope. There is minor redundancy between the output note and the final result-return sentence, plus a duplicated punctuation mark, but the wording is otherwise 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?

For a 10-parameter tool with no annotations and no output schema, the description supplies the key operational and interpolation behavior needed to call it correctly. It does not repeat all action-specific parameter mappings, but those are fully documented in the schema, so the definition 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?

Schema description coverage is 100%, so the parameter schema already documents each parameter well. The description adds meaningful semantics beyond the schema by stating that value, item, and index are not interpolated, that string parameters do support ${var} interpolation, and that array elements are stored as strings.

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 resource, array variables, and enumerates operations including create, push, pop, get, length, join, clear, remove, and contains. It does not explicitly differentiate itself from related siblings such as ACTION_SET_VARIABLE or ACTION_PARSE_JSON, which keeps it below a 5.

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

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

The description identifies the domain as array variable operations but gives no explicit when-to-use or when-not-to-use guidance relative to sibling tools. It also does not state prerequisites or exclusions, leaving the agent to infer usage from the operation list.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses failure semantics, the catch mechanisms, the supported operator set (and that contains is absent), operand resolution order (variable first, then literal), and the return shape (variable snapshot JSON). Missing pieces are permission/timeout behavior, but node_timeout_ms is documented in the schema, so the gap is small.

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 purpose and failure consequence are front-loaded in the first clause, and the description is compact for the amount of rule detail it conveys. It is marred by a doubled full stop ('。。') and by packing operator rules, resolution order, and interpolation into one dense run, which slightly hurts readability.

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 five-parameter, mutation-of-control-flow tool with no annotations and no output schema, the description covers the essentials: what failure means, how it is caught, how operands are evaluated, and that results come back as a variable snapshot. Only minor gaps remain, such as interaction with the require parameter, which the schema already documents.

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 all five parameters already carry descriptions and the baseline is 3. The description adds real meaning about the condition syntax and the variable-vs-literal resolution rule, but that overlaps with the schema's own condition description, and it never explains require or message beyond what the schema says.

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+resource: an assertion that fails the node when the condition is false and routes to error handling. That is clearly distinguishable from data-manipulation siblings like ACTION_SET_VARIABLE or ACTION_MATH. It stops short of naming CONDITION_SWITCH/CONDITION_ADVANCED_SWITCH, the closest alternatives, so it doesn't earn a 5.

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

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

It explains the failure path concretely (on_error, ACTION_TRY_CATCH, ACTION_RETRY can catch it), which tells an agent how this fits into control flow. However, there is no explicit statement of when to choose ASSERT over CONDITION_SWITCH, nor any when-not guidance. Usage is implied rather than prescribed.

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

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

With no annotations, the description carries the full burden. It usefully discloses that results are returned as a variable snapshot JSON with base64_result/base64_success, and that the scope is UTF-8 text (implying binary payloads aren't supported). It says nothing about failure behavior, the require/on_error semantics, or timeout defaults beyond what the schema already states.

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

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

Compact and front-loaded: purpose first, then outputs, then interpolation/return-shape notes. Every sentence carries information; only minor gain from splitting the output-variable details.

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 six-parameter action tool with a fully documented schema and no output schema, the description covers purpose, return variables, and result delivery. The remaining gap is error/timeout behavior, which the schema partly covers and which is unlikely to block 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%, so the schema already defines all six parameters including action enum values. The description adds modest value by noting ${var} interpolation in string parameters and naming the default result variable, but does not explain require or on_error behavior.

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

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

The description states a specific verb pair (encode/decode) and resource (Base64, UTF-8 text), which is distinctive against siblings like ACTION_TEXT_OPERATION or ACTION_PARSE_JSON. It does not explicitly name an alternative tool, but the resource itself is unambiguous.

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

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

Usage is only implied: an agent can infer it should call this when it needs Base64 conversion of UTF-8 text. There is no explicit when-to-use/when-not-to-use guidance or pointer to a sibling for related text operations.

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

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

With no annotations, the description carries the behavioral burden and discloses privilege requirements, an Android-version limitation, output variable names, interpolation, and variable-snapshot JSON returns. It could be more precise that only status writes bluetooth_enabled and explain success/failure semantics, although the schema partially supplies the former.

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 compact and front-loads the tool’s purpose before prerequisites, outputs, and return conventions. Despite the nested parenthetical, each clause contributes actionable information and there is no filler.

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

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

Together with the fully described schema, the definition covers invocation, platform prerequisites, error and timeout controls, variable interpolation, and result variables. The absence of an output schema is adequately mitigated by the stated output names and snapshot JSON 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?

Schema description coverage is 100%, so the action, require, on_error, and node_timeout_ms parameters are already well documented. The description adds meaningful cross-parameter behavior by stating that string parameters support ${var} interpolation and by tying privilege requirements to the selected action.

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 opening “蓝牙开关、切换、查询状态” clearly identifies Bluetooth control and status querying, with the schema supplying the exact on/off/toggle/status actions. It does not explicitly differentiate itself from related siblings such as ACTION_WIFI, though the distinct resource makes confusion unlikely.

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

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

It gives concrete usage context: switching requires Shizuku or root, ordinary-app system APIs are ineffective on Android 13+, and status queries do not require those privileges. It does not provide broader when-not guidance or name an alternative tool, but the operation-specific prerequisites are genuinely useful.

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 supplied, the description carries the full burden and does well: it discloses the permission requirement per action, the risk that a set value gets overridden while auto mode is on, the exact output variable names, and that results come back as a variable-snapshot JSON. It leaves out failure modes (e.g. what happens when WRITE_SETTINGS is denied) and any timeout/rate 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 text is dense and front-loaded: operation list first, then permissions, outputs, the auto-brightness caveat, and the interpolation note. It is efficient overall, though the trailing '。' duplication and the slightly jumbled ordering of outputs vs. caveat keep it from being perfectly polished.

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

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

There is no output schema, so the description correctly compensates by naming the four returned fields and the brightness_mode values. Combined with the permission note and the auto-mode caveat, an agent has what it needs to call this correctly; only error/denial handling is unspecified.

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

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

Schema description coverage is 100%, so the schema already documents value range, action meanings, require, on_error and node_timeout_ms; that sets a baseline of 3. The description adds only marginal parameter-level value, mainly that string parameters support ${var} interpolation and which action values need permission.

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+resource statement (screen brightness) and enumerates the exact operation set: set, get, auto_on, auto_off, matching the action enum. An agent can immediately distinguish this from neighbors such as ACTION_VOLUME or ACTION_FLASHLIGHT, which control different hardware.

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 real when-to-use guidance: set/auto_on/auto_off require WRITE_SETTINGS while get does not, and it explicitly says to call auto_off before set if you want a fixed brightness because the system may override the value. It does not discuss cases where a different tool (e.g. ACTION_GET_SCREEN_STATE) should be preferred, but the hardware scope makes that mostly moot.

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 at all, the description does real work by disclosing the accessibility dependency and the click_success output variable. It does not cover what a failed or ambiguous click looks like, whether it waits for the element, or that out-of-range occurrence fails (that lives only in the schema). Solid but incomplete for a mutation tool with zero annotation coverage.

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

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

Front-loaded with the targeting modes, then the disambiguation warning — good ordering. Slightly redundant ending: '输出：click_success' and '结果以变量快照 JSON 返回' restate the same return channel, and there is a stray doubled period.

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 8-parameter mutation tool with no output schema and no annotations, the description covers the essentials: the three input modes, the multi-match pitfall, the permission requirement, and the success variable. Missing is any statement of failure behavior or the fact that offset/region only apply to text/id matching — though the schema fields do carry that.

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 does explain why region and occurrence exist (disambiguating repeated text) and that string parameters accept ${var} interpolation, but it adds no format or precedence detail beyond what the schema already documents.

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 three concrete targeting modalities: pixel coordinates, on-screen text substring, or resource-id. An agent can tell this apart from neighbors like ACTION_LONG_PRESS or ACTION_FIND_ELEMENT by the matching mode, though no sibling is named explicitly.

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

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

Gives a concrete usage rule that an agent would otherwise get wrong: when the same text appears multiple times (多个「确定」「发送」), use region to narrow or occurrence to pick the Nth. It also flags the accessibility prerequisite. It stops short of when-not guidance or routing to alternatives such as find-element then click.

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 supplied, the description carries the burden and does well: it discloses the Android 10+ background read restriction and the trap that get can return an empty string while clipboard_success is still true. It also names the three output fields, which the agent would otherwise have to guess. It stops short of permissions behavior for write or failure semantics, so not a 5.

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

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

The description is short and front-loaded with the core purpose before the caveats. There is a stray doubled period ('。。') and the output-field list competes with the behavioral warning, but nothing is padded.

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

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

There is no output schema, and the description compensates by naming clipboard_content, clipboard_success, and clipboard_error, plus the most important edge case for this platform. For a six-parameter tool with fully documented schema, this covers what an agent needs to call it correctly, with only write-side failure behavior left 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 every parameter already carries its own description and the baseline is 3. The description adds that string parameters support ${var} interpolation and that results are returned as a variable-snapshot JSON, which is a modest but real addition over the schema.

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

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

The description states a specific verb and resource: 'read from or write to the system clipboard', and the get/set split is explicit. It does not explicitly contrast with nearby siblings like ACTION_INPUT_TEXT or ACTION_READ_SCREEN, but the purpose is unambiguous 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?

Usage is implied by the 'read or write clipboard' framing and the action enum, but there is no explicit when-to-use guidance and no named alternative. The Android 10+ background caveat is context, not routing guidance.

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

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

With no annotations, the description carries the full burden. It does add real behavioral value by disclosing that string parameters accept ${var} interpolation and that results come back as a variable-snapshot JSON, but it never says the call blocks execution or how on_error/require change control flow, which are the most consequential behaviors for a delay node.

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

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

It is short and front-loads the core purpose plus the sibling routing rule. It loses a point for a stray doubled punctuation ('。。') and for compressing three unrelated facts into one run-on line.

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 four-parameter, zero-required utility with no output schema, the description covers purpose, the size limit alternative, interpolation, and the return shape — enough to call it correctly. The gaps around blocking semantics and require/on_error behavior keep it from a 5.

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

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

Schema coverage is 100%, including the 60000 ms cap/truncation and the ms alias, so the schema already documents the parameters. The description only restates the ${var} interpolation support at a general level, adding little beyond the schema; baseline 3 applies.

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

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

The description states a specific verb and resource (pause for a given number of milliseconds) and explicitly names the sibling it is not for long waits (ACTION_WAIT_UNTIL_TIME), so an agent can distinguish it from the other wait/action tools without opening any 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 gives an explicit routing rule: waits longer than 60 seconds should use ACTION_WAIT_UNTIL_TIME instead. That is clear alternative-selection guidance, though the description does not discuss when a delay is inappropriate altogether or how it interacts with retry/loop nodes.

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 supplied, the description carries the full burden and does well: it discloses the permission prerequisite per action, the exact output keys (dnd_success, dnd_error, dnd_state), the full dnd_state value set including the unknown sentinel, and the ${var} interpolation plus variable-snapshot return convention. It does not state whether a mode change persists across reboots or how failures surface beyond dnd_error, which keeps it from a 5.

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?

Purpose is front-loaded in the first clause, followed by permission, output, and interpolation details in a logical order with no filler sentences. It is dense parenthetical prose with a stray doubled period ('。。') that slightly hurts readability, but every clause carries 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?

For a tool with no output schema, the description compensates by documenting the return keys and value domain, and it covers the one real hazard (the permission gate). The only omissions are the generic workflow parameters and post-failure behavior, which are consistent across the ACTION_* family and thus reasonably assumed.

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 baseline is 3, but the description adds genuinely new meaning by mapping the permission requirement to specific action values (all except get) and by noting that string parameters accept ${var} interpolation — neither is in the schema. The workflow-level params (require, on_error, node_timeout_ms) are left to their schema descriptions.

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 pair plus resource: query or switch Do Not Disturb mode. It enumerates the concrete mode values (on/off/priority/alarms) and names the output fields, so an agent can tell exactly what the tool does without opening the schema. No sibling in the list overlaps with DND, so differentiation is moot.

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 explicit conditional guidance: on/off/priority/alarms require ACCESS_NOTIFICATION_POLICY (or notification-access grant), while get does not. That tells the agent when the call will succeed versus fail. It stops short of naming any alternative tool, but none exists among the siblings, so the gap is minor.

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 supplied, the description carries the full burden and does so well: it discloses the overlay-permission prerequisite, that failure without permission is silent and writes no variables, that execution is non-blocking, and that the result is a variable-snapshot JSON. It also flags the duration_ms type trap (string values are ignored and fall back to 3000), which is exactly the kind of behavior an agent could not guess.

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 purpose is front-loaded in the first clause, and every later sentence carries operational value (permission, non-blocking, type gotcha, interpolation). Minor deductions for a stray doubled period ('。。') and for mixing parameter-level detail into the prose body.

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

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

There is no output schema, and the description compensates by stating that the result comes back as a variable snapshot JSON. Permission requirements, failure semantics, blocking behavior, and the key parameter pitfall are all covered, which is enough for an agent to call a 5-parameter, 1-required tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning the schema does not: duration_ms must be a numeric literal or it is silently replaced by 3000, and string parameters accept ${var} interpolation. require, on_error, and node_timeout_ms are only covered by their schema text.

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

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

The description names a specific verb and resource: it pops up a Dynamic Island style capsule at the top of the screen and auto-dismisses. That is concretely distinct from a generic notification. It never distinguishes itself from near-identical siblings such as ACTION_TOAST or ACTION_SEND_NOTIFICATION, so an agent must infer which popup tool to pick.

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

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

Usage is only implied through behavioral facts: it is non-blocking, so the next node runs immediately, and it requires host-app registration plus overlay permission. There is no explicit when-to-use or when-not-to-use guidance, and no sibling is named (ACTION_TOAST, ACTION_SEND_NOTIFICATION, ACTION_MINI_SCREEN are the obvious alternatives).

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

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

With no annotations, the description carries the full burden and does well: it discloses time-limited polling, the accessibility-service requirement ('需无障碍'), that results come back as a variable-snapshot JSON, and the exact output field names. It omits failure/retry semantics, but those are largely covered by the require/on_error schema fields.

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

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

Front-loaded with the core verb and the output list, which is good, but the sentence order is somewhat scattered and a duplicated '。。' punctuation error slightly hurts readability. Nothing is grossly verbose, but the structure could be tighter.

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

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

There is no output schema, and the description compensates by enumerating all five returned fields and explaining the bounds format. Combined with the accessibility prerequisite and variable-snapshot return note, an agent has nearly everything needed to call and interpret this tool; only sibling differentiation and failure behavior are thin.

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

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

Schema description coverage is 100%, so the schema already documents selector, search_mode, region, timeout and the rest in detail. The description adds only the general '${var} interpolation for string parameters' rule, which is marginal value on top of the schema's own per-parameter notes.

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: '限时轮询查找界面元素' with polling semantics and outputs. It does not, however, distinguish itself from the very similar sibling ACTION_WAIT_FOR_ELEMENT, leaving the agent to guess which finder to pick.

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

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

Provides one concrete usage caveat (element_bounds cannot be passed directly as ACTION_CLICK's target, or you hit the top-left corner), which is genuinely useful. But it gives no guidance on when to use this over ACTION_WAIT_FOR_ELEMENT, ACTION_READ_SCREEN, or ACTION_CLICK, so alternatives are only implied.

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

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

With no annotations supplied, the description carries the full burden and does add real behavioral detail: toggle is stateful per run and defaults to on without a prior record, there is no way to read the current flashlight state, string parameters accept ${var} interpolation, and results come back as a variable-snapshot JSON. It omits device-permission requirements and whether the light persists after the workflow ends.

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?

Four compact clauses with the purpose front-loaded and no filler; the output variable names are stated up front where an agent will see them first. Minor blemishes: a duplicated "。。" and a slightly abrupt jump from toggle semantics to interpolation/return format.

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

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

There is no output schema, and the description compensates by naming both return variables (flashlight_success, flashlight_on) and the snapshot-JSON shape. For a simple one-enum actuator with fully documented parameters this is nearly sufficient, though it could note what happens on failure or whether the light state survives run completion.

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 baseline is 3; the description earns above that by explaining the semantics of the `toggle` enum value (invert run-recorded state, else turn on) which the schema only labels as "on/off/toggle". It also clarifies that ${var} interpolation applies to string parameters such as `require`.

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 first clause "手电筒开关" names a specific resource plus the concrete action set (on/off/toggle) resolved through the `action` enum, so the agent knows exactly what the tool controls. It does not explicitly differentiate itself from adjacent hardware-control siblings such as ACTION_BRIGHTNESS or ACTION_SCREEN_WAKE, which keeps it one step below a 5.

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

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

The note that no synchronous state-query API exists, and that toggle inverts the run-recorded flashlight_on (defaulting to on), implicitly steers the agent toward on/off when state is known. However, it never states the condition explicitly ("prefer on/off when you know the current state") and gives no exclusions or error-handling guidance for the non-toggle actions.

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 permission prerequisites (accessibility or Shizuku/root), the fallback chain, the failure sentinel (unknown plus foreground_success=false), and the short-class-name format of foreground_class. It does not describe latency or whether the accessibility path consumes events, so it stops short of full 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?

Front-loads the core purpose and output contract before the cross-cutting boilerplate about params, ${var} interpolation, and snapshot return. Slightly overpacked into one paragraph with a duplicated '。。' typo, but no substantive waste.

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

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

There is no output schema, so the description correctly enumerates the returned variables and the failure-state values. Combined with the disclosed permission requirements and params requirement, an agent has enough to call it correctly; only latency and side effects are unstated.

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

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

Schema description coverage is 100%, so all six parameters including require, on_error, use_shell, and the two _var names are already documented in the schema. The description mainly restates defaults and adds the foreground_class short-name detail, which maps only indirectly to the activity_var parameter. 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?

States a specific verb and resource: '获取前台应用包名/Activity', and enumerates the exact output fields (foreground_package, foreground_success, foreground_activity, foreground_class). An agent can tell this reports the current foreground app rather than app metadata or launching 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?

Gives the acquisition strategy (accessibility first, shell dumpsys fallback), the prerequisite (accessibility or Shizuku/root), and points to the use_shell parameter to force the fallback. It does not explicitly say when to prefer sibling tools such as ACTION_GET_APP_INFO, but the operating context is clear.

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 a lot: it lists the exact output variables, states only the first match is used for address lookups, warns that same-named variables get overwritten, flags the third-party overseas service as possibly slow or unreachable, and fixes connect/read timeouts at 10s each. It stops short of Nominatim's rate-limit/usage policy and says nothing about what a partial or empty result looks like beyond the geocode_error variable.

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 information-dense and front-loaded with the core address↔coordinate purpose, then output variables, then caveats. It is slightly cramped, with a doubled period and several clauses packed into one run-on sentence, but almost every clause carries operational 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 6-parameter tool with no output schema, the description compensates well by enumerating the returned variable snapshot and its error variable. Remaining gaps—rate limits, behavior with multiple matches, and interaction with the workflow-level require/on_error controls—are minor rather than blocking.

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 all six parameters are already documented, including the address-over-coordinates precedence rule the description repeats. The description adds only the ${var} interpolation note, and says nothing extra about require, on_error, or node_timeout_ms beyond what the schema states, so this is the baseline-3 case.

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

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

The description names a specific verb-pair and resource: bidirectional lookup between address and latitude/longitude, via OpenStreetMap Nominatim, key-free but network-required. It explicitly names ACTION_GET_LOCATION as the source of conflicting latitude/longitude variables, so an agent can distinguish the two geo tools without opening a schema.

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

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

Direction is clear: supply address to get coordinates, supply latitude/longitude to reverse-lookup an address, and address wins when both are present. What is missing is an explicit exclusion ('do not use this for device GPS position – use ACTION_GET_LOCATION'), which is only hinted at through the variable-overwrite warning.

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

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

No annotations exist, so the description carries the full burden, and it discloses the key traits: accessibility dependency, the 'unknown' fallback value, ${var} interpolation in string params, and JSON variable-snapshot output. It doesn't cover latency, extra permissions, or whether reading is side-effect free, which keeps it below a 5.

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 purpose and the accessibility requirement come first, followed by output and fallback guidance, which is a sensible order. There is minor redundancy in listing the output variable names already covered by the schema, and a stray double punctuation mark ('。。'), but no real padding.

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 five-parameter read tool with no output schema, the description covers the return values, the failure mode, and the alternative tool, and the fully-documented schema handles the rest. Only minor behavioral details such as side-effect freedom are absent.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters including the output_var/activity_var defaults. The description only restates the default output variable names and notes interpolation for string params, adding marginal meaning beyond the schema. Baseline 3 applies.

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

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

The description opens with a specific verb and resource: reading the foreground app's package name and Activity, and it names the mechanism (accessibility). It also distinguishes itself from the sibling ACTION_FOREGROUND_APP, so an agent can choose between them without opening either schema.

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

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

The description states the accessibility prerequisite, describes the degradation behavior when accessibility is off, and explicitly routes the agent to ACTION_FOREGROUND_APP when a shell fallback is needed. This gives both the when-to-use and a concrete 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?

With no annotations, the description carries the full burden, and it does meaningful work: it lists the four result variables including an explicit success/error pair, and clarifies that headset_connected covers wired/USB and Bluetooth A2DP. It omits anything about permissions, foreground requirements, latency, or what audio_state_error contains when the read fails.

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

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

Purpose is front-loaded in the first clause, followed by the output variable list, then the interpolation/return-format note. Dense and largely waste-free, though the closing sentence reads as framework boilerplate rather than tool-specific 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?

No output schema exists, so the description must name return values and it does, covering both the data variables and the error variable, plus the JSON-snapshot return form. For a simple boolean-state reader this is nearly sufficient; only failure modes and preconditions are unaddressed.

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

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

Schema description coverage is 100%, so the three framework parameters (require, on_error, node_timeout_ms) are already documented, and the baseline is 3. The note that string parameters support ${var} interpolation adds a small amount of meaning beyond the schema, but nothing tool-specific about require or on_error is elaborated.

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 concrete read action and names the exact states read (music playback, headset connection), which an agent can distinguish from the mutating siblings ACTION_MEDIA_CONTROL and ACTION_PLAY_MEDIA. It never explicitly names those siblings, so differentiation is by implication rather than statement.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites, and no pointer to ACTION_MEDIA_CONTROL for the action side. The only cue is that it is a state query, which an agent must infer from the verb.

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 a fair job: it discloses the output variable contract, the 0–100 range of battery_level, the edge case that battery_charging stays true when full, the presence of success/error variables, and that results arrive as a variable-snapshot JSON with ${var} interpolation in string params. It never states that the operation is read-only/no-permission, but the wording 读取 makes the read semantics unambiguous.

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

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

Front-loaded with the action, then the output contract, then the interpolation/return-format note — logical order with no padding. Minor defect: a doubled period ("。。") and the output-variable list slightly duplicates the schema's output_var note.

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

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

No output schema exists, so the description must define the return surface itself — and it names every returned variable, their ranges and edge cases, plus the snapshot/interpolation behavior. Combined with 100% schema coverage of the four generic control params, an agent has everything needed to call and consume 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 four parameters (require, on_error, output_var, node_timeout_ms) are already fully documented in the schema and the description adds nothing about them. It does add meaning about the return values and interpolation, but that is output-side, not parameter-side; 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 opens with a specific verb+resource (读取电量和充电状态) and enumerates the exact output variables (battery_level, battery_charging, battery_success, battery_error), so the agent knows precisely what this tool produces. It does not explicitly differentiate itself from nearby siblings such as ACTION_GET_DEVICE_INFO or ACTION_GET_STORAGE_INFO, 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?

Usage is only implied by the resource name — an agent can infer 'call this when you need battery state' but there is no explicit when-to-use/when-not guidance and no named alternative for richer device queries. No prerequisites or preconditions 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 supplied, the description usefully discloses the required permission, the four output variables, all call-state values, and the variable-snapshot JSON return form. It could further explain what happens when permission is denied and how call_success and call_error are populated.

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 purpose and permission requirement are front-loaded, followed by compact output definitions and return-format details. The text is efficient overall, though the duplicated punctuation and generic interpolation boilerplate slightly reduce polish.

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 tool with no required parameters or annotations, the description supplies the key permission, state vocabulary, output names, and return representation needed to invoke and interpret it. The input schema separately covers assertion, error handling, and timeout controls, leaving no major invocation 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 already 100%, so the three workflow-control parameters need little additional explanation. The description nevertheless adds useful invocation semantics not present in the schema by stating that string parameters support ${var} interpolation.

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 reads the current phone call state, and the idle/ringing/offhook mappings clarify its exact scope. It does not explicitly distinguish this instantaneous state read from siblings such as ACTION_WAIT_CALL_ANSWER or ACTION_WAIT_CALL_END.

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

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

Usage is implied for inspecting the call state at the current moment, and the READ_PHONE_STATE permission prerequisite is stated. However, there is no explicit guidance on when to use this tool rather than waiting for call events or reading related device audio state.

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 burden. It does disclose useful behavior beyond the schema: the exact output field names and the fact that results are returned as a variable-snapshot JSON and that string parameters support ${var} interpolation. However, it says nothing about permissions, timing/cost of the call, or whether the snapshot persists across nodes.

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

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

Two compact sentences, front-loading the purpose before the output-field enumeration and the interpolation note. The long run of device_* field names is dense but functional; nothing is 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?

With no output schema, the description compensates well by enumerating all returned device_* fields, so an agent knows exactly what it gets back. Tool complexity is low and the schema covers the execution-control parameters, so only the missing when-to-use context keeps this from a 5.

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

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

Schema description coverage is 100%, so the three parameters (require, on_error, node_timeout_ms) are already fully documented in the schema — baseline 3 applies. The description adds only the generic note that string parameters accept ${var} interpolation, which is a marginal addition rather than parameter-specific 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 states a specific verb and resource in '读取设备型号、Android 版本和屏幕尺寸', and the enumerated output fields (device_model, device_sdk, device_screen_width, etc.) further pin down the scope. This distinguishes it from the many other readers in the sibling list (ACTION_GET_APP_INFO, ACTION_GET_SCREEN_STATE, ACTION_GET_BATTERY), though it never names a sibling explicitly.

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

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

There is no statement of when to use this tool versus alternatives — no mention of prerequisites, no exclusion of overlapping tools like ACTION_GET_SCREEN_STATE or ACTION_GET_APP_INFO, and no guidance on whether it must precede other device-info calls. Usage must be inferred from the enum of returned fields.

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 burden; it does disclose the permission requirement, the no-active-fix behavior, possible staleness, and units for accuracy and the millisecond timestamp. It does not say what location_error contains on permission denial or how the variable snapshot is scoped, which leaves gaps for a mutation-free but environment-dependent read.

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 core constraint (last known, not active) is front-loaded, and the enumerated output fields earn their place since no output schema exists. Minor waste from the doubled full stop and the slightly dense run-on parenthetical structure.

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

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

With no output schema, listing the seven returned fields is genuinely necessary and is provided; staleness and permission caveats round it out. It would be complete with guidance on recovery when location_success is false, e.g. advising a fallback or an active-fix path.

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 four workflow parameters (require, on_error, output_var, node_timeout_ms) are already documented inline. The description adds only the generic note that string parameters accept ${var} interpolation and that results return as a variable snapshot, which is useful but not parameter-specific.

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 precise verb and resource: it reads the system's last known location, explicitly noting that the newer of GPS/network is chosen. The emphasis on 'last known / cached' rather than an active fix distinguishes it from any active-locate or geocoding sibling such as ACTION_GEOCODE.

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 clearly states the precondition (requires location permission) and the key exclusion ('does not actively locate'), plus the failure case if the device has never been located. It stops short of naming alternatives or telling the agent what to do when it fails, so no explicit routing to a fallback tool.

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

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

No annotations are provided, so the description has to carry the full burden of disclosure. It does useful work by naming the four output variables and saying that results come back as a variable snapshot JSON. It does not say whether the call is read-only, whether it needs any permissions, or how long it takes.

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

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

The description is short and front-loaded: the read purpose comes first, followed by outputs and the interpolation note. Every sentence adds information. The wording is dense but not padded.

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

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

There is no output schema, but the description compensates by enumerating the return variables (screen_on, screen_locked, screen_state_success, screen_state_error). Parameters are fully covered by the schema. The remaining gap is the absence of any pointer to alternatives among the many screen-related siblings.

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

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

Schema description coverage is 100%, so the schema already documents require, on_error, and node_timeout_ms, and a baseline of 3 is appropriate. The one addition beyond the schema is that string parameters support ${var} interpolation, which is genuinely useful. The description does not explain which parameters the interpolation applies to.

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

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

The description opens with a specific verb+resource: reading whether the screen is on and whether it is locked. That is enough for an agent to know what the tool does. However, it does not distinguish the tool from related siblings such as ACTION_READ_SCREEN, ACTION_SCREEN_WAKE, or mini_screen_status, so the agent has to 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?

The description says what the tool reads but never says when to use it, when not to use it, or which sibling to choose instead. With several screen-related siblings, an agent that wants to know whether the screen is lit receives no guidance on whether to use this tool, ACTION_SCREEN_WAKE, or mini_screen_status.

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 disclosure burden and does well: it declares the 3-second no-reading failure, the first-component-only behavior (X axis for accelerometer), the ${var} interpolation support, and the snapshot JSON return. It omits permission/auth requirements and does not explain what makes the read succeed or fail beyond the timeout.

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

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

Front-loaded with the core action, then output fields, then constraints, with no filler sentences. A minor formatting blemish: a doubled Chinese full stop ('。。') and the trailing interpolation note sits slightly out of order.

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

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

There is no output schema, and the description fills that gap by enumerating sensor_value, sensor_type, sensor_success, and sensor_error. Since no annotations exist, the disclosed timeout and failure behavior is necessary and present. It is not fully complete because sensor-specific semantics (for example, what a proximity value represents) and permission needs are unstated.

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

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

Schema coverage is 100%, so all five parameters are already documented, establishing a baseline of 3. The description adds only the ${var} interpolation note and the first-component behavior, which is marginally useful but does not deepen the meaning of type, require, on_error, output_var, or node_timeout_ms.

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: reads one value from a light, proximity, or accelerometer sensor. That is clearly distinct from siblings such as ACTION_GET_BATTERY or ACTION_GET_DEVICE_INFO, though it never names an alternative or boundary.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no sibling alternative is mentioned. Usage is only implied by 'reads a single value', which an agent must infer.

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 and does well: it declares read-only semantics, lists the five result fields, states that values are always strings, and explains that setting_success=false covers both missing keys and permission denials under newer Android restrictions. It also discloses ${var} interpolation and that results are returned as a variable snapshot JSON. Missing only retry/timeout behavior, which the schema covers instead.

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

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

It is front-loaded with the purpose, then outputs, then failure semantics, then interpolation, which is a sensible order. There is a stray doubled period ('。。') and the five-field output enumeration is dense, but since no output schema exists the enumeration 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 six-parameter tool with no annotations and no output schema, the description covers the essential ground: what is returned, that values are strings, how failure is signalled, platform restrictions, and interpolation/return format. Only the interaction between require and on_error failure handling is left entirely to the schema, a minor 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%, so every parameter including key, namespace, require, on_error, output_var and node_timeout_ms is already documented, giving a baseline of 3. The description adds some meaning by noting string parameters support ${var} interpolation and that secure/global keys may be unreadable, but the interpolation note largely repeats the key schema description and it says nothing extra about namespace choice or output_var.

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, '读取一项系统设置（只读）' (read one system setting, read-only), so an agent immediately knows what the tool does and that it has no side effects. It does not differentiate from nearby siblings such as ACTION_GLOBAL_KEY or ACTION_SET_VARIABLE, which is the only thing keeping it from a 5.

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

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

Usage is implied by the read-a-setting purpose and the note that newer Android restricts reading certain secure/global keys, which hints at when reads may fail. There is no explicit 'use this when…, use X instead' routing against any of the dozens of sibling ACTION_* tools, so the agent must infer placement itself.

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 burden. It does well on prerequisites (READ_PHONE_STATE) and on output shape and formatting (comma-separated lists, possible empty sim_numbers, variable-snapshot JSON return), but it says nothing about failure behavior, whether a permission denial throws or returns sim_error, or interaction with the require/on_error parameters.

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?

Dense and front-loaded: capability, permission, outputs, then caveats. The only blemishes are a doubled full stop and a slightly cluttered inline enumeration of output fields, but no sentence is wasted.

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

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

With no output schema, the description correctly compensates by listing the returned fields and their formats. Since all four input parameters are fully described in the schema, the remaining omission (error semantics when permission is missing) is minor for a read-only probe 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%, so the baseline is 3; the description earns an extra point by documenting cross-cutting behavior not in the schema, namely that string parameters support ${var} interpolation and that results are persisted as a variable 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 opens with a specific verb and resource: reading SIM count, carrier and phone number, and it enumerates the exact outputs (sim_count, sim_carriers, sim_numbers). It does not explicitly distinguish itself from nearby siblings such as ACTION_GET_DEVICE_INFO, ACTION_GET_CALL_STATE or ACTION_NETWORK_STATUS, which an agent could plausibly confuse with SIM 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?

Usage context is implied by the READ_PHONE_STATE permission note and the caveat that many SIMs do not store a local number, so agents know to expect empty results. There is no explicit when-to-use or when-not-to-use guidance relative to the other device/network state 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 full disclosure burden, and it does add real value: the exact output variable names (including storage_success and storage_error) and the fact that results are returned as a variable-snapshot JSON object. However, it says nothing about permissions, platform constraints, or whether a failed read still returns partial fields, which matters for a device-state query.

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

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

Front-loaded with purpose in the first clause, followed by output fields and then a workflow-behavior note; no filler sentences. The output-field enumeration is long but earns its place since there is no output schema.

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

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

For a zero-required-parameter device-state read with no output schema, the description covers purpose, returned fields, and variable-snapshot semantics, which is what an agent needs to invoke and consume it. The remaining gap is the lack of any routing guidance against the many sibling read 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 description coverage is 100%, so the three parameters (require, on_error, node_timeout_ms) are already fully documented in the schema, establishing a baseline of 3. The description adds only an adjacent note that string parameters support ${var} interpolation, which is useful context but does not deepen any individual parameter's 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 states a specific verb and resource: read internal storage space, with units (bytes) made explicit. It is clearly distinct from siblings such as ACTION_GET_DEVICE_INFO or ACTION_GET_TRAFFIC, though it never names those alternatives 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?

There is no guidance on when to use this tool versus similar read tools like ACTION_GET_DEVICE_INFO or ACTION_GET_TRAFFIC, and no prerequisites or exclusions are stated. The agent must infer that this is a straightforward storage-status read from the purpose line 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 meaningfully discloses the output variables, variable-snapshot JSON return format, ${var} interpolation, and the potentially error-prone Sunday-based weekday numbering. It does not explicitly discuss timezone behavior or state that the operation is side-effect free, but it covers the important behavior of this simple read-oriented 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 front-loaded with the operation and then moves efficiently through outputs, compatibility details, and invocation behavior. The output enumeration is dense but justified by the absence of an output schema; the duplicated “。。” punctuation is a minor polish issue.

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 no required parameters, the combined definition covers invocation defaults and error handling through the schema while the description supplies output names, return structure, and interoperability semantics. Enumerating the outputs is especially valuable because no output schema is provided.

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 parameters are already well documented. The description adds value beyond that baseline by explaining that string parameters support ${var} interpolation, a cross-cutting invocation behavior absent from the individual parameter 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?

The opening “获取当前时间及年月日时分秒” clearly states that the tool retrieves the current time and its date/time components. It does not differentiate its purpose from siblings such as ACTION_WAIT_UNTIL_TIME; the ACTION_PARSE_DATETIME reference concerns weekday encoding rather than tool selection.

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?

Retrieving the current time provides an implied use case, but there is no explicit guidance on when to choose this tool over parsing, waiting, or other time-related actions. The sibling cross-reference is still useful because it prevents incorrect weekday interpretation.

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 returned field names and the snapshot-JSON result format, which is useful, but it says nothing about permissions, whether counters span all SIMs/interfaces, or how the schema's require/on_error behavior interacts with the read.

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

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

Three short clauses: purpose first, then output fields, then interpolation/result-format note. Nothing is redundant, though the output enumeration is a dense list that could be trimmed.

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 tool with no output schema, the description covers what is read, the fields returned, and the variable-snapshot result shape. The remaining gap is error/requirement semantics that the schema exposes but the description does not discuss.

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 already 100%, so the baseline is 3; the description adds a genuinely new cross-cutting fact - that string parameters accept ${var} interpolation - which the schema does not state. It still does not explain output_var/require interactions, so it is not a full 5.

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

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

The description states a specific verb and resource: read the device-wide cumulative RX/TX byte counters since boot. That clearly separates it from neighbors like ACTION_GET_STORAGE_INFO or ACTION_NETWORK_STATUS, though it never names an alternative explicitly.

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

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

There is no guidance on when to choose this over sibling tools that also report connectivity or device state (ACTION_NETWORK_STATUS, ACTION_GET_SIM_INFO), nor any prerequisite or exclusion. The agent must infer usage entirely from the purpose sentence.

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 load and does so: it discloses the provider, that no API key is needed, the network prerequisite, fixed 10s connect/read timeouts, the exact output variable names, and that results are returned as a variable-snapshot JSON. It also decodes the weather_code field, which is genuinely behavior-level information an agent could not infer.

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

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

Front-loaded with the core action, then progressively discloses outputs, units, timeouts, and the WMO code table — every block is useful. Minor blemishes: a duplicated period ('。。'), a stray trailing sentence, and the full output-variable enumeration is slightly bulky.

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

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

There is no output schema, so the description must explain return values, and it enumerates every returned variable plus units (℃, km/h) and the WMO code semantics. Combined with error variables and timeout behavior, an agent has everything needed to call and interpret 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 coverage is 100%, so the schema already documents latitude/longitude ranges, on_error, require, and output_var. Beyond that the description explains that string parameters accept ${var} interpolation and that weather_json is the default sink for the raw response, adding operational meaning on top of the schema text.

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: fetch current weather by latitude/longitude, and names the backing provider (Open-Meteo, key-free). This clearly separates it from siblings such as ACTION_GET_LOCATION (device coordinates) or ACTION_GEOCODE (place name to coordinates).

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 context (you must already have coordinates, and network access is required) but never says when to prefer this over ACTION_GET_LOCATION, ACTION_GEOCODE, or ACTION_HTTP_REQUEST for arbitrary weather APIs. Usage is inferable rather than stated.

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

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

With no annotations, the description carries the full burden and does disclose meaningful behavior: the privilege prerequisite (Shizuku/root or accessibility), a shell-keyevent-then-accessibility fallback chain for the four navigation keys, and which keys are accessibility-only or shell-only. It does not cover failure reporting beyond naming the key_success output variable.

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?

Very compact and front-loaded: purpose first, then prerequisite, then output contract, then interpolation note. The nested parenthetical ("（需...（见 key 说明））") is slightly dense but every clause carries 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?

There is no output schema, but the description names the return contract (key_success) and the variable-snapshot JSON shape, and it covers prerequisites and per-key channel constraints. The main remaining gap for an agent is disambiguation from ACTION_GLOBAL_NAV.

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 per-key channel semantics in the enum description already do the heavy lifting and the baseline is 3. The description adds only marginal meaning beyond the schema in this dimension, namely the ${var} interpolation support and that string params are interpolated.

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

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

States a specific verb and resource ("全局按键" – press global hardware/navigation keys) and enumerates the supported keys (back/home/recents/notifications/enter). However, it never distinguishes itself from the sibling ACTION_GLOBAL_NAV, which by name sounds like it covers the same navigation-key territory, so an agent cannot route between the two 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?

Conveys the precondition ("需 Shizuku/root 或无障碍") and, via the key description, which keys work through which channel with fallback ordering. It gives no explicit when-to-use vs when-not guidance and names no alternative tool, so routing between this and ACTION_GLOBAL_NAV remains 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?

With no annotations, the description carries the full burden. It does disclose the accessibility requirement, the output variables (nav_success, nav_error), ${var} interpolation, and that results come back as a variable-snapshot JSON — useful context beyond the schema. However it omits risk profile for disruptive actions (power_dialog, lock_screen) and any failure/timeout behavior for the navigation itself.

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

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

A single dense paragraph that front-loads the action list, then the prerequisite, then output and interpolation semantics. No filler, though the output-variable note could be separated for scannability.

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 four-parameter action dispatcher with no output schema, the description names the result fields (nav_success, nav_error), states the prerequisite, and explains interpolation. It lacks only risk/lifecycle detail for the more disruptive actions.

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 action, require, on_error, and node_timeout_ms are already documented in the schema. The description adds only the ${var} interpolation note, which lightly relates to string parameters like 'require', but explains nothing about the workflow-control parameters.

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 (accessibility global actions) and enumerates the eight operations (back, home, recents, notifications, quick settings, power menu, lock, screenshot), matching the enum in the schema. It hints at differentiation via '（需无障碍）' against siblings like ACTION_SCREENSHOT or ACTION_GLOBAL_KEY, but never names them explicitly.

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

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

It conveys the prerequisite (accessibility service required, no Shizuku) and implied usage — pick one of these eight global navigation actions. There is no explicit when-to-use versus ACTION_GLOBAL_KEY or ACTION_SCREENSHOT, and no guidance on which actions are destructive (power menu, lock screen).

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 so well: it discloses that failures do not throw, defines http_success as status 200–399, notes default skip-on-failure, and warns that headers/body must be JSON-escaped strings or they silently degrade to {k=v} text. It does not cover redirect handling, auth requirements beyond the header example, or rate limits, so it stops short of a 5.

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

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

It is front-loaded with purpose, then output fields, then failure semantics, then parameter gotchas — a sensible order with no filler sentences. It is dense to the point of being run-on and contains a duplicated sentence terminator ('。。'), but nothing is wasted.

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

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

For a 10-parameter tool with no output schema, the description supplies exactly what is otherwise missing: the names and meaning of the returned variables (http_success, http_error, http_status_code, http_response, http_truncated) and the shape of the return (a variable snapshot JSON). Combined with the error-handling and interpolation notes, an agent has enough to invoke it correctly without further context.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema: the string-vs-nested-object gotcha for headers and body is a behavioral trap the schema does not flag, and it explains the require=http_success idiom. That is genuine added value over the structured fields.

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 first sentence states a specific verb and resource — send an HTTP request and store the response body in a variable — plus the precondition (network required). No sibling tool in the list performs HTTP requests, so no disambiguation is needed; an agent knows immediately this is the outbound-network action.

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

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

It gives concrete when-to guidance: set a reasonable timeout for unstable third-party services, add require=http_success when a failed request should be treated as a node error, and rely on the default skip behavior otherwise. It lacks an explicit 'when not to use' clause, but with no competing HTTP sibling there is little to exclude.

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 and does substantial work: it discloses the return value (input_success), that a11y mode reads back to verify content, the privilege requirement for shell/ime, the non-ASCII limitation, and the focus-reporting quirk. It does not say whether typed text replaces or appends to existing content, which is a meaningful behavioral gap for an input tool.

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

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

Purpose and output are front-loaded, then caveats follow in a compact sequence. It is dense and mostly earns its sentences, though there is minor clutter such as a stray double period and a slightly run-on mode/parenthesis clause.

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 8-parameter, 3-mode action with no output schema, the description covers output name, verification behavior, platform prerequisites, non-ASCII limits, and interpolation. The main missing piece is the replace-vs-append semantics of the text parameter.

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

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

Schema description coverage is 100%, so the schema already explains every parameter and the baseline is 3. The description adds a little (mode requirements, why target matters, ${var} interpolation applied to all string parameters) but mostly restates what the schema already documents.

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?

Opening clause gives a specific verb+resource (write text into an input box) plus the optional submit behavior, so the agent immediately knows what the tool does. It never names a sibling such as ACTION_CLICK or ACTION_TEXT_OPERATION to draw a boundary, 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?

Gives concrete selection guidance: use a11y mode for Chinese/non-ASCII, shell/ime only when Shizuku or root is available, and pass target coordinates for QQ/WeChat inputs that do not report focus. No explicit exclusions or named alternative tools are given, so it is clear context rather than a full when/when-not rule set.

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 does substantial work: it names the output variables, warns that on Android 10+ a background launch may be silently blocked while launch_success still returns true, and explains that launch_has_overlay reflects overlay permission as a background-launch exemption. That is exactly the kind of non-obvious failure mode an agent needs. It stops short of stating required permissions, whether an overlay prompt is triggered, or any timing/latency expectations, so not a 5.

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?

Purpose is front-loaded in the first clause, followed by return values and then the critical Android 10+ caveat — a sensible order. It is compact for the amount of behavioral content packed in, though the doubled period ('。。') and the slightly run-on caveat sentence show minor polish issues.

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

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

There is no output schema, and the description compensates by enumerating the four returned variables and their meanings, including the counterintuitive launch_success caveat. Combined with a fully documented six-parameter schema, an agent has enough to call this correctly; only permission prerequisites and failure-handling behavior (beyond on_error) are left unstated.

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

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

Schema description coverage is 100%, so all six parameters (including the on_error enum and node_timeout_ms default) are already documented in structured form, making 3 the baseline. The description adds only the cross-cutting note that string parameters accept ${var} interpolation, which is genuinely useful but does not deepen any individual parameter's 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 states a specific verb and two concrete resources: launch an app (package_name) or open a system settings page (intent_action). An agent can immediately tell this is a launch/activation action rather than a query or search. It does not explicitly differentiate itself from look-alike siblings such as ACTION_APP_SEARCH or ACTION_FOREGROUND_APP, which keeps it at 4 rather than 5.

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

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

Usage is implied through the two modes ('open app' vs 'open a settings page'), and the schema clarifies that intent_action overrides package_name. However, there is no explicit when-to-use guidance against alternatives — an agent must infer on its own whether to call this versus ACTION_APP_SEARCH, ACTION_GET_APP_INFO, or ACTION_FOREGROUND_APP when it wants to know or confirm the foreground app.

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 and does disclose the key traits: output destination (Logcat, tag HabitatLog), exclusion from the workflow run log, ${var} interpolation in string parameters, and a variable-snapshot JSON result. It does not discuss failure semantics of the node itself (that lives only in the schema's on_error/require fields), which keeps it just short of a 5.

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?

Purpose is front-loaded in the first clause, followed by the destination constraint and the alternative routing, then the interpolation/return notes. It is compact and earns its sentences, but the stray doubled punctuation and the dense packing of three distinct facts into one line slightly reduce polish.

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 five-parameter tool with no annotations and no output schema, the description covers the essentials an agent needs: where the log goes, what it does not do, how interpolation works, and what shape the result takes (variable snapshot JSON). Only the per-node error/timeout behavior is left entirely to the schema, which is acceptable given 100% coverage there.

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 level, require, on_error and node_timeout_ms are already fully documented in the schema. The description adds only the ${var} interpolation note, which the schema also mentions for message, so it contributes little beyond the structured fields; 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?

"输出一条调试日志" gives a specific verb plus resource, and the description immediately bounds the scope: it writes only to Logcat under tag HabitatLog and never to the workflow run log. It also names the sibling actions to use instead when the goal is user-visible output, so an agent can separate it from ACTION_TOAST/ACTION_WORKSPACE without inspecting 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?

The description states an explicit when-not condition (do not use this if the user should see the message) and names the concrete alternatives, ACTION_TOAST and ACTION_WORKSPACE. It also implicitly scopes use to developer/diagnostic tracing by calling it a debug log written only to Logcat.

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 supplied, the description carries the full burden and does most of it: it discloses the accessibility dependency, the strict parse-failure semantics (deliberately different from ACTION_CLICK), unsupported region/occurrence options, ${var} interpolation for string parameters, and that results are returned as a variable snapshot JSON. It omits side effects/rollback and any rate or timing caveats, which keeps it short of a 5.

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

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

It is front-loaded with the verb and target modes, then the key behavioral caveat, then output and interpolation notes — a sensible ordering with no filler. It loses a point for a duplicated punctuation artifact ('。。') and a slightly run-on sentence that merges the failure-mode, unsupported-options, and interpolation topics.

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 5-parameter action tool with no output schema and no annotations, the description covers the critical unknowns: prerequisite (accessibility), output variable name and return shape (variable snapshot JSON), and the failure contract. Remaining gaps (interaction of duration with the text-matching path, timeout behavior interplay) are partially covered by the input schema.

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 target, require, duration, on_error, and node_timeout_ms. The description adds genuine meaning only for target (comma implies coordinate mode, parse failure is fatal) and a general note that string params support ${var}; the other four parameters get no added semantic context 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 names a specific verb+resource (长按 / long press) and states the two target resolution modes (coordinates or UI text/viewId), plus the accessibility prerequisite. It explicitly contrasts its parsing behavior with the sibling ACTION_CLICK (no fallback to text matching), so an agent can distinguish the two without opening either schema.

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

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

It gives clear operating context: requires accessibility service, and comma-containing targets are always parsed as coordinates with hard failure rather than falling back to text matching. It also rules out region/occurrence options, implicitly routing those needs elsewhere, but it never names a positive alternative tool or states explicitly when a caller should prefer ACTION_CLICK instead.

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 usefully discloses non-obvious behavior: the body’s final next must point back to the loop, the loop node’s own next is the exit path, and counter_var resets to 0 after count mode. It also mentions interpolation and variable-snapshot JSON output, though failure and iteration-limit behavior are left to the schema.

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 compact, front-loaded with the purpose, and devotes nearly every sentence to invocation-critical behavior. The duplicated Chinese full stop and the slightly dense presentation are minor polish issues.

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?

Together with the fully described schema, the description covers the essential information needed to configure and wire this comparatively complex control-flow node, including output behavior despite the absence of an output schema. A small ambiguity remains between “输出：loop_index,” support for a custom counter_var, and the later statement that the result is a variable snapshot JSON.

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 parameters are already well documented. The description adds meaningful lifecycle and structural semantics for body_node and counter_var, especially the required back-edge and post-loop counter reset, rather than merely repeating 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 opening “计数或条件循环” clearly identifies the tool as a count-based or condition-based workflow loop, and the next sentence explains its body-versus-exit control flow. It does not explicitly differentiate itself from siblings such as ACTION_RETRY or CONDITION_SWITCH.

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 usage contexts—counted iteration and conditional iteration—and supplies essential wiring guidance for constructing a loop body. It does not state when not to use a loop or name an alternative for retries or ordinary conditional branching.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses that all results are decimals, that division by zero yields 0, that unparseable operands are treated as 0, that ${var} interpolation is supported, and that output is a variable-snapshot JSON. It does not explain the error-flow semantics of require/on_error, but those are documented in the schema.

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?

Content is front-loaded and dense, with the operation scope first and caveats after; every clause conveys real information. Minor blemishes: a stray doubled period ('。。') and a run-on sentence chained with semicolons that mixes output type, comparison caveats, and error behavior.

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

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

For a 7-parameter math node with no annotations and no output schema, the description covers the essentials an agent needs: output variable, return format, numeric type coercion, interpolation, and zero/parse failure edge cases. The remaining parameters (require, on_error, node_timeout_ms) are fully described in the schema, so nothing critical 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?

Schema coverage is 100%, so every parameter already carries its own description, which sets the baseline at 3. The description adds only marginal extra meaning, notably that string parameters support ${var} interpolation, a point the schema also touches on.

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 precise verb+resource: arithmetic on two numbers covering the four basic operations, modulo, and power, and names the default output variable math_result. An agent can tell this apart from siblings like ACTION_TEXT_OPERATION or ACTION_ASSERT, though it never explicitly contrasts itself with them.

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

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

Usage guidance is indirect: it warns that results are always floats and that CONDITION_SWITCH must compare with 5.0 under == or use > / <, which is genuinely actionable downstream advice. However, it never states when to pick this tool over alternatives such as ACTION_RANDOM, ACTION_SET_VARIABLE, or ACTION_ASSERT, 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 and does well: it discloses the Shizuku/root permission requirement, the output variables (media_success, media_error), and that results are returned as a variable-snapshot JSON. It omits what happens when no media session is active or how failures are reported beyond the error variable.

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

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

Three short clauses, front-loaded with purpose then prerequisite then output/interpolation behavior. No filler, though the interpolation remark is dense shorthand an agent must parse.

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 4-optional-parameter, no-annotation, no-output-schema action, the description covers what it does, what it needs (Shizuku/root), what it returns, and templating support. Remaining gaps (no-active-session behavior, error semantics) are minor against a fully documented schema.

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 enum, defaults and per-parameter meanings are already documented in the schema. The description adds one genuine cross-cutting fact — string parameters support ${var} interpolation — but says nothing about cmd/require/on_error semantics beyond that, so baseline 3 fits.

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: 'send media keys (play/pause/track skip, etc.) to the currently playing app'. The scope 'currently playing app' distinguishes it from siblings like ACTION_PLAY_MEDIA, ACTION_VOLUME or ACTION_GLOBAL_KEY without naming them explicitly.

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

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

Gives a real prerequisite ('requires Shizuku or root'), which is useful context for selecting the tool. However it never says when to prefer this over ACTION_PLAY_MEDIA, ACTION_VOLUME, or ACTION_GLOBAL_KEY, and gives no exclusions or failure 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 supplied, the description carries the full burden and does substantial work: it declares non-blocking behavior, the permission prerequisite, that output is returned as the variables mini_screen_success/mini_screen_shown/mini_screen_error, and — importantly — that once a user dismisses the overlay during the run, later writes only update content and do not re-pop (mini_screen_shown=false). It also notes the source label cannot be set via parameters. What it omits is whether concurrent invocations create multiple overlays and any cost/rate implications of repeated writes.

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 structure is front-loaded and logical: purpose and prerequisite, then output variables, then input constraints, then behavioral traits. Sentences are dense but each carries information; the parenthetical prerequisites and the trailing interpolation note are slightly compressed but nothing is redundant.

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 10-parameter, zero-required, no-output-schema tool, the description covers the essentials an agent needs: what it renders, permission gating, non-blocking semantics, the minimum-content rule, dismissal persistence, and the names of the result variables. The main remaining gap is interaction with the mini_screen_status sibling and any multi-overlay behavior, which matters given the tool's UI side effects.

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

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

Schema coverage is already 100%, so the baseline would be 3; the description adds real meaning beyond it by stating the cross-parameter rule that show/append requires at least one of text, image, title, or progress — a constraint the schema does not encode since zero parameters are marked required. It also documents ${var} interpolation across string parameters and that results come back as a variable snapshot JSON, both of which are semantic additions rather than restatements.

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 resource and capability: a floating mini-screen that shows text, images, and progress to the user in real time. It is clear enough to distinguish from most siblings, but it never names mini_screen_status (the natural query counterpart) or explains how it differs from ACTION_TOAST or ACTION_SEND_NOTIFICATION, so the differentiation is left implicit.

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

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

Usage is implied by 'show text/images/progress to the user in real time' plus the stated prerequisite (Habitat accessibility service or overlay permission), which is genuinely useful context. However, there is no explicit when-to-use vs. when-not guidance and no routing to mini_screen_status for reading current state, leaving the agent to infer the boundary.

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 and does reasonably well: it enumerates the output variables (network_connected, network_type, wifi_ip, mobile_ip, network_success, network_error), lists the possible network_type values, and discloses a non-obvious quirk that mobile_ip is actually the first non-loopback IPv4 address and may equal the WiFi address. It also notes that results are returned as a variable-snapshot JSON. It does not cover permission requirements or whether the call has 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 purpose is front-loaded, followed by output fields, then the mobile_ip caveat, then the interpolation note; every sentence carries information. Minor polish issues remain, such as the doubled '。。' punctuation, but there is no filler.

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

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

There is no output schema, so the description appropriately enumerates the returned variables and their likely values, and it flags the mobile_ip edge case that would otherwise mislead an agent. The omission of permission or side-effect information is minor for what is fundamentally a read-only status probe.

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 four parameters are already documented in the schema and the baseline is 3. The description adds marginal value by noting that string parameters support ${var} interpolation, which is not visible in the schema, but it does not expand on require, on_error, or node_timeout_ms.

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 combination: query whether the device is online, the network type, and optionally the IP. The action enum values (status/ip/all) make the scope precise enough that an agent can distinguish this read-only status tool from ACTION_WIFI or ACTION_GET_TRAFFIC. It stops short of explicitly naming a sibling tool as the alternative.

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

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

The description implies usage through the action breakdown (status = connectivity only, ip/all = also return addresses), but it never states when an agent should pick this tool rather than ACTION_WIFI, ACTION_GET_SIM_INFO, or ACTION_GET_TRAFFIC. The 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 supplied, the description carries the full burden and does a fair job: it discloses the parse engine (LocalDateTime), the hard failure mode for date-only formats, weekday numbering (1=Monday…7=Sunday), ${var} interpolation on string params, and that results are returned as a variable snapshot JSON rather than a direct return value. It does not discuss what happens on error beyond the schema's on_error, but the mutation-to-workflow-variables side effect is disclosed.

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?

Purpose is correctly front-loaded in the first clause, but the middle is a flat run-on enumeration of eleven output field names that interrupts the flow, and there is a stray doubled period ('。。'). The output list is justified because no output schema exists, yet it could have been condensed into a pattern like datetime_{result,epoch,year,...}.

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 12-parameter, annotation-free tool with no output schema, the definition covers the essentials: what it does, the parse constraint, output variable names, and the interpolation convention. The main remaining gap is the total absence of routing guidance versus ACTION_GET_TIME, which an agent could easily pick instead for a simple 'now' read.

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 all 12 parameters and the baseline is 3. The description adds real value on input_format (must contain a time part, date-only will fail) and on ${var} interpolation across string parameters, but says nothing about the offset params (add_days/hours/minutes/seconds), output_var, require, or node_timeout_ms beyond what the schema states.

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+resource: get current time, parse or format a datetime, with optional offset arithmetic. That is clearly distinct from data-shaping siblings like ACTION_PARSE_JSON or ACTION_MATH, though it never distinguishes itself from the obvious sibling ACTION_GET_TIME, which overlaps on 'now'.

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 reader can infer parse vs format vs now from the action semantics. There is one genuinely useful usage constraint (input_format must include a time component, so pure yyyy-MM-dd fails), but no statement of when to prefer this over ACTION_GET_TIME or ACTION_WAIT_UNTIL_TIME.

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 disclosure burden — and it does real work here: it enumerates the four output fields, states that every result is a string, and flags the counterintuitive edge case that a missing path yields the string value null while parse_success stays true. It also discloses ${var} interpolation and that results are returned as a variable snapshot, though it does not explain what happens to pre-existing variables on failure.

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

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

Purpose is front-loaded in the first clause, followed by outputs and then edge cases — a sensible order with little waste. Minor blemishes: a duplicated sentence-ending punctuation mark ('。。') and slight redundancy between the null-path note and the general 'results are strings' 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?

With no output schema and no annotations, the description adequately enumerates return fields and covers the important null-path edge case. What is missing is minor but real: whether output_var overwrites existing variables and how require failures surface to the agent.

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 baseline is 3; the description goes beyond it by generalizing ${var} interpolation to all string parameters (the schema notes it only for json) and by clarifying the path parameter's failure semantics. It does not elaborate on require or on_error, which the schema already documents.

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 ('解析 JSON 字符串并按路径取值') and names the exact output fields. The resource (JSON) alone distinguishes it from ACTION_PARSE_XML and ACTION_PARSE_DATETIME, so an agent can select it 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?

The description explains behavior but never says when to use this tool rather than alternatives (for example, extracting a field from an HTTP response, versus using ACTION_TEXT_OPERATION or ACTION_ARRAY), and it never names a when-not condition. Usage is implied by context, but no explicit guidance 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?

With no annotations, the description has to disclose behaviour, and it does: it names the output variables (xml_parsed_value, xml_success, xml_error), explains that multiple matches come back as a JSON array string, and says results are returned as a variable snapshot. It could say more about how writing to variables affects the workflow state, but the key observable behaviour is 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 purpose comes first, then the output keys, then the multi-match behaviour, then interpolation. Every sentence carries information. Minor noise remains, such as a doubled Chinese full stop and the output list being repeated in prose.

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

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

For a seven-parameter tool with complete schema descriptions and no output schema, the description is nearly complete: it summarises the return values and the multi-match edge case. It could say more about on_error and require in workflow terms, but those are documented in the schema.

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 all seven parameters — including the dot-path, require and on_error semantics — are already documented in the schema. The description adds only the ${var} interpolation note, which the schema also states, so it adds little beyond the schema. A 3 baseline is right.

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: parse an XML string and extract element text or an attribute by tag path. That makes it easy to pick out against siblings, unlike ACTION_PARSE_JSON or ACTION_TEXT_OPERATION. It never names those neighbouring tools, though, so there is no explicit contrast.

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

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

When to use the tool is only implied: you have XML text (or a variable containing XML) and need a value out of it. Nothing states when not to use it, and nothing points to ACTION_PARSE_JSON or other alternatives. The note that a missing path returns the root element's text does help with how to call it.

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