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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal the primary state change (turning airplane mode on/off), but it says nothing about side effects, permissions, device prerequisites, or impact on network connectivity.

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

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

The description is a single concise sentence with no redundant wording. It is easily parseable and front-loads the core purpose, though it is quite terse and could carry more supporting detail without becoming bloated.

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 only two parameters and an output schema, the description is minimal but not fully complete. It omits when to use the tool, how the optional serial parameter affects behavior, and any side effects of toggling airplane mode, which an agent would need for reliable 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 0%, so the description must compensate for missing parameter explanations. It indirectly maps 'enabled' to turning airplane mode on/off, but it does not clarify the role of the optional 'serial' parameter or explain how the required boolean should be interpreted.

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 identifies the resource (airplane mode) and the specific action (switching it on or off), which is more informative than the tool name alone. This also separates it from sibling tools like wifi_toggle or bluetooth_toggle because it targets airplane mode specifically.

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

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

There is no guidance about when to use this tool versus alternatives such as wifi_toggle or set_mode. The description simply states what the tool does without providing context, exclusions, prerequisites, or example scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It lists some output fields and implies a read operation, but it does not mention side effects, required permissions, or how the app is identified. This is minimal transparency for an unannotated tool.

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

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

The description is a single concise sentence with no filler, and it front-loads the tool's purpose by naming the target resource and example output fields. It is economical, though slightly too terse to carry much behavioral or parameter 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?

Although an output schema exists and the tool is relatively simple, the description leaves parameter semantics and usage context unaddressed, and there are no annotations to compensate. An agent would likely understand what app_info returns, but not fully how to invoke it correctly in the broader toolset.

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

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

Schema description coverage is 0%, and the description never mentions the 'package' or 'serial' parameters. It adds no meaning beyond the schema's property names, leaving the optional 'serial' parameter entirely unexplained.

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

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

The Hungarian description translates to 'details of an application: version, installation date, permissions summary,' which clearly identifies the resource and the kind of data returned. It implies a retrieval operation and distinguishes this from a tool like list_apps, though it lacks an explicit verb such as 'get' or 'return'.

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

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

There is no guidance on when to use this tool versus alternatives like list_apps or device_info, and no mention of prerequisites or exclusions. The description states what the tool does but not where it fits among the many sibling tools.

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

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

With no annotations, the description carries the burden. It discloses a key behavior: never throws an exception and always returns a PASS/FAIL text, which is valuable. But it does not state whether the operation is read-only or has any side effects, nor what happens on failure beyond returning a string.

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

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

Two short paragraphs, front-loaded with the core purpose, followed by usage context and the critical behavioral guarantee. No redundant sentences.

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 assertion tool with an output schema, the description covers purpose, typical use, and error behavior. However, the untouched serial parameter and the lack of explicit mapping of the should_exist flag mean an agent might not invoke it entirely correctly on the first try.

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

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

Schema description coverage is 0%, so the description must explain parameters. It indirectly explains 'text' and the negation semantics of should_exist, but it never mentions the 'serial' parameter or how to set should_exist to false explicitly. This leaves a significant gap.

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

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

The description states a specific verb ('Ellenorzi' / checks) and resource (text visibility on screen), and clarifies it can assert both presence and absence. It positions itself as a final verification step in test flows, which distinguishes it from waiting or observation tools like wait_for_text.

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 context: use as a closing step of automated test flows, with examples of checking for a success message or absence of an error message. However, it does not explicitly name alternatives or exclusion criteria, so it stops short of a 5.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals that the tool invokes the standard adb backup mechanism, may require on-screen approval, and can be blocked by a broken screen. This is meaningful behavioral context beyond 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-loads the core purpose, and adds a clearly labeled important caveat. The extra clarification that the on-screen prompt is Android's own mechanism is slightly defensive but still relevant and not wasteful.

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

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

The description covers preconditions and interaction, but omits parameter guidance, default behavior for include_system, and any mention of overwrite behavior or output. For a tool with no annotations and 0% schema parameter descriptions, this leaves important gaps for correct invocation.

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

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

Schema description coverage is 0%, and the description does not explain local_path, serial, or include_system. The agent is left to infer parameter meaning solely from names, which is insufficient given the low coverage and required local_path parameter.

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

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

The description clearly states the tool creates a full ADB backup from the device into an .ab file on the computer, using a specific verb and resource. This distinguishes it from sibling tools like pull_file or list_apps, even without naming an 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 gives concrete preconditions: ADB debugging must already be enabled on the device, and the phone screen may prompt for confirmation or a password. It does not explicitly compare against alternatives, but it clearly explains when the tool can succeed and what limitations apply.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does describe what information the tool reports (charge, charging status, temperature), which helps an agent anticipate the result. However, it does not explicitly state that the operation is read-only, how the optional serial parameter affects behavior, or any error behavior.

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

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

The description is a single sentence listing three concrete battery attributes with no filler or redundant wording. It is appropriately sized for a simple status tool and the core information is front-loaded.

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

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

An output schema is present, so the return value structure is presumably covered elsewhere. The description conveys the main battery data points but omits the role of the optional serial parameter and any safety or read-only context. For a simple status tool this is adequate but leaves clear gaps.

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

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

Schema description coverage is 0% and the description does not mention the optional serial parameter at all. The description adds no meaning about which device is queried or whether serial must be supplied. The schema only provides a minimal title and type, leaving the agent without useful parameter guidance.

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 identifies a specific resource (battery) and the data points it exposes: charge level, state (charging/discharging), and temperature. This distinguishes it from sibling status tools like network_status and storage_usage. It lacks an explicit verb like 'get' or 'read', but the tool name and noun-phrase description make the purpose clear.

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

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

No guidance is given about when to use this tool versus alternatives, nor are there any prerequisites or exclusion conditions. Usage context must be inferred entirely from the tool name and the battery-specific resource, which is not sufficient for clear tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core toggle action and does not mention side effects, permission requirements, device connectivity impacts, or any other behavioral traits.

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

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

The description is a single concise phrase with no superfluous words. It is front-loaded with the core purpose, though its brevity leaves gaps that other dimensions penalize.

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

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

Given the lack of annotations and zero schema description coverage, the description is not complete enough for an agent to confidently invoke the tool. It lacks parameter meaning, usage context, and behavioral details, even though the tool itself is simple.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter explanations. It does not mention the required 'enabled' boolean or the optional 'serial' parameter at all, providing no semantic value beyond the parameter names themselves.

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 'Bluetooth be- vagy kikapcsolasa' clearly states the action (turning Bluetooth on or off) and the resource (Bluetooth). It is specific enough, though it does not explicitly differentiate from sibling tools like wifi_toggle or airplane_mode_toggle.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of situations where toggling Bluetooth might be appropriate or inappropriate. The usage context is entirely absent.

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 fully carries the behavioral disclosure burden. It warns that logins, saves, and cache are lost, that the app is reset to its post-installation state, that ADMIN mode is required, and that confirmation will be requested. This is strong transparency for a destructive operation.

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

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

The description is compact and front-loaded: the first sentence states the core purpose, and the second concisely adds consequences and requirements. Every sentence earns its place with no padding or repetition.

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

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

The destructive behavior, authentication need, and confirmation are well covered, and an output schema exists for return values. However, the tool has two parameters with no schema descriptions, and the description fails to explain them; usage guidance relative to sibling tools is also absent. Overall it is serviceable but not complete.

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

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

Schema description coverage is 0%, so the description must compensate, but it only weakly implies that the 'package' parameter identifies the target app. It does not explain the 'serial' parameter, the expected package name format, or how the optional serial affects 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 clearly states the operation: deleting all local data of an app, analogous to 'Clear data' in Settings, and explains that the app returns to its fresh-installed state. This is a specific verb and resource, and the 'new state' phrasing helps distinguish it from uninstalling or stopping an app, though no sibling is explicitly named.

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

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

The description provides no guidance on when to choose this tool over alternatives like uninstall_app, stop_app, or backup_apps_data. It mentions ADMIN mode and confirmation, but these are prerequisites, not usage-scenario guidance, and no exclusions or alternatives are given.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It goes beyond the tool name by explaining the underlying adb connect command, requiring a setup step on the device, and disclosing a significant limitation around pairing. It still does not describe error behavior, return output, or network requirements, but for a simple connection tool this is reasonably transparent.

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

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

The description is only two sentences, front-loaded with the exact command semantics, followed by the necessary prerequisite and caveat. Every sentence adds useful 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?

For a single-parameter tool with an output schema and no annotations, the description covers the core purpose, prerequisite, and known limitation. It does not mention whether the device must be on the same network or what happens on failure, but the essentials for using the tool are present.

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

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

The schema has 0% coverage and only provides a generic 'host_port' string with no description. The description compensates by showing the expected format 'adb connect ip:port' and by explaining the host/port value is provided by the Wireless debugging settings. This makes the parameter meaning reasonably clear, though it does not explicitly state that host_port is an IP:port string.

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

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

The description clearly states the tool connects over wireless ADB using 'adb connect ip:port', which is a specific verb and resource. It also notes that pairing codes are not covered, but it does not explicitly differentiate itself from sibling tools like disconnect_device or network_status, so it falls slightly 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?

The description gives an explicit prerequisite: the phone must have Developer settings > Wireless debugging enabled, and it explains where the address/port comes from. It also clearly states when not to use it: pairing on newer Android versions requires 'adb pair' and is not covered by this tool. It does not name an in-tool alternative, so it is not a full 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully warns that confirmation is requested and that the operation is irreversible. However, it does not mention whether directory deletion is recursive, what happens if the path does not exist, or any permission requirements.

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

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

The description is two concise sentences with no redundant wording. The core action is front-loaded, and the irreversibility warning is a valuable second sentence. Every word earns its place.

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

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

For a destructive file operation with no annotations, the description covers the essential safety warning and target type, but it omits practical details like how serial affects which device is targeted, whether directories are removed recursively, and any prerequisites. The presence of an output schema reduces the need to describe return values, but the missing path and serial semantics leave noticeable gaps.

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

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

Schema description coverage is 0%, so the description must compensate, but it only identifies the broad target ('file or directory') and does not explain the remote_path format, path constraints, or the role of the optional serial parameter. The parameter names are self-descriptive to some degree, but the description adds little beyond them.

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 explicitly states the action ('delete') and the resource ('file or directory') on the device, which is specific and distinguishable from siblings like move_path or make_dir. It clearly conveys what the tool does without ambiguity.

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

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

The description gives no guidance on when to use this tool versus alternatives such as move_path for relocation or list_files for inspection. It implies deletion use but does not state exclusions, prerequisites, or conditions where another tool should be chosen 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 carries full burden and delivers well: it discloses the tri-state value semantics, the critical rule that 'unknown' is an equally valid answer and that support must never be invented, plus the fallback behavior when ADB is unreachable. Absent disclosure: what happens when neither ADB nor hints yield data, and exactly which capabilities beyond video output are checked.

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 tightly written paragraphs with purpose front-loaded in the first sentence. The 'unknown is equally valid, never invent support' warning and the fallback instructions each earn their place. Slightly verbose in phrasing but no filler.

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

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

An output schema exists, so return-value format need not be in the description. The description covers value semantics and the non-ADB fallback path well, but leaves gaps: the role of scrcpy_path, fuller behavior of the ADB path via serial, and how this diagnostic tool relates to sibling diagnostic/rescue tools. Adequate but not complete for a 4-parameter tool with zero annotation support.

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

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

Schema description coverage is 0%, so the description must compensate. It does meaningfully explain manufacturer_hint and model_hint (manual fallback inputs for the known-model database lookup), and serial is loosely inferable as the ADB device identifier. However, scrcpy_path is entirely unexplained in both schema and description, leaving an important parameter semantically opaque.

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

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

The description states a clear verb+resource: 'Az eszkoz/gep helyreallitasi kepessegeinek diagnosztikaja' (diagnostics of the device/machine's recovery capabilities) and specifies the tri-state output values. This distinguishes it from device_info (general info) and the rescue_* session tools, though it never names those siblings explicitly, so full differentiation is left partly 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?

The description gives concrete situational guidance: when ADB is unavailable (broken screen, never-authorized device), supply manufacturer_hint/model_hint manually to query at least video output capability from the known-model database. This is clear context for when to use the fallback path, but it does not explicitly state when to prefer this tool over specific alternatives like rescue_probe or explain_capability.

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 available, so the description carries the burden of behavioral disclosure. It conveys that the tool returns device metadata and implicitly suggests a read-only operation, but it does not explicitly state side effects, connection requirements, or error behavior. This is adequate for a simple getter but not deeply transparent.

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

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

The description is very concise, with the returned fields front-loaded and the practical use cases in a short second sentence. No filler or redundant wording exists.

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

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

For a low-complexity read-only tool with an output schema, the description covers the main purpose and practical context. It lacks parameter guidance and sibling differentiation, but the tool is simple enough that the description is mostly complete.

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

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

Schema description coverage is 0%, and the description does not mention the serial parameter at all. The parameter name is self-explanatory, but there is no explanation of how it selects a device or what happens when it is omitted, leaving a noticeable gap.

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

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

The description clearly identifies the resource (device) and enumerates the returned data: manufacturer, model, Android version, SDK level, and build. It lacks an explicit verb and does not contrast itself with sibling tools like device_capabilities or device_list, so it is clear but not fully differentiating.

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

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

It explicitly states when the tool is useful: before any automation and when deciding upgrade options for older devices. It does not mention exclusions or alternatives, but the provided context gives a solid sense of appropriate usage.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the output fields (serial, status) and connection methods (USB or adb connect wifi). It does not mention edge cases like no devices connected or failure behavior, but for a simple read-only list operation the disclosure is adequate.

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 concise sentences in Hungarian front-load the main purpose, then detail the output fields, and finally provide the cross-tool usage note. Every sentence earns its place with no repetition or fluff.

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

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

For a zero-parameter listing tool with an output schema, the description fully covers what the tool does, what it returns, and how the result connects to sibling tool usage. Nothing critical is missing for an agent to call it correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description adds a useful note about how other tools use the 'serial' parameter, which indirectly clarifies the data this tool returns. There are no parameter ambiguities to resolve.

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

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

The description clearly states it lists connected Android devices and their serial numbers and status (device/unauthorized/offline), which is specific and actionable. However, it does not explicitly distinguish itself from sibling tools like device_info, though the resource and verb make the purpose unambiguous.

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

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

The description explains the key usage context: when multiple devices exist, other tools' 'serial' parameter is used to choose which device to operate on. This implies device_list is the way to discover available serials, but it does not explicitly state 'use this tool before other tools' or list 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 of behavioral disclosure, but it only says that a wireless ADB connection is disconnected. It does not explain whether the optional serial selects one device or all, whether disconnection is reversible, what side effects occur, or how failures are reported.

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 entire description is one short Hungarian sentence with no filler, redundant caveats, or irrelevant details. The core action is stated up front and the description is appropriately sized for a simple tool.

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

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

Although the tool is simple and has an output schema, the description is incomplete for correct invocation because the optional serial parameter is unexplained and no usage context is provided. An agent cannot determine whether the call disconnects a single specified device or the current/all wireless ADB connections.

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

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

Schema description coverage is 0% and the description never mentions the 'serial' parameter, so the agent cannot tell how the parameter affects which device is disconnected. The nullable, optional serial with no documented meaning is a significant gap that the description must compensate for but does not.

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

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

The description states a specific action ('Vezetek nelkuli ADB kapcsolat bontasa' – terminate wireless ADB connection) with a clear target device. It is more specific than the tool name, adding the wireless ADB scope, and no sibling tool overlaps with this exact function. It does not explicitly contrast with a sibling, so it stops short of a 5.

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

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

There is no guidance on when to use the tool, what preconditions must hold, or which alternative to choose. The description merely restates what the tool does rather than instructing an agent on when to invoke it, so the agent is left to infer usage from context.

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

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

With no annotations, the description must carry behavioral disclosure. It does state the core behavior and intent, but it does not explain coordinate units/origin, serial targeting, or failure/response behavior. The core action is simple enough that this is adequate but not rich.

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

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

The description is a single concise sentence with a useful example and no filler. It is front-loaded and easy to parse, though the brevity leaves some semantic gaps.

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 3 parameters, no annotations, and no schema descriptions, the definition is too thin. It omits serial semantics, coordinate system details, and any differentiation from sibling tap/long_press tools. The presence of an output schema helps return-value expectations but not call correctness.

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

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

Schema description coverage is 0%, so the description needs to compensate. It clarifies that x and y are the coordinates where the double tap occurs, but it leaves the serial parameter completely unexplained and does not specify coordinate units or origin.

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

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

The description states a clear action (double tap) on a specific resource (coordinate x,y) and gives a concrete use case (image zoom). It does not explicitly distinguish itself from the sibling tap/long_press tools beyond the tap count, so it stops short of a 5.

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

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

Usage is implied through the example 'pl. kep nagyitasahoz/kicsinyitesehez' (e.g. for zooming an image), but there is no explicit guidance on when to prefer this over tap, long_press, or other input tools, nor any exclusions.

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

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

There are no annotations, so the description carries the full behavioral disclosure burden. It does reveal the key behavior: this is a longer-duration swipe intended to avoid being treated as a flick. However, it omits important behavioral details such as coordinate system/units, whether the gesture blocks until completion, and the role of the optional serial parameter.

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

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

The description is a single sentence with no filler. It front-loads the operation and coordinates, then adds the behavioral rationale and a helpful example. Every part earns its place, and the parenthetical use case improves selectability without bloating the text.

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

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

Given the presence of an output schema and the relative simplicity of a drag gesture, the description provides the core invocation context: what the tool does, how it differs from a flick, and a typical use case. It is not fully complete because it does not specify coordinate space or explicitly explain the serial parameter, but the essential information is present.

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

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

Schema description coverage is 0%, so the description must compensate for missing parameter documentation. It maps x1, y1, x2, and y2 as the from/to coordinates and hints at the duration concept with 'longer duration swipe.' Yet it does not explain the serial parameter, and duration units are only recoverable from the schema's property name and default value, not from the description.

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

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

The description clearly specifies a drag gesture from (x1,y1) to (x2,y2) and explains that it should be a longer-duration swipe so the UI perceives it as a drag rather than a quick flick. It gives a concrete example (list item reordering), which aids selection. However, it does not explicitly name a sibling tool as the alternative, only the generic swipe/flick 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?

The description communicates when to use this tool: when the UI needs to recognize a drag and not just a fast flick, such as reordering list items. This is clear contextual guidance, but it does not explicitly state exclusions or directly recommend a specific sibling tool for quick flicks, so it stops short of full alternative routing.

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

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

With no annotations, the description carries the full burden and does state the core behavior: transforming a capability indicator into a human-readable explanation. However, it doesn't disclose what happens for unknown or malformed capability names, whether the explanation is localized, or where the data comes from. The core contract is visible but edge-case behavior is not.

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

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

The description is a single focused sentence with no filler, and the key information (explanation of a capability indicator) comes early. It loses one point because it is written in Hungarian while the schema title and properties are in English, which may reduce usability for agents operating primarily on English-language tool definitions.

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

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

For a one-parameter tool with an output schema present, the description adequately conveys purpose and gives an example value, so return-value detail is not required. But it omits the natural input source (device_capabilities), any error/edge-case behavior, and usage guidance, making it minimally viable rather than complete.

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

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

Schema description coverage is 0%, and the schema only labels `name` as a generic string, so the description must compensate. It adds meaning by characterizing the value as a 'kepesseg-jelzo' with a concrete example, but it never tells the agent where valid names come from (e.g., device_capabilities) or how to handle unrecognized values, leaving a real gap at zero schema coverage.

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

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

The description names a specific verb+resource: 'emberi nyelvu magyarazata' (human-language explanation) of a capability indicator, and grounds the abstract input with the concrete example 'wired_video_output'. The purpose is clear and distinguishable from siblings like device_capabilities (which presumably lists capabilities), though it doesn't explicitly state the 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?

The description offers no guidance on when to use this tool versus alternatives, no exclusions, and no mention that valid capability names likely come from the device_capabilities sibling. The intended usage is only weakly implied by the word 'magyarazata' (explanation), leaving the agent to infer the call context on its own.

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

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

With no annotations, the description carries the full burden. It discloses the core read-only behavior and the output fields, and an output schema covers return structure. But it does not address non-existent paths, symlink behavior, or what happens on permission-denied access.

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

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

One tight sentence with output fields front-loaded; nothing is wasted. Minor concern: the Hungarian text may be less accessible to English-centric agents, but it is brief and purpose-first.

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?

Two parameters, zero schema descriptions, zero annotations, and a large sibling set demand more than one sentence. The core purpose is clear and the output schema covers return values, but serial's meaning and selection guidance are missing, making this thin for reliable 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 0%, so the description must compensate, but it only lists output metadata, not parameter meaning. remote_path is reasonably self-explanatory by name, while serial is entirely unexplained — an agent cannot infer whether it is a device identifier, session ID, or something else.

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 single sentence identifies a concrete resource (a file or directory) and the deliverable (metadata: size, permissions, modification time). The metadata focus differentiates it from file-content tools like read_file, but the verb is implied rather than explicit ('metadata of' rather than 'retrieve/get').

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

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

No guidance on when to choose file_info over read_file, list_files, pull_file, or move_path — a meaningful gap given roughly 70 sibling tools. The metadata focus implies the use case, but no alternative or exclusion is named.

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

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

No annotations are present, so the description carries the burden of behavioral disclosure. It explicitly describes the interaction sequence: each field is found, tapped, then typed into with unicode-safe text. It does not discuss error handling or side effects, but the core behavior is transparent.

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

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

The description is front-loaded with the purpose, then provides the key mapping, a concrete example, and the underlying behavior. Every sentence contributes useful information with no redundant filler.

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

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

For a nested-parameter tool with no annotations and zero schema coverage, the description covers behavior and the `fields` parameter well. The unexplained `serial` parameter is a clear gap, and no alternatives are mentioned. An output schema exists, so omitting return-value details is acceptable, but the parameter gap keeps it from being fully complete.

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

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

The description thoroughly explains the `fields` parameter with a concrete example, which is valuable because schema coverage is 0%. However, the optional `serial` parameter is completely unexplained by both the schema and the description, leaving an important parameter gap.

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

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

The opening sentence states a specific action (fill multiple fields) on a specific resource (form fields) in one call. The field mapping and the reference to find_element/ui_dump make the operation unambiguous. It does not explicitly name a sibling like type_into, but the batch nature is clear.

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

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

The phrase 'in one call' plus the sequential find-tap-type behavior makes the intended batch-filling context clear. It also tells the agent where to obtain resource-ids via find_element/ui_dump. It does not state when to use a single-field alternative or exclude any cases, but the usage context is still evident.

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

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

With no annotations, the description carries the behavioral burden. It discloses the matching behavior (partial, case-insensitive), the requirement for at least one filter, and that multiple results are all listed with element_id. It does not mention behavior for zero results or the undocumented 'serial' parameter, but the output schema likely covers return details.

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 core purpose, and every sentence carries useful information. It also includes actionable routing to sibling tools without unnecessary filler.

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

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

The description covers key filters, matching behavior, and result handling, but the 'serial' parameter is left completely unexplained. Given four optional-looking parameters and no annotations, an agent could still be uncertain about the full expected input contract.

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

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

Schema description coverage is 0%, so the description must compensate. It explains text, resource_id, and class_name matching semantics, but does not explain the 'serial' parameter at all. This is partial compensation, not complete.

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

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

The description clearly states the tool searches UI elements on the current screen by text/content description, resource-id, and/or class, with partial, case-insensitive matching. This is a specific verb+resource and distinguishes it from generic tools like tap or type_text.

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

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

It explicitly requires at least one filter and explains how to use the returned element_id with tap_element/type_into when multiple results exist. This gives clear context for when to use it, though it does not name exclusion criteria or alternatives like wait_for_element.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It implies a read-only observation of the current screen state and explains the output's role, but it does not explicitly state that it has no side effects or how it behaves when no app is in the foreground.

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

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

The description is two short, purposeful sentences. The result is stated first in an efficient noun phrase, followed by one sentence explaining the usage context. No excess or redundancy.

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

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

For a simple, zero-required-parameter read tool, the description gives enough context to invoke without arguments and understand the returned concept. However, the complete absence of serial parameter documentation and any behavioral caveats leaves moderate gaps.

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

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

The input schema has one optional 'serial' parameter with 0% description coverage, and the description does not mention it at all. The agent gets no guidance on what serial selects or what the default null behavior means.

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 defines the tool's output: the name of the currently visible foreground application and activity. It also distinguishes this from visual or structural tools by framing it as the lightweight context before requesting ui_dump or screenshot.

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 explicit situational guidance: use this to obtain screen context before calling ui_dump or screenshot. It does not mention alternative tools for similar foreground/process queries, but the intended workflow 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 for behavioral disclosure. It explicitly warns to install only from reliable sources, states that unknown-origin files trigger server confirmation, and notes the ADMIN prerequisite. These are meaningful behavioral traits beyond the schema, though it does not describe side effects like overwriting an existing app or how reinstall affects data.

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

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

Three short sentences, all substantive: the main verb and object appear first, followed by a critical path clarification, then safety and prerequisite notes. No filler or redundancy.

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

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

For a 3-parameter mutable operation with no annotations and 0% schema coverage, the description covers the most important parameter and safety preconditions, but omits explanations for serial and reinstall and does not mention what constitutes a successful install. Since an output schema exists, return values need not be described, but the parameter gaps make the definition only partially complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does meaningfully clarify local_path as a host-side path, which is the key ambiguity. However, serial and reinstall are left unexplained; their semantics must be inferred from names/types, and reinstall's behavior (e.g., replace vs. update, data preservation) is not described.

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

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

The description states a clear verb+resource: 'APK telepitese' (install APK) from computer to device via adb install. This unambiguously distinguishes it from sibling app-management tools like launch_app, stop_app, uninstall_app, and clear_app_data, none of which handle installation.

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 provides useful context by clarifying that local_path refers to a file on the computer, not the device, and by noting that ADMIN mode is required. However, it does not explicitly name alternatives or state conditions when not to use this tool, though no sibling appears to duplicate the install capability.

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 must carry behavioral disclosure. It does reveal an important implementation detail—the use of the monkey tool and default activity fallback—but it omits side effects, return behavior, failure conditions, or permission requirements.

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

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

The description is two concise sentences with no filler. The first sentence states the primary purpose, and the second adds essential behavioral detail about the fallback mechanism. Every sentence earns its place.

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

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

For a simple launch tool, the description covers the main launch behavior and the activity fallback adequately. However, the serial parameter is undocumented, the tool does not describe success/failure signaling, and there are no annotations to fill in safety or side-effect context.

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

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

Schema description coverage is 0%, so the description needs to compensate. It explains the package parameter with an example and clarifies the activity parameter's default behavior, but it does not explain the serial parameter at all, leaving a meaningful gap.

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

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

The description clearly states the tool launches an app by package name, with a concrete example ('com.android.settings'). It communicates the core action and resource, though it does not explicitly contrast itself with sibling tools like open_app_and_wait or foreground_app.

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 useful conditional guidance: if activity is not supplied, the launcher activity is started via monkey, described as the most reliable way to launch an app by package name alone. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It goes beyond the schema by disclosing the default filtering behavior (only_third_party=True shows only user-installed apps) and the rationale of avoiding an overwhelmingly large system list. It does not cover every edge case, but for a read-only listing operation this is reasonably transparent.

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

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

The description is two short sentences with the primary purpose front-loaded and the parameter behavior explained second. Every sentence earns its place; the rationale about avoiding a 300+ line system list is useful and not 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?

Given the low complexity of the tool – two optional parameters and an output schema present – the description covers the essential behavior: what is listed and how the default filtering works. The only notable gap is the unmentioned serial parameter, but its title and the surrounding sibling tools make it recoverable. Overall, the definition is complete enough for correct invocation.

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

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

With 0% schema description coverage, the description must compensate for undocumented parameters. It explains only_third_party's default and effect in detail, but the serial parameter is not described in prose, though its name and title make its purpose inferable. This partial coverage is adequate but not complete.

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 'Telepitett alkalmazasok csomagneveinek listaja' – a list of package names of installed applications – which clearly identifies the verb (list) and resource (installed apps' package names). This distinguishes it from siblings like app_info or launch_app, which concern individual app details or actions.

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 that only_third_party defaults to True and therefore returns only user-installed apps rather than a 300+ line system list, giving concrete context for when the default setting is appropriate. It does not explicitly name alternatives or exclusions, but the usage context is clear enough for an agent to decide when a simple app list is needed.

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?

Annotations are none, so the description carries the full burden. The description only states a listing action; it does not disclose how results are returned, whether the operation is read-only, what happens for invalid paths, or whether permissions are needed. No behavioral detail beyond the basic action is provided.

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

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

The description is a single short sentence, so it is concise. However, it is one of those cases where under-specification is not true conciseness: it communicates almost nothing beyond the bare action. It is not wasted, but it is minimal.

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

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

The tool is a simple listing operation with no annotations and no schema descriptions. The description is extremely thin, but the presence of an output schema and two simple parameters means the agent can infer some behavior from the schema. What is missing is guidance on serial semantics, path handling, and result interpretation.

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

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

Schema description coverage is 0% and there is no textual explanation of the parameters. The schema shows serial and remote_path with defaults, but the description gives no semantic guidance about what serial means or how remote_path should be formatted. The parameter list itself is short, so a 2 is appropriate rather than 1, but the description compensates very little for the schema's lack of documentation.

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

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

The description is in Hungarian and states that it lists files/directories on the device at a given path. It has a clear verb and resource but doesn't distinguish itself from file-related siblings like file_info, read_file, or make_dir.

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

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

No when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives or prerequisites such as whether the path must exist or whether hidden files are included. With zero annotations, there is no usage context at all.

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 disclosure burden. It reveals the underlying 'dumpsys notification' mechanism and notes it is a summary, but it does not explain whether the operation is read-only, requires permissions, or has any side effects on the device or notification state.

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

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

The description is a single focused sentence with no filler, and it front-loads the core purpose. It is appropriately concise, though it sacrifices needed detail about usage and the serial parameter.

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

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

The tool is simple and has an output schema, but the description is incomplete for correct invocation: it lacks parameter guidance, usage alternatives, and behavioral safety context. An agent cannot fully determine when or how to use the optional serial 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?

The schema has zero description coverage and the only parameter, 'serial', is not mentioned or explained in the description. Since the description must compensate for the lack of schema documentation, the complete absence of parameter semantics is a severe gap.

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

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

The description clearly states the tool summarizes currently active notifications on the device and even identifies the underlying source as 'dumpsys notification'. It is specific about the resource and scope, though it does not explicitly differentiate itself from sibling tools like open_notification_panel.

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

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

There is no guidance on when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The phrase 'currently active notifications' only implies a narrow use case, leaving the agent to infer when this should be called.

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

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

With no annotations, the description carries the full burden. It discloses the snapshot behavior (last N lines) and the filter semantics with an example, but it does not explicitly state that it is a read-only operation, note any prerequisites like a connected device, or clarify whether it follows the log stream or returns once. These are meaningful gaps for an annotation-free tool.

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

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

Two sentences, front-loaded with the core purpose, and the second sentence adds a practical filter example. No wasted words; the structure is easy to parse and directly useful.

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

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

The tool is simple and the output schema exists, so the description does not need to explain return values. However, with 0% schema coverage, the missing semantics for lines and serial make the definition incomplete. It is adequate for an agent that already knows Android terminology, but has clear documentation gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains filter_tag well with a concrete syntax example, but lines and serial receive no explanation. The agent is left guessing what 'serial' means and how lines behaves beyond its default, which is a significant gap for a 3-parameter tool.

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

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

The description clearly states the operation ('az utolso N sor a rendszernaplobol') and the resource (logcat), and adds the debugging context. It is unambiguous, though it does not explicitly differentiate from siblings, likely because no sibling tool does the same thing.

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

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

The phrase 'hibakereseshez' (for debugging) gives a clear use context, and the filter_tag explanation with a concrete example tells the agent how to narrow results. It does not mention alternatives or exclusions, but there are no evident log-reading siblings, so the context is sufficient.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic gesture and a use case, omitting details such as how duration_ms affects the press, whether it triggers side effects like menus, or whether it blocks/wait for UI changes. This is insufficient for an unannotated tool.

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

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

A single sentence that front-loads the core action ('long press on (x,y)') and appends a brief use case. There is no redundant or filler text; every word contributes to understanding.

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

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

The tool has four parameters including optional duration_ms and serial, yet the description covers only the coordinates and the basic use case. With no annotations and an output schema that is not referenced, the description is adequate only for a minimal default invocation, but incomplete for an agent needing to handle device selection, timing, or expected outcomes.

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

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

Schema description coverage is 0%, and the description only references the x and y coordinates. It adds no meaning for duration_ms (e.g., that it controls press duration) or serial (e.g., which device to target), so the agent cannot infer the semantics of half the parameters from the description.

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

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

The description clearly states a specific action (long press) on a specific resource (coordinate x,y) and gives a concrete purpose (context menu or element selection). This distinguishes it from sibling tools like tap, double_tap, and swipe, though it does not explicitly name alternatives.

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

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

The description implies when to use the tool: when a context menu or element selection is needed. However, it provides no explicit guidance on when NOT to use it or how it compares to sibling gesture tools such as tap or double_tap, leaving the decision largely to inference.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether the directory must not already exist, whether parent directories are created, whether permissions are needed, or what happens on failure. This is a mutation tool with no side-effect or error information.

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

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

The description is one short, front-loaded sentence with no filler or redundancy. However, its brevity comes from under-specification rather than efficient coverage of the tool's important 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?

Given no annotations and an output schema that is not provided, the description is too minimal to allow correct invocation. It lacks essential context about error handling, existing-directory behavior, recursive creation, and the role of serial, making it incomplete for a real-world 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 description coverage is 0%, and the description adds only minimal meaning by implying that remote_path is the directory to create. The optional serial parameter is completely unexplained, and there is no detail about path format, required permissions, or default 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 clearly states a specific action ('create') on a specific resource ('directory') on the device, matching the tool name make_dir. It is distinguishable from siblings like list_files, delete_path, and move_path, though it does not explicitly differentiate itself from any 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?

There is no guidance on when to use this tool versus alternatives. The description only states what the tool does, not when it should be preferred over other file-system tools such as push_file or move_path.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. It only states that the operation is local and not a computer transfer; it omits overwrite semantics, behavior when destination exists, directory recursion, permissions, or reversibility. For a mutating filesystem operation, this is a significant transparency gap.

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

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

The description is a single front-loaded sentence that communicates the core operation and the key scope qualifier without any wasted words.

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 mutation tool, the description is too sparse: it lacks critical edge-case behavior such as overwrite handling, directory recursion, or failure modes, and since no annotations exist, an agent has no safety or behavioral baseline. The output schema exists but the description does not reference expected results, leaving the definition incomplete for reliable 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?

Input schema description coverage is 0%, and the description adds no explanation of source, destination, or serial formats. The parameter names 'source' and 'destination' are self-evident, but the description does not confirm expected path conventions, whether destination can be a directory, or the role of the optional serial parameter, so semantics remain under-specified.

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

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

The Hungarian description states a specific action — moving or renaming a file/directory on the device — and explicitly excludes transfer to a computer, distinguishing it from file-transfer siblings like pull_file and push_file.

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

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

The parenthetical '(helyben, nem a gepre)' clarifies that this tool is for on-device operations rather than transferring files to/from a PC, which gives the agent a clear context signal for when to use it over pull_file/push_file. However, it does not explicitly name alternatives or specify when rename versus move is intended, leaving some inference required.

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 behavioral disclosure burden. It adds useful context by noting that the Wi-Fi SSID is included only if queryable, and it specifies the other reported values. It does not explicitly state that the operation is read-only, nor does it describe behavior when network information is unavailable or errors occur.

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

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

The description is a single focused sentence that leads with the resource name and immediately lists the returned fields. There is no filler, repetition, or unnecessary detail.

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

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

The description adequately summarizes the returned network information for a simple status tool, and an output schema exists. However, the undocumented serial parameter and lack of usage guidance prevent the definition from being fully self-sufficient for correct invocation.

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

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

The single optional 'serial' parameter has 0% schema description coverage, and the description never mentions it. An agent receives no explanation of what 'serial' refers to, when to provide it, or how it affects the result.

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

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

The description identifies a specific resource (network status) and enumerates the concrete returned fields: Wi-Fi SSID, IP address, and mobile data state. This makes the tool's purpose clear and distinguishes it from generic status tools like battery_status, though it lacks an explicit verb such as 'gets' or 'returns'.

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

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

The intended use is implied by the name and the listed network-related fields, so an agent can infer when to call it. However, it does not explicitly state when to use this tool versus alternatives like device_info, nor does it mention any exclusions or prerequisites.

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 explains the main behavioral traits: the response is textual, screenshot inclusion is controlled by include_screenshot, and when enabled the screenshot is delivered as a separate message. It does not explicitly state that the operation is read-only or describe failure modes, but the observe semantics and returned-state detail are reasonably transparent.

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

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

The description is compact and front-loaded, with the core 'one call collects screen state' statement first. Each of the four sentences adds useful information, though bullet points would improve 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 tool with no output schema and no annotations, the description explains the returned payload and screenshot behavior well. However, it omits the role of serial and does not mention device prerequisites or error behavior, leaving some operational context unresolved.

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?

Parameter schema coverage is 0%, so the description must compensate. It explains include_screenshot and its behavior, but the serial parameter is never mentioned or semantically defined, leaving a significant gap for how the agent targets a device.

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

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

The description clearly states that the tool collects the current screen state in one call, listing the exact returned data: foreground app/activity, screen size and orientation, and key clickable/editable UI elements. It also distinguishes itself from siblings by naming foreground_app, ui_dump, and screen_state as the tools it replaces.

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 usage context: use this composite tool before steps to avoid multiple separate calls, and names the sibling tools it consolidates. It does not explicitly state when not to use it or when a specialized tool would be better, so it stops short of a full 5.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses that OCR requires an optional Python dependency and a system-level Tesseract installation, and that the tool fails gracefully with installation guidance instead of crashing. This is valuable beyond the basic function, though it does not cover all edge-case 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 compact, front-loaded with the purpose and fallback condition before dependencies and parameter details. Every sentence adds information, though the dependency install instructions make it slightly longer than strictly necessary.

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?

It covers purpose, fallback condition, dependencies, failure mode, and the lang parameter, and an output schema exists so return format need not be described. However, the serial parameter remains unexplained, which is a real gap for a tool with only two parameters and no schema descriptions.

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

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

Schema description coverage is 0%, so the description must document parameters. It explains lang well (Tesseract language code, multi-language via 'eng+hun'), but it does not mention the serial parameter at all, leaving half the parameters undocumented.

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

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

The description names a specific verb and resource ('OCR-based text recognition on the screen') and immediately distinguishes it from ui_dump by positioning it as the fallback for empty UI dumps in games, WebView, Canvas, and custom-drawn UI. This makes its role clear among the sibling tools.

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

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

It explicitly states when to use this tool: when ui_dump returns an empty list, with concrete scenarios. The word 'fallback' plus the named ui_dump alternative gives the agent a clear selection rule.

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 disclosure burden. It does disclose the key behavior: it starts the app and waits until the app is truly in the foreground, and it frames the tool as a compound of launch and check operations. However, it does not explain what happens on timeout or failure, despite exposing a timeout_seconds parameter.

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 action, and every sentence adds value: the first states what it does, the second clarifies why it exists and when it is useful. There is no filler or redundant restatement of the tool name.

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

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

The description clearly conveys the core purpose and differentiates the tool from siblings, but it leaves important gaps: no parameter guidance, no timeout/failure behavior, and no context on what the output means. The presence of an output schema reduces some burden, but the missing behavioral and parameter detail is significant for a state-changing tool with no annotations.

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

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

Schema description coverage is 0% and the description adds no parameter-level meaning. The role of 'timeout_seconds' is especially relevant to the described waiting behavior but is not mentioned, and 'serial' is left entirely to its name and default.

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

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

The description uses a specific verb (inditasa), a specific resource (app), and a clear expected outcome (waiting until it actually reaches the foreground). It explicitly contrasts itself with 'launch_app' and 'foreground_app', making it easy to distinguish from sibling tools.

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

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

The description names the alternatives ('launch_app' + repeated 'foreground_app' checks) and gives a concrete use case: use this when you need certainty the app launched before proceeding. It does not explicitly state when to prefer the simpler alternatives or when this combined approach should be avoided, so it stops short of full when/when-not guidance.

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

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

The core behavior—pulling down the notification/quick-settings panel from the top of the screen—is stated, which is useful because no annotations are provided. However, side effects, toggle behavior, and any device/UI-state requirements are not 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?

The description is a single, front-loaded sentence with no filler or repetition. It is appropriately sized for a simple one-parameter UI action, even though it lacks parameter and usage detail.

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

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

For a simple one-parameter action with an output schema, the description covers the main action but omits serial-parameter context and any guidance on when the action can be performed. It is minimally viable rather than fully complete.

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

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

The single 'serial' parameter is not mentioned in the description, and the schema provides only the parameter name and a null default with no description. Since schema description coverage is 0%, the description should have compensated for this gap but did not.

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 identifies the action ('lehuzasa' = pulling down) and the resource ('ertesitesi/gyorsbeallitasok panel' = notifications/quick-settings panel). It is specific enough to distinguish the tool from list_notifications or generic swipe, though it does not explicitly name sibling tools.

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

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

The description states only what the tool does, not when to use it versus alternatives such as list_notifications or a manual swipe. There are no prerequisites, exclusions, or conditions such as screen state or whether the device must be unlocked.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses one meaningful trait — Android selects the handling app via intent, so the tool has no control over which app opens — which is genuinely useful context. However, it doesn't disclose side effects like launching an external app that takes over the screen, failure modes when no app handles the URL, or whether the call blocks or returns immediately.

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

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

The description is one front-loaded sentence plus a single clarifying clause about intent-based routing, with no wasted words. Its compact size is appropriate for a simple tool, aside from the minor stylistic inconsistency of a Hungarian sentence attached to an English tool name.

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

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

For a 2-parameter, no-annotation tool with 0% schema coverage, the description covers the core action and the app-routing behavior, and the presence of an output schema relieves it of explaining return values. But it leaves the serial parameter undocumented, omits failure handling, and doesn't warn that opening a URL will switch the device to an external app. It is minimally viable with clear gaps.

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

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

Schema description coverage is 0%, so the description must define the parameters itself. It implicitly conveys what 'url' means (the URL to open) through the tool's overall statement, but it never explicitly names the parameter. The 'serial' parameter (likely a device identifier given sibling device_list/device_info tools) is entirely unexplained, leaving a required-in-context semantic gap.

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

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

The description states a clear action — opening a URL in the default application (browser, map, YouTube) — which is a specific verb+resource combination. It goes beyond the tool name by clarifying that Android resolves the handler app via intent. It is clearly distinct from all listed siblings, none of which open URLs, though the Hungarian phrasing with an English tool name is a minor presentation inconsistency.

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

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

No guidance is given about when to use this tool versus alternatives, and no sibling tools are referenced. The only context is that Android decides which app handles the intent, which describes behavior rather than usage conditions, exclusions, or selection criteria. This is effectively no usage 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 behavioral disclosure burden. It reveals the underlying clipboard command, clarifies this tool copies rather than pastes, and explains how type_text routes non-ASCII text automatically. It could mention side effects or failure modes, but for a clipboard-copy operation this is reasonably transparent.

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

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

The description is concise and front-loaded with the core purpose, then provides relevant usage guidance in two short follow-up sentences. Every sentence adds useful information without filler.

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

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

For a simple clipboard tool, the description covers purpose, usage timing, and the key alternative sibling. The main gap is the unexplained 'serial' parameter, but since it is optional and an output schema exists, the description is otherwise sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly explains the 'text' parameter by stating the tool copies text, but the optional 'serial' parameter is never mentioned or explained. With one parameter semantically opaque, the description only partially compensates for the missing 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 clearly states the tool copies text to the device clipboard and even names the underlying command ('cmd clipboard set-primary-clip'). It also distinguishes itself from type_text by explaining when each is appropriate.

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

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

It explicitly says to prefer type_text for accented/unicode text and to use this tool when you only want to copy without immediately pasting, or when you need to paste the same text multiple times. This is clear, actionable usage 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?

Without annotations, the description carries more burden and does provide useful behavior: it discloses that any KEYCODE_* name works and that the format is checked before the shell command is built. However, it does not mention potential side effects such as power toggling the screen, volume changes, or what happens on invalid input beyond validation. Behavioral disclosure is partial.

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

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

The purpose is front-loaded in a single sentence followed by a compact list of accepted keys. Every sentence carries useful information, but the long enumeration could benefit from clearer grouping or bullet formatting.

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

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

An output schema exists, so return values do not need to be described. The description is complete enough for the required key parameter and its validation, but it omits explanation of the serial parameter and when to prefer press_key over text/touch input tools. For a simple action tool, this is mostly adequate but not fully self-contained.

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

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

Schema description coverage is 0%, so the description must compensate. It strongly documents the required 'key' parameter by listing valid shortcut names and the KEYCODE_* pattern, adding meaning beyond the bare string schema. The optional 'serial' parameter is never mentioned, which leaves multi-device targeting underspecified.

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 action: pressing hardware/system keys. The description then enumerates the exact accepted key names, making the tool's resource and scope clear. It is distinguishable from sibling touch/text tools like tap and type_text by the 'hardware/system key' framing.

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

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

There is no explicit guidance on when to use press_key versus siblings such as tap, type_text, or paste_clipboard. The description does not state exclusions, prerequisites, or device-targeting context. The only hint of usage is the implicit key 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 behavioral disclosure burden. It adds a useful safety detail: adb pull receives arguments directly (not as a shell string) so there is no shell-injection surface, and only the local target folder's existence is checked. However, it does not mention overwrite behavior, error handling, or required permissions.

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

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

Three concise sentences, each serving a distinct purpose: core action, use-case scenario, and safety note. The key action is front-loaded and there is no redundant wording.

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

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

The tool is simple and has an output schema, but lacks annotations. The description adequately covers purpose and a key safety aspect, yet leaves gaps around serial semantics and error conditions. It is sufficient for basic use but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly clarifies remote_path as the device path and local_path as the computer path, and references the local folder existence check. It does not explain the optional serial parameter, which is relevant when multiple devices are connected.

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: downloading a file from the device to the computer via adb pull. It gives concrete examples (photos, WhatsApp media, logs) and distinguishes itself from push_file by directionality.

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 a clear context for when to use the tool, such as retrieving files from a device with a broken screen that was previously authorized. It does not explicitly name alternatives or exclusions, but the use case is concrete enough for an agent to infer applicability.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It reveals the underlying `adb push` mechanism but omits important side effects for a write operation, such as whether existing remote files are overwritten, whether directories are created implicitly, or what permissions are required.

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

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

The description is a single efficient sentence with no filler and the core technical alias (`adb push`) front-loaded. It earns its place, though its brevity leaves room for more behavioral detail without becoming bloated.

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 mutating file-transfer tool with no annotations and undocumented parameters, this is insufficient for safe invocation. It does not mention serial selection, overwrite behavior, failure modes, or prerequisites, and although an output schema exists, the operational context is still too thin.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It adds the high-level local-to-remote direction, which clarifies `local_path` and `remote_path`, but it says nothing about the optional `serial` parameter, path formatting, or expected input formats beyond the parameter names.

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 ('feltoltese' – upload), a resource (file from the computer to the device), and explicitly maps to `adb push`. This unambiguously identifies the operation and distinguishes it from siblings like `pull_file` without needing to inspect 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 phrase 'from the computer to the device' clearly implies the upload direction, which helps differentiate it from `pull_file`. However, there is no explicit guidance on prerequisites, exclusions, or when alternatives such as `install_apk` or `make_dir` would be more appropriate.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does disclose a text-only scope and the binary-file alternative, which is useful. However, it does not explain the effect of max_bytes, encoding, truncation, or failure behavior for a read operation.

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

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

Two short sentences, with the core purpose front-loaded and the binary-file exclusion immediately after. Every clause earns its place, 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?

The output schema covers return format, so that is not a gap. The description gives the core selection and invocation guidance, but omits parameter-level behavior such as what max_bytes does and what happens with large files. This makes it adequate for the common text-file case but not fully complete.

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

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

Schema description coverage is 0%, so the description needed to compensate for parameter explanations. It only implies that remote_path is a text file path; serial and max_bytes are not explained at all, and the meaning of max_bytes default is left entirely to inference.

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

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

The description uses a specific verb ('read') and resource ('text file content from the device'), with concrete examples like logs and config files. It also explicitly distinguishes itself from pull_file for binary files, making sibling differentiation clear.

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

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

The description states 'only use for plain text files' and explicitly directs binary files to pull_file. This is an explicit when-to-use/when-not-to-use rule with a named 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 provided, the description carries the full burden of behavioral disclosure. It reveals that bootloader/recovery modes are risky, may require physical buttons or flashing to return to normal use, and prompt for stronger confirmation. This goes beyond basic schema info and genuinely informs the agent of consequences.

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, front-loaded with the action, and every sentence adds meaningful information. The risk warning is placed after the core definition and is not redundant with the 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 reboot tool with two parameters, the description handles the main 'mode' parameter thoroughly and output schema exists to cover return values. However, the complete absence of any explanation of the 'serial' parameter leaves a gap for an agent trying to target a specific device.

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

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

The input schema has 0% coverage, so the description is the only source of parameter meaning. It explains the 'mode' values and their risk implications well, but it says nothing about the 'serial' parameter, leaving its purpose and usage undocumented.

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

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

The description states a clear action ('device restart') and enumerates the supported modes, so an agent knows this is the reboot tool. It does not explicitly differentiate from siblings, but no other sibling performs a device reboot, so the lack of differentiation is not a practical problem.

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 concrete usage context by explaining the three modes and explicitly warns that bootloader/recovery modes are higher risk and require stronger confirmation. It does not mention exclusions or alternative tools, but none are obviously relevant for a reboot operation.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose the non-obvious scope that only running or recently stopped sessions are included, which is useful. However, it does not clarify what 'recently stopped' means, whether the call has side effects, or how results are ordered.

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

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

The description is one short sentence that front-loads the resource and its filtering condition. Every word earns its place, with no redundancy or filler.

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

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

For a zero-argument listing tool with an output schema present, the description is largely complete: it names the resource and the session-state filter. It could be slightly more complete by defining the recency window or noting that this is a read-only operation, but these are minor gaps given the tool's simplicity.

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

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

The tool has zero parameters, so there are no parameter semantics for the description to add. The baseline of 4 applies because there is nothing for either the schema or description to document.

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 identifies the resource as Rescue sessions and indicates a listing action via 'listája' (list), with a useful state filter: currently running or recently stopped. It distinguishes itself from generic siblings like running_processes by focusing specifically on Rescue sessions, though it does not explicitly name any sibling.

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

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

No guidance is given about when to use this tool versus alternatives such as rescue_probe, rescue_scrcpy_status, or running_processes. The state filter implies a use case, but there are no explicit conditions, exclusions, or recommendations.

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

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

No annotations are present, so the description carries the full burden. It usefully discloses that the recommendation is based on actually known data and is in human language, and the term diagnostics implies non-destructive behavior. However, it does not explicitly state whether the tool is read-only, what side effects it may have, or what happens 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?

The description is compact and front-loaded: the first sentence summarizes the tool, and the second clarifies the relationship to device_capabilities and the added recommendation. Every sentence contributes useful information with 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?

The description gives a clear purpose, names a relevant alternative, and the presence of an output schema covers return-value structure. However, with no annotations and no parameter explanations, the agent still lacks guidance on how to supply serial or hints and when exactly to prefer this tool over device_capabilities, leaving the definition only minimally complete.

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

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

The schema has 0% description coverage and the description does not explain serial, model_hint, or manufacturer_hint at all. Their names and defaults hint at their roles, but the description provides no guidance on how they affect the diagnostic report or recommendation, which is a significant gap for an invocation-focused tool.

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 rescue_probe performs full recovery diagnostics plus a human-language recommendation, and it explicitly says it produces the same report as device_capabilities with an added concrete next-step suggestion. This distinguishes it from a named sibling tool and makes its purpose immediately understandable.

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 names device_capabilities as the alternative and clarifies the deciding factor: choose rescue_probe when a recommendation is needed in addition to the standard capability report. It does not explicitly state when not to use it or mention prerequisites, but the comparison provides clear contextual 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 provided, the description carries the burden of behavioral disclosure. It states that the tool reports availability and version, which implies a read-only status check rather than a mutation. However, it does not explain how the scrcpy_path parameter affects behavior or what happens when the binary is missing.

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

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

The description is a single compact sentence with no filler. It front-loads the core purpose and adds a parenthetical with the two key output aspects, so every word earns its place.

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

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

The tool is simple and has an output schema, so return-value details are less necessary. However, the complete absence of parameter guidance and usage context leaves an agent uncertain about how to invoke the tool correctly, especially when deciding whether to supply scrcpy_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?

The schema has 0% description coverage for its only parameter, and the description makes no mention of scrcpy_path. The parameter name gives some clue, but the tool description does not explain whether this path is required, optional, or how it is used relative to the default system search.

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 identifies the resource (the official scrcpy binary on this machine) and the information returned (whether it exists and its version). It is not a tautology and is distinct in scope from sibling rescue commands, though it lacks an explicit action verb.

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

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

The description gives no guidance on when to use this tool versus alternatives, such as rescue_probe or the mirror/OTG start tools. There is no mention of prerequisites or conditions that should trigger this status check.

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 disclosure burden and does a good job: read_only guarantees no input forwarding or clipboard sync and names the enforcing flags; print_fps is explicitly defined as reporting the actual stream frame rate to stderr/stdout. It does not disclose the default control/clipboard behavior or that this starts a long-running session, 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?

The description is front-loaded with the core function and then organizes parameter-specific behavior into readable blocks. The repeated emphasis on 'official scrcpy' is slightly redundant, but every sentence contributes useful detail.

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

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

For a session-starting tool with four parameters and no annotations, the description covers the two boolean parameters well but leaves profile semantics and serial selection unexplained. It also doesn't mention how the started session is stopped or observed, though sibling tools hint at that workflow.

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

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

Schema description coverage is 0%, so the description must compensate, and it richly documents read_only and print_fps. However, it only lists profile's allowed values without explaining their tradeoffs, and serial is not described at all.

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

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

The description clearly states it starts full-screen mirroring and control in the official scrcpy window, and the read_only mode clarifies a view-only variant. It does not explicitly distinguish itself from sibling tools such as rescue_start_otg or observe_screen, so it stops short of a 5.

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

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

It gives a concrete use case for read_only=True ('if you only want to view the screen without risking accidental input') and notes the ADB/authorized-device prerequisite. It does not state when to prefer this over alternative monitoring tools or when not to use it, but the provided 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 provided, the description carries the full disclosure burden and does it well: no image/sound, forwards the caller's physical USB keyboard/mouse, requires visible screen, and explicitly disclaims automatic guessing. It does not cover session lifecycle or failure modes, but the most important behavioral traits are transparent.

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

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

The description is moderately sized and front-loaded: purpose first, then a clearly labeled limitation, then a concrete use case. Every sentence adds value, though the scenario explanation could be tightened; it remains readable and well structured.

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

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

For a single-optional-param start command with an output schema, the description covers purpose, constraints, and the exact human-in-the-loop scenario. It does not mention prerequisites (USB/AOA support) or how the session is stopped, but these are secondary and partially inferable from the rescue_* sibling group.

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

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

The only parameter, serial_hint, is never mentioned in the description, and the schema provides no description for it beyond the name and a null default. With 0% schema description coverage, the description was expected to compensate but does not; the agent must guess that serial_hint selects the target device.

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

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

Description opens with a specific verb and object: starting AOA-based keyboard/mouse control without ADB ('scrcpy --otg'). It also differentiates itself from sibling rescue_start_mirror by explicitly stating there is no image and no sound, so the mode's scope 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?

It clearly defines when this mode is appropriate: when the phone screen is still visible but touch/fingerprint is dead, and the owner can enter PIN/pattern with physical input. It also states a limitation ('no image/sound') that implicitly steers away from using this when mirroring is needed, though it does not explicitly name alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It communicates that this stops a session, but it does not disclose side effects, whether the action is irreversible, what happens to the mirror/OTG connection, or whether any prerequisites apply.

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

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

The description is a single short sentence with no filler. It front-loads the object ('Rescue session') and immediately states the action and parameter role.

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

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

For a simple one-parameter operations tool, the description covers the core purpose and the role of PID. However, with no annotations and no mention of how to discover the PID or what consequences stopping has, an agent is left to infer several important details.

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

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

Schema description coverage is 0%, so the description must compensate. It adds some meaning by clarifying that 'pid' identifies the running Rescue session to stop, rather than a generic process ID. However, it does not explain where to obtain the PID or how session PIDs relate to the output of rescue_list_sessions.

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 ('leállítása' = stop), a specific resource ('futó Rescue munkamenet' = running Rescue session), and the method ('PID alapján' = based on PID). It clearly distinguishes this from sibling start/list/status tools.

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

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

The description implies when to use the tool: when a running Rescue mirroring or OTG session must be stopped by PID. However, it does not explicitly mention alternatives or prerequisites, such as obtaining the PID from rescue_list_sessions or that this is the inverse of rescue_start_mirror/rescue_start_otg.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only reveals that the output is an abbreviated form of ps -A, hinting at filtered output, but says nothing about read-only safety, required permissions, side effects, or what fields are omitted. The single behavioral clue is weak given the complete absence of annotation support.

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

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

The description is a single ~12-word sentence that front-loads the core fact ('list of running processes') and wastes no words. The parenthetical 'ps -A abbreviated' adds useful grounding without bloat. It is efficient, though it also conveys very little information overall.

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 list-type tool with an output schema present, the core purpose is adequately covered — an agent knows what the tool returns at a high level. However, the unexplained 'serial' parameter, the undefined scope of 'abbreviated', and the total absence of annotations leave meaningful gaps in what an agent needs to invoke it confidently. It is minimally viable but not complete.

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

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

The single parameter 'serial' has 0% schema description coverage and is not mentioned anywhere in the description. An agent must infer from the parameter name and device context that it likely selects the target device by serial number. The description does nothing to compensate for the schema gap, though the parameter is optional with a null default, which slightly mitigates the risk.

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, Hungarian for 'List of currently running processes on the device (ps -A abbreviated)', states a specific verb and resource: it lists processes, not apps or device info, which implicitly differentiates it from siblings like list_apps and device_info. The concrete 'ps -A' anchor makes the scope unambiguous. It loses a point only for not explicitly contrasting with sibling tools.

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

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

No guidance is given on when to use this tool versus alternatives such as list_apps, app_info, or foreground_app. There are no exclusions, prerequisites, or conditions stated. The description is purely definitional and leaves all routing decisions to the agent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether this changes the device orientation, what side effects occur, whether the change persists, how the serial parameter affects behavior, or what response is returned.

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

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

The description is extremely short and front-loaded with the key values, so it is concise. However, it is under-specified: it lacks an explicit operation, parameter explanations, and any usage context, making it less usable than its brevity might suggest.

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?

While the tool is simple and has an output schema, the description remains incomplete for safe invocation. It does not explain the serial parameter, when to use this tool, or what effect the rotation setting has on the device, leaving important gaps in an otherwise minimal description.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It adds useful allowed values for rotation ('auto', 'portrait', 'landscape', 'landscape_reverse'), but it entirely omits any meaning for the 'serial' parameter, which is especially relevant for a device-oriented tool.

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 the resource (screen orientation) and the allowed modes, which makes the tool's purpose reasonably clear for an agent. However, it uses a Hungarian noun phrase rather than an explicit verb like 'set', and it does not differentiate itself from siblings beyond the tool name.

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

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

There is no guidance about when to use this tool versus alternatives, no mention of conditions or prerequisites, and no indication of how it relates to tools like screen_state or set_mode. The description only lists possible values, leaving usage context entirely to inference.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It does so by stating the 30-second cap, MP4 format, temporary device storage, and subsequent download-and-delete lifecycle. It omits permissions and error behavior, but the main side effects are covered.

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

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

The description is compact: two sentences, with the core purpose front-loaded and the use cases and lifecycle details after. There is no redundant wording, though a slightly more structured format could improve 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?

The description is minimally complete for a simple tool: it conveys what is recorded, the format, duration limit, and storage lifecycle. However, it leaves parameter semantics and the tool's return/output behavior undefined, which matters because there is no output 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 0%, and the description does not explain the 'serial' or 'seconds' parameters. The 'max 30 mp' hint weakly implies that 'seconds' controls duration, but 'serial' is never clarified, so the description fails to compensate for the absent 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 clearly states the action: creating a short screen recording (max 30 seconds) in MP4 format. It distinguishes video capture from static screenshot tools, though it does not explicitly name a sibling 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?

It explicitly says the tool is useful for animations, transitions, and gameplay replay, giving an agent context for when video recording is appropriate. It does not, however, mention when not to use it or name an alternative tool directly.

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 behavioral disclosure burden. It clearly communicates that the tool captures the current screen and returns a PNG, and explains the model's visual access to the screen. It does not discuss side effects or permissions, but screenshot is inherently a read-only operation and the description is sufficiently transparent for this 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 compact and front-loaded, with the first sentence stating the operation and output format and the second adding relevant use-case context. Every sentence earns its place and there is no redundant 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 simple, side-effect-free tool, the description covers the action, the output format, and the main use case. The only notable gap is the undocumented serial parameter, which is optional, so the description is still mostly complete but not fully self-sufficient for multi-device scenarios.

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

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

The input schema has one parameter, serial, with 0% schema description coverage, and the description does not mention serial at all. This leaves the agent without any explanation of whether serial selects a specific device, what values are valid, or what happens when it is null. The description fails to compensate for the schema's lack of parameter documentation.

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

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

The description states a specific action and result: taking a screenshot of the device and returning it as a PNG image. It also explicitly contrasts itself with ui_dump, giving a clear purpose distinction from a key sibling tool.

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

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

The description gives clear context for when to use the tool: when ui_dump is insufficient for visually rendered content such as games, video, custom-drawn UI, or WebView/Canvas. It does not explicitly state when not to use it or mention alternatives like screen_record or ocr_screen, so it narrowly misses a 5.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly discloses that the tool is purely informational, only shows the current state, and does not attempt to circumvent locks, which addresses the main risk for a screen-state query. It does not discuss permissions or side effects, but for a read-only state query this is reasonably transparent.

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

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

The description is two short sentences with no filler. It front-loads the core state information and then adds a concise, important caveat about not being a lock-bypass tool.

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

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

An output schema exists, so return values do not need to be described. The main gap is that the optional serial parameter is undocumented in both the schema and the description, and there is no guidance on when to pass it; otherwise the tool is a simple read-only query.

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

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

The schema has 0% description coverage and the only parameter, serial, is never mentioned in the description. The agent is left to infer what serial means or whether omitting it targets a default/current device, so the description adds no value for parameter understanding.

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 reports the current screen state: on/off and whether it is locked. It identifies the resource ('screen') and frames the operation as an informative query, which distinguishes it from capture tools like screenshot and screen_record, though it does not name those siblings.

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

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

The description explicitly says this is an informative query and is NOT suitable for bypassing a lock, which provides a useful exclusion. However, it does not name any alternative tools or state when screen_state should be preferred over related tools such as ui_dump or screenshot, so the guidance is partial.

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 behavioral disclosure burden. It discloses that the tool scrolls from the center of the screen, uses semantic directions, and is implemented as a wrapper around 'swipe'. This gives the agent an accurate mental model of what will happen, though it does not describe edge cases such as failure behavior or when scrolling may have no effect.

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

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

The description is two concise sentences: the first states the core behavior, and the second positions the tool relative to 'swipe' and 'scroll_to'. Every sentence earns its place with no filler or redundant restating of the tool name.

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

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

For a low-complexity tool, the description covers purpose, behavior, and the main alternative, and an agent can call the tool successfully with just the required 'direction' parameter. However, with no annotations and no parameter descriptions for 'amount' and 'serial', the description is not fully complete for agents that need to customize those values.

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

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

The schema has 0% description coverage, so the description should compensate. It does add meaning for the required 'direction' parameter by listing valid values ('up', 'down', 'left', 'right'), but it says nothing about 'amount' or 'serial'. These remain unexplained, leaving the agent without enough information to intentionally customize them.

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

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

The description states a specific action ('scroll from the middle of the screen') with concrete valid directions ('up', 'down', 'left', 'right'). It also clarifies that this tool is a convenience wrapper around 'swipe' and distinguishes it from 'scroll_to', making its role among siblings clear.

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

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

The description explicitly says this is a convenience wrapper around 'swipe' with semantic directions, implying when to prefer it over a raw swipe. It also directly states that if the goal is to scroll to specific text, the agent should use 'scroll_to' instead, which is a clear when-not-to-use instruction.

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

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

With no annotations, the description carries the burden, and it discloses the key behavior: repeated downward scrolling, stopping when the text appears or when max_swipes is reached. It does not detail exact matching semantics or behavior when text is already visible, but the core side effects are clearly described.

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

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

Two sentences: the first states the behavior, the second states when it is useful. Each sentence adds value and 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?

Given that an output schema exists, return-value documentation is not required here. The description adequately covers the core invocation context and behavior, though a clearer definition of how text matching works and what serial means would make it fully complete.

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

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

Schema property descriptions are 0% covered, and the description adds meaning for text (the searched text) and max_swipes (the iteration limit). However, the optional serial parameter is never explained, so the gap is only partially compensated.

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 action: scroll down until the searched text appears on screen. This distinguishes it from sibling tools like generic scroll or wait_for_text, and the use-case mention reinforces its purpose.

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

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

It clearly says this is useful for long lists or settings pages where the target element is not initially visible. It does not explicitly name alternatives or give when-not-to-use guidance, so it stops short of a 5.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure, and it excels: it reveals the upper-limit ceiling (max_mode), the rule that lowering the mode does not grant later escalation, and concrete scenarios for ADMIN- versus NORMAL-started servers. This is exactly the non-obvious operational constraint an agent must know before calling the 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 purpose and valid values are front-loaded in the first sentence, and the second sentence adds the critical ceiling constraint, so the structure is logical. Each sentence earns its place, though the worked example scenarios are somewhat redundant with the general rule just stated and could be slightly 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?

For a simple one-parameter setter whose only real nuance is the max_mode ceiling, the description covers the essential behavior thoroughly, and an output schema exists to define return values. Minor gaps remain: the error behavior when attempting to exceed max_mode and whether the mode change persists are not addressed, but neither is critical given the constraints already described.

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

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

Schema description coverage is 0%: the schema only declares a required string 'mode' with no enum, allowed values, or description. The description fully compensates by listing the three valid string values and explaining their hierarchical relationship (safe < normal < admin) and their interaction with the max_mode ceiling.

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: changing the server's permission mode at runtime, and enumerates the exact allowed values ('safe', 'normal', 'admin'). This states the tool's function precisely and clearly distinguishes it from the sibling tools, none of which manage server permission modes.

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?