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

There are no annotations, so the description carries the burden of behavioral disclosure. It clarifies what host and token mean and conveys persistence via 'Register', but it does not explain behavior on duplicate names, token validation, or whether the phone must be reachable at registration time.

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 tight sentences: the first states the core purpose, and the second defines the two non-obvious required inputs. There is no filler or repetition.

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

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

For a simple registration tool, the description covers the required inputs, points to discover_phones for context, and an output schema exists. It is slightly incomplete on optional parameter semantics and behavioral edge cases, but not critically so.

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 host and token well, and name is implied by 'driven by name', but port and label are completely unmentioned. With five parameters and no schema descriptions, this is a material 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 uses a specific verb 'Register' with a clear resource and intent: a phone, so it can be driven by name. This distinguishes it from sibling tools like discover_phones or forget_phone.

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: registering a phone for name-based control. It also directs the agent to discover_phones for obtaining the host and to the Android Use app for the token, though it does not explicitly explain when to prefer this over 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 reveals a side effect – connecting over Wi-Fi automatically – which is valuable, but it does not state whether the check is non-destructive or modifies connection state, leaving some uncertainty about side effects.

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

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

The description is two short sentences with no fluff. Purpose and usage trigger are front-loaded, and the Wi-Fi behavior is a necessary caution.

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 diagnostic tool with one optional parameter and no annotations, the description is incomplete: it omits parameter semantics and prerequisites (e.g., whether the device must be known/paired). The output schema covers return values, but the input side is under-specified.

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

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

The single 'device' parameter has zero schema description coverage, and the description does not explain what value to pass (e.g., ID, name, or default behavior). This is a critical gap for a tool with a parameter; the agent must guess how to specify the 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 a specific diagnostic action: checking a phone's reachability and reporting what it is. This distinguishes it from siblings like check_internet (network reachability) and phone_health (device health), so an agent can select it appropriately.

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 explicit usage guidance: 'Call this first if anything seems wrong,' telling the agent when to invoke it as the initial diagnostic step. It does not name alternatives or exclusion criteria, but the directive gives a clear trigger condition.

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 behavioral burden. It clearly states the tool is non-interactive ('without touching the screen') and diagnostic in intent ('diagnose', 'shows whether'), and it describes the measured dimensions. It does not explicitly promise zero side effects, but the diagnostic framing makes this mostly unambiguous.

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

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

Two tight sentences: the first front-loads the action and key constraint, the second adds the usage trigger and expected output dimensions. No filler or repetition.

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

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

For a one-parameter diagnostic with an output schema, the description covers the core call flow and result semantics well. It is slightly incomplete only because the device parameter is unexplained and no alternative tools are referenced, but these are minor given the explicit 'start here' guidance.

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, device, is optional and has zero schema description coverage, and the description never mentions it. With no compensation in prose, an agent gets no help on whether to pass a device id, what the default means, or how the target device is selected.

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

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

Uses a specific verb ('diagnose') with an explicit resource ('the phone's internet connection') and enumerates the checks (radios, traffic, DNS). This clearly distinguishes it from siblings like check_device and phone_health, which target different aspects.

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

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

Explicitly frames the tool as the entry point for 'my internet isn't working', providing a clear trigger condition. It does not name alternative tools or state when not to use it, so it stops short of full routing guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states only the immediate click action and does not mention potential side effects such as navigation, page changes, waiting, or whether the click may trigger destructive actions. For a click 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 sentence with no filler, extraneous detail, or repetition of schema information. The key action and source are front-loaded, making it easy to parse quickly.

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

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

For a tool with no annotations, an output schema, and three parameters, the description is too thin. It lacks parameter guidance for device and tab_id, does not explain when to use this tool over alternatives, and omits behavioral side effects that matter for an agent deciding whether clicking is safe or appropriate.

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

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

Schema description coverage is 0%, so the description must compensate for all parameters. It clarifies that 'index' is the element number from chrome_read, but it gives no meaning for 'device' or 'tab_id', leaving two of three parameters unexplained and relying on the agent to infer their purpose.

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 ('Click an element') and the resource ('by its number from chrome_read'), making the tool's purpose immediately understandable. It implicitly distinguishes itself from generic tap tools by tying clicks to numbered elements from chrome_read, but it does not explicitly name sibling 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 phrase 'from chrome_read' implies a precondition: the agent must first call chrome_read to obtain numbered elements. However, it gives no explicit guidance about when to choose this tool over siblings like tap, tap_coordinates, or tap_text, and provides no 'when not to use' conditions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action; it does not mention that closing is irreversible, what happens if the tab id is invalid, whether an active Chrome session is required, or what the output means.

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 with every word earning its place; the key input source is front-loaded and there is no repetition of schema fields or boilerplate.

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 an output schema exists, so return values need no description. It is adequate for basic selection, but the unresolved device parameter and lack of behavioral caveats leave clear gaps for full invocation confidence.

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

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

Schema coverage is 0%, so the description must compensate. It usefully clarifies tab_id as an id from chrome_tabs, but the device parameter is completely unexplained, and there is no format or eligibility detail for the id.

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 ('Close'), a clear resource ('Chrome tab'), and explains the id comes from chrome_tabs. This is sufficient to distinguish it from sibling navigation/read/open tools even without a title.

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

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

It implies the workflow: obtain a tab id from chrome_tabs, then close that tab. However, it does not explicitly state when to prefer this over alternatives or exclude cases like closing the whole Chrome window.

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 states that JavaScript is run and a result is returned but does not disclose side effects, execution context, async behavior, error handling, or what state changes may occur. For an arbitrary code-execution tool, 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?

Two sentences with no filler. The core action is front-loaded, and the second sentence adds scope and examples without redundancy. 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?

An output schema exists, so return-value documentation is not required from the description. However, no annotations and weak parameter semantics leave the agent uncertain about which tab or device will be used, whether an existing tab is required, and what limitations apply. For a powerful generic tool, this is not complete enough.

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 makes 'expression' obvious from the tool name and description, and 'in a Chrome tab' hints at tab_id, but 'device' and the relationship between device, tab_id, and the required expression are left unexplained. The defaults are not 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 begins with a specific verb and resource: 'Run JavaScript in a Chrome tab and return the result.' It also differentiates from the chrome_ sibling family by framing this as the catch-all fallback with concrete examples like extracting data, submitting a form, and scrolling to an element.

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

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

The description explicitly says to use this tool for 'anything the other chrome_ tools do not cover,' which gives a clear selection rule against an entire set of siblings. The examples further clarify the intended use cases and imply that if a specialized chrome_ tool applies, it should be preferred.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'point' the tab at a URL, but reveals nothing about side effects, permissions, whether the tab changes state, or what happens if the tab is not found. This is a severe gap for a navigation 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 extremely short (one sentence), but this is under-specification rather than concise efficiency. It front-loads the core action but omits all supporting details necessary for correct invocation. It does not earn its brevity by leaving out superfluous content; it leaves out essential content.

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

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

Given three parameters with no descriptions, no annotations, and an output schema that isn't referenced, the description is drastically incomplete. It provides no information about parameter usage, prerequisites, or return behavior, making it nearly impossible for an agent to call the tool correctly without additional 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%, and the description does not compensate. It only mentions 'different URL,' which loosely maps to the 'url' parameter, but the 'device' and 'tab_id' parameters are completely unexplained. An agent cannot know how to identify the target tab or device from this description.

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

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

The description states a clear action: 'Point an existing Chrome tab at a different URL.' It identifies the resource (Chrome tab) and the operation (navigation). It distinguishes from siblings like chrome_open (likely opening a new tab) and chrome_tabs (listing tabs) by specifying 'existing' tab, but it doesn't explicitly contrast them.

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

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

There is no guidance on when to use this tool versus alternatives like chrome_open or chrome_tabs. The word 'existing' implies a prerequisite, but no exclusions or context about selecting the right tab or device is provided. An agent must infer usage from the name alone.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only restates the action without mentioning side effects (e.g., launching Chrome, focusing the new tab), failure conditions, or whether the phone must be unlocked or connected.

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

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

One short, front-loaded sentence with no redundant wording. Every word contributes to the core action, making it easy to parse quickly.

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, the description omits the optional device parameter and provides no preconditions or side-effect context. With no annotations to compensate, it is not complete enough for reliable invocation in 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?

Schema description coverage is 0%, and the description adds no real parameter meaning beyond the property names. It repeats 'URL' but does not explain the device parameter, its default value, or how it selects among multiple phones.

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

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

States a specific action (open) on a precise resource (a URL in a new Chrome tab on the phone). The phrase 'new tab' differentiates it from related Chrome tools such as chrome_navigate or chrome_close_tab without needing extra context.

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

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

No guidance is provided on when to use this tool versus alternatives like chrome_navigate or chrome_read, and no prerequisites are mentioned. The usage is only implied by the action itself rather than explicitly stated.

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

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

No annotations are provided, so the description must assume the burden. It states the output is structured content (text, links, buttons, fields), which is helpful, but it doesn't disclose any side effects (e.g., it's a read operation, navigation is not performed) or limitations (e.g., requires an open tab, may not capture dynamic content). The description is better than nothing but lacks depth for a tool with no annotations.

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 (read as structured content) front-loaded. The comparison to get_screen and screenshots adds value without 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?

Given the tool has an output schema (though not shown in the prompt), the description doesn't need to explain return values in detail. However, with no annotations and zero parameter coverage, an agent needs to know what 'device' and 'tab_id' mean and prerequisites (like needing an open tab). The description is adequate for the main purpose but lacks critical context for a tool with mutable parameters.

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 carries no parameter information. The parameters 'device' and 'tab_id' are opaque from the schema, and the description doesn't explain them or their format (e.g., device ID vs. adb ID). Given the low coverage, the description should compensate but doesn't, so a 3 is appropriate as it provides no help beyond 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 clearly states the tool reads a page as structured content (text, links, buttons, fields). It distinguishes itself from get_screen and screenshot reading, which helps select it. However, it doesn't explicitly mention that it operates on a Chrome tab or how it relates to other chrome_* tools, but the name and description are clear enough.

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 says this is the web equivalent of get_screen and more reliable than screenshots, guiding when to use it (for reading web content). But it doesn't explicitly state when not to use it or mention alternatives like chrome_javascript or other chrome tools, but the 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 behavioral burden. It discloses that the tool returns tab ids, that those ids are intended for sibling tools, and that sibling tools often default to the most recent tab. It does not discuss device targeting or side effects, but for a list-style read operation, the key behavior is covered.

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

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

The description is two sentences with no filler. It leads with the core action and immediately follows with the most useful operational detail about ids and defaults.

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 listing tool, the description covers the essential behavior, the relationship to sibling tools, and the default-tab behavior. The main omission is device parameter semantics, but given that the parameter is optional and an output schema exists, this is a minor gap rather than a blocking one.

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, device, has 0% schema description coverage and is not explained in the description. The phrase 'on the phone' hints at a default device but does not clarify how to select a specific device or how the empty default is resolved. The description does not compensate for the missing schema 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 clearly states the action 'List' and the resource 'tabs open in Chrome on the phone.' It is immediately distinguishable from sibling tools like chrome_open, chrome_navigate, and chrome_close_tab, so an agent can understand exactly what this tool does.

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 practical guidance by explaining that the returned ids should be used with the other chrome_ tools, and that most of those tools default to the most recent tab. It does not explicitly list exclusions, but the purpose and typical workflow are clear enough.

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

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

With no annotations, the description carries the full burden. It discloses that it handles any language and emoji, which is a meaningful behavioral trait. Yet it omits details such as error handling (invalid index, no focus), potential side effects (e.g., form submission), and whether it operates on a specific tab/device. This is partial disclosure but not comprehensive.

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 redundancy. It front-loads the core action and then provides the key usage detail (index or focus) and a differentiator. Every word earns its place.

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

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

For a simple typing tool, the description covers the primary usage and intent. However, it lacks detail on error conditions, parameter semantics for device/tab_id, and any return values (though an output schema exists). With no annotations and zero schema descriptions, the tool is not fully self-explanatory for an agent, especially regarding optional parameters.

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

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

Schema coverage is 0%, so the description must explain all parameters. It explains 'text' (the content to type) and 'index' (field number from chrome_read), but provides no guidance on 'device' or 'tab_id' — these remain undocumented. Given the low coverage, the description does not fully compensate, leaving two parameters ambiguous.

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 (type into a field) and the resource (Chrome), and it explicitly differentiates from the phone's own keyboard (type_text) by noting language/emoji support. This makes the tool's purpose unambiguous even among many Chrome-related 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 provides concrete usage instructions: how to specify the field via an index from chrome_read, or omit it to type into the focused element. It also contrasts with the phone keyboard, hinting at when to prefer this tool. However, it does not explicitly mention when NOT to use it (e.g., for non-Chrome fields) or any prerequisites like having a tab open.

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 discloses that the port changes and that the tool rediscovers it, a key operational detail. It doesn't mention failure handling or side effects, but the core reconnection 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?

Two sentences with no filler. The primary purpose and usage trigger are front-loaded, making it easy to scan and understand.

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 explains the use case and behavior, and an output schema exists. However, the missing parameter semantics is a significant gap for a tool with only one parameter. The description is adequate for understanding intent but incomplete for actual 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 schema has zero description coverage for the 'device' parameter, and the description does not mention it at all. An agent has no guidance on what value to supply (e.g., device ID, IP, name). The tool cannot be correctly invoked without this information.

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 to an already-paired phone over Wi-Fi, a specific verb+resource. It distinguishes from siblings like pair_wireless (initial pairing) and enable_wireless (toggling wireless debugging) by its focus on reconnection after a reboot.

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

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

Explicitly says to use after the phone reboots or wireless debugging is toggled, providing clear timing. It also implicitly excludes initial pairing scenarios, giving an agent unambiguous guidance on when to invoke this tool over 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 provided, the description must disclose behavioral traits. It does state that pairing is remembered, which is a key side effect. However, it does not clarify the effect of the optional 'device' parameter or behavior with multiple connections, leaving some behavioral ambiguity for a tool with no annotation safety net.

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 remarkably concise: two short sentences with the core action front-loaded. Every word adds value—'Drop the wireless connection' is direct, and the pairing note is essential context. No fluff 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 tool, the description covers the main action and a key behavioral note, and an output schema exists so return values are not needed. However, the complete lack of parameter explanation and ambiguity around multi-device behavior leaves gaps. It is adequate but not fully comprehensive.

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 one optional parameter 'device' with zero description coverage (0%). The description does not mention this parameter at all, failing to explain its purpose or how it affects the disconnect action. Since coverage is low, the description was required to compensate and does not, making the parameter semantics completely 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 description states the exact action 'Drop the wireless connection' with a specific resource, and it clearly distinguishes from connect_wireless by noting the pairing is remembered. This differentiates it from sibling tools like pair_wireless and enable_wireless 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 provides context by mentioning connect_wireless as the reconnection path and notes that pairing is retained, which implies the tool is for temporary disconnects. However, it does not explicitly list when not to use it or compare to other alternatives like pair_wireless, so it lacks full exclusion 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 behavioral disclosure burden. It explains the discovery mechanism, the bridge-port check, and the important caveat that a discovered phone still needs its pairing token before it can be driven. This adds meaningful behavioral context beyond simply restating the tool name.

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 well-structured: it opens with the primary action, then adds the technical detail, and ends with the crucial prerequisite. Every sentence earns its place with no 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 zero-parameter discovery tool with an output schema, the description covers the essential context: what is discovered, how discovery is validated, and what further action is required. Nothing important is missing for an agent to invoke it correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly focuses on the tool's behavior rather than inventing parameter guidance, and no parameter clarification is needed.

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 specific verbs ('Look for', 'Finds', 'checks') and a concrete resource: Android devices on the tailnet running the client app and answering on the bridge port. This clearly distinguishes it from generic device-listing tools such as list_devices.

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 clear context for when to use the tool: when you need to find phones on the tailnet that are running the client app. It does not explicitly name alternative tools or exclusions, but the intended use case is 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 and discloses key traits: the phone must be physically connected, no pairing code is required, and the wireless state is not persistent across reboot. It does not cover error conditions or side effects on existing connections, but it covers the critical state change and prerequisite.

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

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

Four short sentences with no filler: action/outcome first, then prerequisite, usage trigger, and persistence caveat. Each sentence contributes non-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?

Most operational facts are present and an output schema exists, so return-value explanation is not required. However, the only input parameter is left completely undocumented, and the tool's relationship to connect_wireless/disconnect_wireless beyond pair_wireless is not addressed, leaving partial ambiguity for a simple tool.

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

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

Schema description coverage is 0%, and the description never explains the single device argument: whether it is an ID, serial, display name, or optional value that defaults to the current phone. The schema title 'Device' and default '' are only minimal hints, so the description fails to compensate for the uncovered 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?

Description opens with a concrete verb and resource: 'Switch a cabled phone over to Wi-Fi so the cable can be unplugged.' It also stakes out its boundary from pair_wireless by noting it does not survive reboot, so the agent can distinguish the two.

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

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

It gives an explicit trigger: 'Use this when the user wants to stop using the cable.' The prerequisite 'Needs the phone plugged in for this one step' and the no-pairing-code note help rule it in/out, and the reboot caveat names pair_wireless as the alternative when persistence 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?

With no annotations, the description carries the behavioral disclosure burden. It usefully clarifies that the phone itself is not affected, which prevents a dangerous misinterpretation. However, it does not disclose whether the registry removal is reversible, whether it affects connected/pairing state, 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 short sentences with no filler. The primary action is stated first, and the key caveat about the phone being untouched is immediately adjacent, making it easy to parse.

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

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

The tool is simple with one parameter and an output schema exists, so the description covers the core behavior. However, the lack of parameter semantics and usage guidance means an agent may still be uncertain about what value to pass and when this should be used instead of related phone-management tools.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not mention the 'name' parameter or define whether it refers to the phone's display name, identifier, or registry key. The schema only provides the string type and required flag, leaving the agent to infer the meaning.

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

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

The description clearly states a specific action ('Remove a phone from the registry') and distinguishes this from physical device operations by noting the phone itself is untouched. This separates it clearly from siblings like repair_phone or add_phone.

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 use when you want to unregister a phone, but it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or mention related tools such as add_phone or list_phones. An agent gets little routing guidance beyond the basic action.

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 transparency burden. It clearly indicates that the operation is a read of the current screen and explains the output format. It does not disclose edge-case behaviors such as errors when the screen is off or the device is disconnected, but for a simple read tool the core behavior is well communicated.

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. The core action and output format are front-loaded, and the usage guidance follows naturally. 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?

Given the tool's low complexity scrap output schema exists and the description covers what it does, what it returns, and when to call it, the main remaining gap is the undocumented device parameter. That is a modest omission rather than a fundamental completeness failure.

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 one parameter, device, with 0% description coverageane the description never mentions it. The tool description does not add any meaning about how to specify or omit the device parameter. The optional nature and default value in the schema reduce the risk, but the description still fails to compensate for the missing 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 uses a specific verb ('Read') and a clear resource ('what is currently on the phone screen'), and further specifies the output as a 'numbered list of tappable elements.' This also distinguishes it from siblings like take_screenshot, which would return a visual image rather than structured tappable elements.

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: 'call it before acting, and after anything unexpected.' It also positions itself as 'the main way to see the phone.' However, it does not explicitly name alternatives or state when not to use it, 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?

No annotations are provided, so the description carries the full burden. It implies a read-only discovery operation ('list'), but does not explicitly state that it has no side effects, nor does it mention prerequisites like ADB server running or permissions. The local-setup context adds some behavioral framing, but significant safety specifics remain undisclosed.

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

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

The description is two sentences, front-loads the core function, and then adds a concise usage context. Every word earns its place; there is no fluff 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?

The description covers purpose and usage context well, and the output schema exists so return-value documentation is not needed. However, the unexplained parameter, lack of explicit read-only disclosure, and absent prerequisites (e.g., ADB setup) leave gaps for an agent trying to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. However, the description makes no mention of the sole parameter 'device' – its meaning, format, or filtering behavior. An agent has no guidance on whether to supply it or what values to use.

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's purpose: listing phones reachable over ADB (cable or wireless debugging) from this machine. It also dissociates this from day-to-day network-based phone access, which distinguishes it from sibling tools like list_devices.

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 states when to use this tool: 'Only useful while setting a phone up locally.' It also gives a clear exclusion: day-to-day the phones are reached over the network, not ADB, implying an alternative sibling. This is strong guidance for an agent.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It communicates a read-style listing behavior and reveals the permission-related filter ('which ones this server is allowed to open'), which adds useful context. However, it does not mention device-connectivity requirements, possible failures, or other edge behavior, though the operation is low-risk.

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. Every part earns its place: the primary listing behavior and the additional permission-related output 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 tool is simple, has an output schema, and the description covers its core behavior. However, it lacks guidance on the 'device' parameter and when to use the tool, so it is only minimally complete 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?

There is one optional 'device' parameter with 0% schema description coverage, and the description does not explain it. The parameter name and title ('Device') give some hint, and 'the phone' in the description implies a device context, but the description adds no real semantic value about how to choose or format the device value.

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 ('List') and resource ('apps installed on the phone'), and adds a meaningful output nuance: which apps the server is allowed to open. It is clearly distinct from open_app, but it does not explicitly compare itself to any sibling, so it stops short of full differentiation.

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

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

No guidance is given about when to use this tool versus alternatives. An agent could infer it is useful before calling open_app, but the description never states that or provides any exclusion criteria.

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 implies a read-only discovery operation through words like 'Find' and 'discover,' and adds meaningful context about the device source (tailnet client app). It does not, however, state whether it modifies anything, whether already-added phones are excluded, or whether any connection/handshake occurs during the call.

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

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

The description is two short sentences with no filler. The primary purpose is front-loaded, and the ADB clarification earns its place by preventing misuse of a sibling tool.

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

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

For a simple discovery tool, the description covers the main use case and key sibling distinction. However, the undocumented 'device' parameter and the lack of guidance about other discovery-related siblings leave a meaningful gap. The output schema mitigates the need to describe return 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 input schema has an optional 'device' parameter with no description and 0% schema description coverage. The tool description never mentions this parameter, so an agent cannot tell whether it filters by name, ID, or something else, or whether it is safe to leave as the default empty 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 a specific verb ('Find') and resource ('phones that could be added'), and further scopes it to 'devices on your tailnet running the client app.' It also differentiates itself from list_adb_devices, so an agent can tell this apart 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 explicitly says this is the normal way to discover a phone and tells the agent to use list_adb_devices when ADB is specifically needed. However, it does not address overlapping sibling tools like list_phones or discover_phones, so guidance is not fully comprehensive.

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

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

The description discloses that the tool reports reachability, which is a behavioral trait. However, with no annotations provided, the description carries the full burden. It doesn't mention whether the tool performs any network checks, caches results, or has side effects, but for a simple listing tool this is acceptable. The reachability disclosure adds value 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?

Two sentences, no wasted words. The first sentence states the core function and output. The second sentence provides essential cross-tool context. Information is front-loaded and 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 zero-parameter listing tool with an output schema, the description is complete. It explains what the tool does, what the output means (reachability), and how the results are used by other tools. No critical information 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 schema is trivially complete. The description adds context about how the output relates to other tools (the `device` parameter used elsewhere), which is valuable. Baseline for 0 params is 4, and the description earns it by explaining the significance of the listed phones.

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's function: listing phones the server can drive and their reachability status. It distinguishes itself from sibling tools like list_devices and list_adb_devices by focusing on phones the server can drive, not generic devices or ADB devices.

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

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

The description explicitly explains when to use this tool: to see available phones, and it provides critical guidance that every other tool takes an optional `device` parameter naming one of these phones. It also instructs the agent to always name the device when multiple phones are configured, which is essential for correct 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 provided, the description carries the full burden of behavioral disclosure, and it does so well. It discloses that the lock persists until unlocked, that every subsequent tool call acts on this phone, and that requests naming another phone are refused rather than redirected. This is critical state-changing behavior that an agent must know before calling.

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 behavior, and the second adds the crucial safety rationale and failure mode. There is no redundant wording 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?

Given this is a simple one-parameter state-changing tool with no annotations, the description covers the essential behavioral contract, duration, refusal behavior, and intended usage context. Some minor ambiguity remains around the exact value expected for 'name', but the overall definition is sufficient for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'name' parameter. It implicitly establishes that 'name' identifies the phone to lock ('a request naming a different one'), but it does not specify the expected format, whether it is a device ID or display name, or where valid values come from.

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 explains that the tool restricts all subsequent tool actions to a single phone until explicitly unlocked, and that requests for other phones are refused rather than redirected. This is a specific behavioral contract and not a tautology, though it does not explicitly name sibling tools like unlock_phone to differentiate them.

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

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

The description explicitly states when to use the tool: when helping one person, to prevent a misread instruction from reaching another user's phone. It also implies when it stops applying ('until unlocked'), though it does not explicitly contrast with alternatives such as use_phone or list_phones.

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

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

No annotations are provided, so the description carries the disclosure burden. It does disclose the allowlist restriction and the need to consult list_apps, which is useful. However, it does not describe what happens for disallowed apps, whether launching has side effects on the current device state, or how the optional device parameter affects 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 two short sentences with no filler. The action and examples are front-loaded, and the allowlist constraint is stated immediately afterward. 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 core purpose and restriction are present, and an output schema exists so return values need not be described. However, the optional device parameter is unexplained, and the description does not mention any alternative tools such as open_settings. This is adequate but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. The 'name' parameter is clarified with examples, but the optional 'device' parameter is left entirely unexplained. Since one of the two parameters has no semantic guidance, 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 uses a clear verb-object structure ('Open an app by name') with concrete examples ('youtube', 'chrome'), and it clarifies the tool only operates on allowlisted apps. This distinguishes it from related sibling tools like list_apps, which enumerates apps rather than launching them.

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

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

The description gives a clear precondition: only allowlisted apps can be opened, and the agent should call list_apps to discover them. It does not explicitly list alternatives or exclusions, but the context is sufficient for an agent to decide when to use this tool.

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

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

With no annotations, the description carries the full behavioral burden. It clearly discloses that the tool opens a Settings page directly, and the page list adds useful detail. However, it does not mention prerequisites like device unlock, behavior on invalid page names, or how the optional device parameter affects which device's settings are opened.

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

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

The description is short and front-loaded: the purpose appears in the first sentence, and the second sentence is a compact list of valid values. Every sentence earns its place, and the page list is necessary given the lack of an enum in 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 simple navigation tool, the description covers the core action and the main parameter's value space. It is incomplete regarding the 'device' parameter, whether the page value is case-sensitive, and what happens on invalid input. An agent could call it correctly with the required page, but the optional device semantics remain unclear.

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 for the 'page' parameter by listing all accepted values, which is genuinely useful. However, the 'device' parameter is not explained at all, leaving its meaning and relationship to the sibling device-management tools implicit.

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 ('Jump straight to') and a clear resource ('a Settings page'), and enumerates the exact accepted page values. This makes the tool's purpose unambiguous and distinguishes it from general navigation or app-opening 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 phrase 'instead of navigating there by hand' gives clear context for when to use this tool: when direct access to a Settings page is needed. It doesn't explicitly name alternatives or exclusions, but the page list and sibling context make the intended usage 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 burden and does well: it discloses persistence ('once'), requires user action on the phone, and warns about the port distinction. It does not cover failure cases or state changes, but the essential behavior is clear.

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

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

Three sentences with no filler: purpose, phone-side instructions, and the critical port warning. Every sentence adds useful information and the most important fact 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?

Given no annotations and minimal schema descriptions, this is nearly complete: it explains how to obtain the inputs, what those inputs mean, and the key gotcha. It could clarify the optional device parameter and name the follow-up connect tool, but a correct call is achievable.

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

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

Schema coverage is 0%, so the description compensates by explaining address as the ip:port and code as the 6-digit pairing code. The optional device parameter is not described, but it is not required and has a 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?

States a specific action ('Pair with a phone over Wi-Fi') and a clear outcome ('no cable is needed afterwards'). It also distinguishes itself from siblings by noting that pairing is one-time and that the pairing port differs from the connection port.

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 clear context: use this when setting up wireless debugging, with concrete steps on the phone. It implies the follow-up is connecting, but does not explicitly name connect_wireless or state when not to use this tool.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds useful context about the accessibility service being switched off without warning and the symptom masquerading as a network issue. However, it does not explicitly state whether the check is read-only, what state it inspects, or whether any side effects 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 concise and well-structured. The first sentence states the core purpose immediately, and the second provides a valuable, non-redundant rationale for calling this tool early in troubleshooting. 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 low-complexity diagnostic tool with an output schema present, the description covers the key 'why and when' context well. However, the undocumented 'device' parameter and lack of distinction from the sibling 'check_device' leave meaningful gaps in the overall call 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%, and the description never mentions the 'device' parameter, its format, possible values, or what happens when it is omitted. The agent is left without guidance on how to supply the optional device argument, which is 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 clearly states a specific verb and resource: 'Check whether the phone is reachable and why not, if not.' This is a clear diagnostic purpose. However, it does not explicitly distinguish itself from the similarly named sibling 'check_device', so it stops short of full sibling differentiation.

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

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

The description gives strong, explicit when-to-use guidance: 'Worth calling first when something stops working' and explains the specific failure mode where the accessibility service can be silently disabled and appear as a network problem. It does not, however, mention alternatives or when not to use this tool.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that a key is pressed but does not disclose how the device parameter is resolved, whether a physical or emulated device is required, possible side effects, or what happens if device is left empty. This is thin for an action-performing 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 that front-loads the action and then immediately gives useful, high-signal examples. Every part earns its place, and there is no filler or repetition of 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?

Although the tool is simple, the device parameter is left completely undocumented and the description gives no guidance on multi-device situations or how the empty default behaves. The common-key list helps, but an agent still does not have enough context to confidently invoke the tool across different device setups.

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 useful common values for the key parameter, but it does not explain the device parameter at all, nor does it specify the exact accepted key syntax or whether values need to be exact strings. The parameter meaning is only partially clarified.

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 names the action ('Press') and the resource ('hardware or system key'), and provides concrete examples like back, home, recents, enter, delete, and volume_up. This helps distinguish it from sibling input tools such as tap and type_text, though it does not explicitly contrast with them.

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

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

The description gives no guidance on when to use this tool instead of tap, scroll, type_text, or wake_screen. The example keys imply system-level use, but there are no explicit exclusions, prerequisites, or alternative routing, leaving the agent to infer usage from sibling names.

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 explains that the phone re-enables its own service, works over any network including cellular, and requires no cable or human touch. It does not mention side effects or prerequisites, but the core operational behavior is transparent enough.

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 sentences, with the core action and condition front-loaded. The background about Android revocation and the network/cable detail are relevant and not wasted. It could have been slightly tighter, but the length is reasonable and each sentence adds needed context.

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

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

The description covers what, why, and when, and the output schema presumably documents return values. However, it leaves the device parameter unexplained and does not mention how the agent should select a device or whether prior discovery via list_devices is expected. That is a meaningful gap for successful 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 input schema has one string parameter 'device' with an empty default and 0% description coverage. The tool description never mentions this parameter, so the agent gets no guidance on whether it is required, what formats are acceptable, or how to obtain a valid device identifier. The name itself hints at the device selector, but that is minimal compensation.

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

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

States a specific verb and resource: 'Put the phone's accessibility service back' and specifies the trigger ('when it has been switched off'). It clearly distinguishes itself from all the interaction/device-management siblings by naming the accessibility-service repair action.

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

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

The description gives a clear condition for use: Android revoked the accessibility service and it needs reinstating. It also explains that remote repair works over any network with no physical access, which helps an agent understand when this is appropriate. It does not explicitly name alternative tools, but no obvious alternative exists among the siblings.

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

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

There are no annotations, so the description carries the behavioral transparency burden. It does add meaningful direction-to-effect mapping, such as 'up' meaning go back and left/right moving between pages. However, it does not mention scroll amount, behavior at scroll boundaries, or how the optional device parameter affects the action.

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 delivers the core action and all direction semantics with no filler. The information is front-loaded and every part 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 values do not need elaboration. Still, the device parameter is entirely unexplained, and with zero schema descriptions and no annotations, an agent cannot confidently know whether it must supply a device or how that value is used.

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 provides no parameter descriptions, but the tool description explains the direction parameter's values and their effects. The device parameter, however, is completely undocumented, leaving ambiguity about whether and how to specify a 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?

The description states a specific action ('Scroll the screen') and resource, and immediately clarifies what each direction does. It is neither a tautology nor vague, and it clearly distinguishes this tool from siblings like tap, type_text, and chrome_navigate.

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

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

The description gives clear context: use 'down' to see content further down the page, 'up' to go back, and left/right to move between pages. It does not explicitly state when not to use this tool or name alternatives, but the usage context is strong enough for an agent to make a sensible 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?

No annotations are provided, so the description must carry the behavioral disclosure burden. 'Take a picture' does imply a non-destructive capture and distinguishes it from get_screen's accessibility-tree output, but it does not state the return format, potential capture limitations, or device requirements. It is minimally adequate but not transparent about edge behaviors.

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

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

Two short sentences with no filler. The primary action is front-loaded, and the conditional use case follows immediately. Every word contributes to selection or invocation.

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, no annotations, and no parameter descriptions, the description is too thin to fully prepare an agent. It explains when to use it but not the meaning of its two parameters or what the return value looks like. The core purpose is clear, but operational details are missing.

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

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

The schema has 0% description coverage and the description never mentions 'device' or 'max_width.' An agent cannot determine what the parameters mean, what formats are accepted, or how max_width affects the result. The description adds no semantic value beyond the raw 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 and resource ('Take a picture of the phone screen') and explicitly distinguishes itself from get_screen by naming when that sibling is insufficient. The examples (videos, games, photos, custom-drawn interfaces) make the tool's purpose concrete.

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 a clear conditional for when to use this tool: 'Use this when get_screen doesn't show what you need.' It also names the alternative tool and the scenarios that favor this one, giving an agent actionable routing guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only reveals that the index comes from the last get_screen listing; it does not disclose potential side effects of tapping, required device state, failure conditions, or whether this can trigger consequential actions on the target device.

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

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

Two sentences, no filler, and the core action is front-loaded in the first sentence. The second sentence reinforces the critical input source without repeating schema information.

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

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

The description is enough to attempt a basic tap, but it omits the meaning of the 'device' parameter and gives no guidance on when to prefer the alternative tap tools. Even with an output schema present, the missing device semantics and usage boundaries leave a significant gap for a device-control tool.

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

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

Schema description coverage is 0%, so the description must compensate. It usefully explains that 'index' is the element number from get_screen, but it says nothing about the 'device' parameter, leaving its meaning and when to set it 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 specific verb and resource: 'Tap an element by its number from get_screen.' It clearly differentiates from sibling tap tools like tap_text and tap_coordinates by anchoring the index to a get_screen listing.

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 clear usage context: use the index from the 'last get_screen listing,' and calls this 'the normal way to tap.' However, it does not explicitly contrast itself with tap_text or tap_coordinates, so it stops short of full when-not guidance.

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

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

With no annotations, the description carries the behavioral burden. It does disclose that tapping is done by exact pixel coordinates rather than by element, but it does not mention device targeting, coordinate-origin assumptions, or side effects of tapping arbitrary screen positions. It is not contradictory, just thin.

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

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

Two short sentences with no filler; the action and the when-not-to-use condition are both front-loaded. Every word earns its place.

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

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

For a simple tap tool, purpose and selection condition are present, and an output schema exists so return values are covered elsewhere. However, the description leaves the device parameter and coordinate-system details undocumented, which are necessary for reliable invocation in a multi-device context.

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

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

Schema description coverage is 0%, so the description must compensate for x, y, and device. It gives some meaning to x and y ('exact pixel position') but does not explain the coordinate origin, units, or the device parameter at all. This is insufficient for the optional third parameter.

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

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

States a specific verb and resource ('Tap an exact pixel position') and immediately differentiates from element-indexed tapping by saying it is only for elements with no index, such as screenshot-derived targets. This is enough for an agent to distinguish it from siblings like tap or tap_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?

Explicitly says when to use it ('Only use this when an element has no index') and gives a concrete example (something found in a screenshot). It does not name the alternative tool to use when an index exists, but the condition is clear enough to prevent misuse.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It only describes the selection mechanism and leaves out what happens on no match, multiple matches, or device targeting, as well as any side effects or failure modes.

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 action front-loaded. There is no filler, and each clause contributes either the operation or the usage condition.

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

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

The core use case is covered and an output schema exists, so return values do not need explanation. However, the description omits device parameter semantics and any ambiguity or failure behavior, which 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?

Schema description coverage is 0%, so the description must compensate. It clearly defines 'text' as the label to match, but the optional 'device' parameter is left as an unexplained string with an empty default, relying on schema title and convention.

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: tap an element whose label matches the provided text. The phrase 'not its index' explicitly separates it from index-based or coordinate-based sibling tap 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 gives an explicit trigger condition: use this tool when the visible label is known but the index is not. It does not name the alternative tools explicitly, but the condition is clear enough to route an agent correctly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully reveals that the tool operates on the currently focused field and does not focus a field itself. It does not disclose what happens if no field is focused, whether existing text is overwritten, or how special characters are handled.

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

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

The description is two short sentences with the core behavior front-loaded and the prerequisite stated immediately after. There is no filler or redundant content; 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 two-parameter tool with no annotations, the description leaves a significant gap around the optional device parameter and how the tool selects a target device. It also lacks failure-mode context, such as what happens when nothing is focused. The output schema exists, so return values are not a gap, but this is still incomplete for safe agent invocations.

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 clarifies that 'text' is the content to be typed, but it says nothing about the 'device' parameter, which remains ambiguous in a multi-device context. The description provides little value beyond what the parameter name alone already suggests.

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 ('Type text') and a clear target ('the field that is currently focused'), and it adds a prerequisite: tap a text field first. It does not explicitly name sibling alternatives, but the wording is enough to distinguish typing from tapping or browser-specific typing.

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

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

The description implies the correct usage context: it should be used when a text field is focused, and the user is told to tap a field first. However, it does not say when to prefer this over related tools like tap_text or chrome_type, nor does it give exclusions for when the field is not ready.

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 does reveal the broad outcome (all registered phones become usable) and the triggering action (stop working on one phone), but it does not mention reversibility, whether devices are disconnected, or what happens to in-flight operations.

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 and is not padded. It is slightly awkwardly worded, but it earns its place by conveying the essential action and outcome.

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

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

For a zero-argument state-change tool with an output schema, the description is mostly complete: it identifies the trigger and the intended effect on registered phones. Some ambiguity remains about the exact scope and mechanics of 'unlocking,' but the low complexity makes this a minor gap.

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

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

The tool accepts zero parameters, so the schema is complete by definition and no additional parameter documentation is needed. The description correctly adds no parameter details.

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 concrete state change: stop devoting work to a single phone so that all registered phones become usable again. This is more specific than the tool name and implicitly contrasts with use_phone or lock_phone, though it does not explicitly name a sibling or use the word 'unlock'.

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 call this tool versus lock_phone, use_phone, or disconnect_wireless. The phrase 'so all registered phones are usable again' implies a post-session release, but no conditions, alternatives, or exclusions are given.

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

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

With no annotations, the description carries the disclosure burden. It transparently reveals the key side effect: changing the default affects everyone on the server. It does not mention other behaviors like validation or reversion, but for a single-parameter setter this is adequate and not misleading.

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 purpose, and a clear warning in the second. Every word earns its place; no padding or redundant schema repetition.

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

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

For a simple tool with one required parameter and an output schema, the description covers purpose, global side effect, and usage guidance. It does not list possible values or error cases, but the presence of sibling tools like list_phones mitigates this gap. Overall 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?

Schema coverage is 0%, so the description must clarify the parameter. It implies the parameter is a phone name ('Set which phone'), but never explicitly connects the 'name' field to a valid phone identifier or its format. An agent would still need to infer the meaning from the tool name and context.

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

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

The description states a specific action (set default phone) and resource (the phone used by other tools when no device is named). It clearly differentiates from siblings by focusing on context-setting rather than phone actions or management.

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

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

Explicitly explains when to use (set a global default) and when not to (when switching between phones, prefer naming per call). Warns about the global effect on all server users, which is a strong usage guardrail.

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, this description carries the full behavioral burden. It discloses the main side effect (waking and dismissing swipe lock) and the key limitation (secure locks require the user), providing useful context beyond the bare tool name.

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 contain the core action and the critical security caveat with no redundancy. The structure front-loads the behavior before the limitation.

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 complete for a simple action and an output schema exists, but the undocumented device parameter is a real gap. An agent cannot be fully confident how to target the wake operation across the devices managed by the sibling tools.

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

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

There is one parameter, device, and the schema provides only a type and default with no description. The tool description does not mention device at all, so the agent cannot tell whether it expects a device ID, serial, index, or what the empty default 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 identifies the specific action ('wake the phone') and a precise scope ('dismiss a simple swipe lock'), and it differentiates the tool from full unlock tools by stating that PIN, pattern, and fingerprint locks cannot be bypassed. This is enough for an agent to know what the tool does and what it does not do.

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

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

The description implies the tool is appropriate when the screen is off and protected only by a swipe lock, and it explicitly excludes secure lock types. However, it never names an alternative such as unlock_phone or states when to prefer that sibling, so routing guidance remains implicit.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the report reflects what the 'background watchdog last saw' (historical/cached data), includes specific status details, and emphasizes that it does not poke the phone, establishing read-only behavior. It does not detail staleness limits, but 'last saw' strongly implies them.

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 packed sentences with no filler. The first states what the tool shows; the second explains when to use it. Every phrase 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 zero-parameter tool with an output schema, the description is complete: it identifies the data source, the report contents, and the intended use case. Output schema handles return-shape concerns, so nothing critical is missing.

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

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

The input schema has zero parameters, so there is no parameter burden for the description to carry. The baseline score of 4 applies because there is nothing for the description to add.

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 ('Show') and resource ('what the background watchdog last saw'), with concrete details like 'when the phone went down' and 'whether a repair was attempted'. This clearly distinguishes it from live-check tools such as check_device.

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

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

It explicitly says to use this tool to answer 'has the phone been reachable?' 'without poking the phone right now,' which gives clear context and implies avoiding live-check alternatives. It stops short of naming the exact sibling tool, so it misses the full explicitness needed for a 5.

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