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

The readOnlyHint annotation already establishes the non-mutating nature, and the description aligns with that. The description adds some scope context, 'saved' and 'named', but does not disclose additional behavioral details like return format or pagination. No contradiction with 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 a single short sentence with no filler. It front-loads the action and the scope, every word earning 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, read-only listing tool the description is mostly sufficient. However, since there is no output schema, it could be slightly more complete by stating what the returned list contains (e.g., flow names vs. full flow objects).

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

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

The tool has zero parameters, so there is no parameter-level meaning the description needs to add. The baseline of 4 applies because no parameter explanation is required.

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 ('list') and resource ('all saved named flows'), making the operation unambiguous. It is also clearly distinct from sibling tools like run_flow and save_flow.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives such as run_flow or save_flow. An agent must infer usage from the tool name and sibling list, which is not enough to count as real guidance.

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

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

The destructiveHint annotation already flags this as potentially destructive, and the description doesn't add further behavioral details beyond the click action. It provides a useful workflow hint but not additional side-effect information, which is acceptable given the simple nature of the tool.

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

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

The description is two short sentences with the action first. No redundant phrases, every sentence serves a purpose.

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, all params are documented, and the annotation covers the destructive nature. The description gives enough context for using coordinates and when to use list_elements. Minor lack of success/failure details is acceptable without an output schema.

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

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

Schema coverage is 100%, with descriptions for x, y, and device. The description doesn't add new semantics beyond the schema, but the guidance about element coordinates complements the parameter meaning. Baseline 3 is appropriate.

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

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

The description clearly identifies the action as clicking at x,y coordinates with a specific verb and resource. It differentiates from sibling tools like double_tap or long_press by focusing on a single coordinate-based click. It also mentions an alternative for element-based clicking.

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

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

It explicitly states that for clicking on an element, one should first use list_elements_on_screen to find coordinates, providing direct guidance on when to use this tool versus the alternative. It doesn't explicitly exclude other gesture tools, but the guidance is clear and actionable.

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 offers no behavioral context beyond the action itself. While the destructiveHint annotation indicates potential destructive effects, the description does not elaborate on consequences, such as triggering app actions or changing UI state, which would be valuable for an agent deciding to invoke this tool.

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

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

The description is a single, concise sentence that directly states the action and inputs. There is no unnecessary information, and it is front-loaded with the core purpose.

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

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

For a simple action tool with three well-documented parameters and no output schema, the description is sufficient to convey its purpose and usage. However, it could be slightly enhanced by noting typical return behavior or potential side effects, but the current level is adequate.

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

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

The input schema provides full descriptions for all three parameters (x, y, device), including units and a hint for finding devices. The description adds no additional parameter semantics, so the baseline score of 3 is appropriate given complete schema coverage.

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

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

The description clearly identifies the action (double-tap) and target (screen), and specifies the input as x,y coordinates. This distinguishes it from sibling tools like click, long press, and swipe, which involve different gestures.

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

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

The description implies usage when a double-tap gesture is needed, but it does not explicitly state when to prefer this over alternatives such as single tap or long press. No exclusion or alternative guidance is provided beyond the tool name and description.

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

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

The readOnlyHint=true annotation already signals a safe read operation. The description adds that it retrieves the full crash report content, clarifying the scope beyond just retrieving an ID. No additional behavioral disclosures are necessary for this straightforward read.

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

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

Two concise sentences, front-loaded with the primary purpose. The second sentence adds essential guidance on finding IDs. No wasted words or redundant information.

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

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

For a simple get tool with complete schema and annotations, the description covers the prerequisite (mobile_list_crashes) and indicates the output type ('full content'). It does not describe return format, but given the simplicity and lack of an output schema, this is acceptable.

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?

Both parameters are fully described in the input schema, which already explains their purpose. The description's phrase 'by its ID' reinforces the id parameter but does not introduce new semantic information beyond what the schema provides.

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

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

The description clearly states the action ('Get the full content of a crash report') and the resource ('by its ID'). It distinguishes from sibling tools like mobile_list_crashes by emphasizing 'full content' retrieval.

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 directs users to mobile_list_crashes to find available crash IDs, providing a clear prerequisite workflow. The schema also references mobile_list_available_devices for device selection, but the description does not explicitly exclude alternative tools.

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

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

The readOnlyHint annotation already declares this is a safe read operation. The description adds minimal context beyond the annotation—merely specifying 'current' orientation. This is not misleading, but it does not disclose any additional behavioral traits such as return format or potential platform limitations.

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 immediately states the tool's function. Every word contributes to clarity, with no unnecessary 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 getter with one parameter, the description is sufficient. The lack of an output schema is somewhat mitigated by the clarity of 'screen orientation,' though the exact return format is not specified. Given the low complexity, this is not a significant 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 only parameter 'device' has a full description in the schema, including a pointer to mobile_list_available_devices. Since schema coverage is 100%, the description does not need to add parameter details. Baseline of 3 applies.

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

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

The description 'Get the current screen orientation of the device' uses a specific verb (get) and identifies the exact resource (screen orientation), clearly distinguishing it from the sibling tool mobile_set_orientation. It is unambiguous and not a tautology.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that it is the read counterpart to mobile_set_orientation, nor does it reference sibling tools like mobile_get_screen_size. No explicit or implied usage context is 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?

The annotation readOnlyHint=true already signals a safe read operation, and the description's 'Get' is consistent with that. The description adds minor value by specifying the unit 'pixels' and the device scope, but does not disclose the return format or any other behavioral details.

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

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

A single, clear sentence delivers the essential information with no filler. The action and subject are front-loaded, making it immediately scannable.

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

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

The tool is simple, but since there is no output schema, the description leaves ambiguity about the exact return structure (e.g., width x height vs. diagonal). The phrase 'in pixels' offers the unit but not the shape of the result, which is a notable gap.

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

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

The input schema fully documents the single 'device' parameter, including guidance to use mobile_list_available_devices. The description itself does not add parameter semantics beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'screen size' with an explicit unit ('in pixels'). This sufficiently distinguishes it from sibling tools like mobile_get_orientation, which retrieves a different device property.

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

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

The description provides no guidance on when to use this tool versus alternatives. The only contextual hint appears in the schema's parameter description (referencing mobile_list_available_devices), which helps with parameter selection but not tool selection.

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

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

The annotations include destructiveHint: true, which already informs the agent of the destructive nature. The description adds no additional behavioral context such as potential app replacement, permissions needed, or installation failure modes. Since the annotation covers the key safety aspect, the lack of extra disclosure is acceptable, keeping the score at a baseline 3.

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

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

The description is a single, focused sentence with no redundant words. It conveys the core action without elaboration, which is the pinnacle of conciseness and structure.

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

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

The description, combined with the rich schema and annotation, covers the essential information for invoking the tool. However, it does not mention installation outcome or side effects beyond the annotation's destructive hint. Since there is no output schema, a bit more context on expected results would improve completeness, but the current level is minimally sufficient.

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

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

The input schema provides full descriptions for both parameters, including file format guidance for different platforms and device discovery instructions. With 100% schema description coverage, the description has no additional need to explain parameters, aligning with the baseline of 3.

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

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

The description clearly states the verb 'Install' and the resource 'an app on a mobile device', making the primary purpose obvious. It does not explicitly differentiate from sibling tools like mobile_launch_app or mobile_uninstall_app, but the action verb itself distinguishes the operation as an installation, which is specific enough for a clear purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as mobile_launch_app or mobile_uninstall_app. It also doesn't mention prerequisites like device availability. The only usage hint is in the schema's device parameter description, but the tool description itself is silent on when to invoke it.

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

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

Annotations mark destructiveHint as true, but the description adds no behavioral detail beyond 'launch' or 'open.' It does not explain what happens to the current app, whether the app is brought to the foreground, or why the operation is considered destructive. It provides no context beyond the annotation.

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 three short sentences, front-loading the main purpose without unnecessary fluff. The package-finding hint is concise, even though the referenced tool name is incorrect.

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 schema is detailed, the description references a nonexistent tool for discovering the required packageName and provides no clarification around the destructive annotation. This leaves the agent without reliable guidance 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 already covers all parameters with descriptions, so the baseline is 3. The only additional hint in the description is to find packageName via 'list_apps_on_device,' which is an inaccurate tool reference; it adds nothing about device or locale parameters.

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

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

The description clearly states the tool 'Launch an app on mobile device' and 'Use this to open a specific app,' giving a specific verb and resource. This distinguishes it from siblings like mobile_terminate_app, mobile_install_app, and mobile_open_url.

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 context for when to use the tool ('Use this to open a specific app'). However, it instructs calling 'list_apps_on_device' to find package names, but that tool is not in the sibling list—mobile_list_apps is the actual tool. This makes the guidance partly misleading and there are no exclusions or alternatives mentioned.

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

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

The description is consistent with the readOnlyHint annotation and adds the scope detail 'all installed apps'. However, it does not disclose return format, whether system apps are included, or any permission requirements. With annotations already declaring read-only, the description provides minimal additional behavioral context beyond the scope.

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

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

A single concise sentence of six words. No filler or 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?

For a simple read-only list tool, the description combined with the schema and annotation is largely sufficient. It does not mention return format or app name specifics, but given the tool's simplicity and lack of output schema, the current description is nearly complete for selection purposes.

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

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

Schema description coverage is 100%: the device parameter is fully explained as the identifier to use, with a pointer to mobile_list_available_devices. The description does not add any parameter-specific detail beyond referencing 'the device', so it relies on the schema, matching the baseline.

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 the specific verb 'List' with a clear resource 'installed apps on the device'. This clearly distinguishes it from sibling tools like mobile_launch_app, mobile_install_app, and mobile_list_crashes, which target different actions or data types.

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?

While no explicit alternatives or exclusions are given, the phrase 'List all the installed apps' provides clear context for when to use this tool. The schema also points to mobile_list_available_devices for device selection, which is useful guidance even though it's not in the description itself.

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

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

Annotations already declare readOnlyHint=true. The description adds valuable behavioral context beyond that: it lists physical devices, simulators, and emulators, and clarifies that both Android and iOS are included. It does not mention output format details, but the added scope information is meaningful for a read-only list 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 two short sentences with the main action front-loaded ('List all available devices'). Every sentence contributes meaning, and there is no redundancy or filler.

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

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

For a tool with no input parameters and no output schema, the description adequately covers the tool's purpose and scope. It explains what devices are returned (physical, simulator, emulator; Android, iOS), which is sufficient for an agent to select and 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?

The tool has zero parameters, and schema coverage is 100% by default. The description adds no parameter-specific details because none exist, but the baseline of 4 is appropriate for a no-parameter tool, and the description clarifies the result set (available devices across platforms).

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 ('List') and resource ('available devices'), clearly distinguishing it from sibling tools related to orientation, screen recording, crashes, and apps. It also specifies the scope: physical devices, simulators, and emulators, across both Android and iOS.

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 about what the tool returns (both platforms, physical and virtual devices), effectively indicating when to use it. It does not explicitly name alternatives or exclusions, but no sibling tool performs a similar listing function, so the usage context is sufficient.

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

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

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds the scope 'on the device' but does not disclose any additional behavioral traits such as return format or ordering. With annotations covering the safety profile, a 3 is appropriate for the minimal added context.

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

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

The description is a single, concise sentence that immediately communicates the tool's function. No unnecessary words 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, one-parameter, read-only listing tool, the description covers the essential purpose and scope. It could optionally mention that the returned crash reports could be used with 'mobile_get_crash,' but this is not strictly necessary given the tool's simplicity and the lack of an output schema.

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

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

Schema description coverage is 100% and the single parameter 'device' already has a helpful description with a pointer to a companion tool. The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description uses a specific verb 'List' with a clear resource 'crash reports' and scope 'on the device,' making its purpose unambiguous. It also distinguishes itself from the sibling tool 'mobile_get_crash,' which likely retrieves a single crash, by focusing on the listing 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 input schema description provides usage guidance by directing the user to 'mobile_list_available_devices' to find valid device identifiers. However, the tool description itself does not explicitly state when to use this over alternatives like 'mobile_get_crash,' though the use case is clear from the context.

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

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

Beyond the readOnlyHint, the description adds the specific instruction 'Do not cache this result,' indicating the output is dynamic. It also specifies the output content (coordinates, text/label), providing transparency about what to expect. However, it does not discuss potential failures, required permissions, or return structure, so it's not a 5.

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

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

The description is two concise sentences, front-loaded with the primary action. Every word adds value, with no redundant or fluff content.

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

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

For a single-parameter read-only tool with no output schema, the description is fairly complete: it states what is listed (elements, coordinates, text/label) and adds a caching caution. It could benefit from clarifying what qualifies as an 'element' or whether the output is a list, but overall it covers the essential 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?

The input schema already provides a complete description of the 'device' parameter, including a pointer to mobile_list_available_devices. The tool description adds no parameter-specific information, but since schema coverage is 100%, the baseline of 3 applies.

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

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

The description clearly states the tool's function: listing on-screen elements with coordinates and display text or accessibility label. It distinguishes from sibling tools like mobile_take_screenshot or mobile_get_screen_size by focusing on UI element hierarchy rather than images or dimensions.

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 does not explicitly state when to use this tool versus alternatives. It only includes 'Do not cache this result,' which is a usage caution, but there is no mention of alternatives or contextual triggers. The schema's parameter description references sibling tool mobile_list_available_devices, but that's for parameter resolution, not tool selection.

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

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

The annotation destructiveHint: true already signals potential destructive behavior. The description adds minimal extra context beyond the action itself, only noting how to find coordinates for elements. It does not contradict the annotation, but it also doesn't disclose additional behavioral traits such as side effects or system behavior. Given the annotation covers the safety profile, a score of 3 is appropriate.

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, concise, and front-loaded with the core action. The second sentence provides a practical tip without redundancy. Every word earns its place, and it avoids repeating schema details.

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

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

This is a simple action tool with no output schema and a single annotation. The description covers the core action and a key usage tip. It omits details like duration default, but that is already in the schema. For a tool of this complexity, the description is sufficiently complete, though it could theoretically mention that a long press may trigger context menus or custom actions.

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

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

Schema coverage is 100% with all parameters (x, y, device, duration) described. The description adds value by instructing to use list_elements_on_screen to find coordinates, which clarifies the expected format of x/y parameters in a real workflow. This goes beyond the schema's bare pixel descriptions, earning a 4.

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 'Long press on the screen at given x,y coordinates', identifying the specific action (long press) and resource (screen coordinates). It distinguishes from sibling tools like click, double tap, and swipe by the verb 'long press', and the second sentence adds a usage hint 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 explicit guidance for one common scenario: 'If long pressing on an element, use the list_elements_on_screen tool to find the coordinates.' This tells the agent how to obtain coordinate input and implies this tool is for coordinate-based presses. However, it does not explicitly contrast with click/double-tap tools, so it's not a full when-to-use vs alternatives guideline.

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 annotation destructiveHint: true already informs the agent that this operation is potentially destructive. The description adds the context that the URL opens 'in browser on device', but does not disclose additional behavioral details such as navigation side effects, default browser behavior, or whether the current app will be left.

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 word earns its place, making it highly concise and 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 only two parameters, both documented, and the action is clear. However, the description lacks information about expected outcomes or side effects beyond the destructive annotation, and there is no output schema. It is adequate but leaves room for more detail.

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

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

Schema description coverage is 100%, with both 'device' and 'url' adequately documented in the schema. The description adds no additional semantic meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Open') and resource ('a URL in browser on device'), clearly distinguishing it from sibling tools that launch apps, take screenshots, or manage devices. It is unambiguous and actionable.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It simply states the action without contextual usage instructions.

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 destructiveHint annotation is present, but the description adds no behavioral context beyond restating the action. It does not mention potential side effects like navigation changes or platform-specific behavior, which would be valuable despite the annotation.

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

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

The description is a single, concise sentence with no unnecessary words. It is front-loaded and to the point, though it could be slightly more informative without losing brevity.

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 rich schema and destructiveHint annotation help compensate for the sparse description. However, it lacks contextual cues to differentiate from sibling input tools and does not explicitly state that it handles hardware/device buttons, relying on the schema for that distinction.

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

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

Schema description coverage is 100% and includes detailed descriptions for both parameters, including a list of supported buttons and a reference to mobile_list_available_devices. The tool description itself adds no parameter semantics, so the baseline score of 3 applies.

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

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

The description states 'Press a button on device', which is a clear verb+resource. However, it does not explicitly distinguish from sibling input tools like clicking on screen or typing keys, so it is clear but lacks strong differentiation.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of platform limitations or use cases is provided, leaving the agent to infer from the schema.

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 tool has a destructiveHint: true annotation, so the bar for additional behavioral disclosure is lower. The description accurately describes a file-writing operation but adds no extra context such as potential overwriting of existing files, required permissions, or side effects beyond what the annotation already signals.

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 redundant words. It succinctly conveys the tool's purpose without unnecessary detail.

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

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

This is a simple tool with a well-documented schema and clear annotations. The description is sufficient for the agent to understand the basic operation, though a note about overwriting behavior or file path handling would enhance completeness. Overall, it is adequate for the tool's simplicity.

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

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

The input schema provides 100% coverage of both parameters with clear descriptions. The tool description itself adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('save') and clearly identifies the resource ('screenshot of the mobile device') and the target ('to a file'). This distinguishes it from the sibling tool mobile_take_screenshot, which likely captures a screenshot without saving to a file.

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

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

The description implies use when you need to persist a screenshot to a file, but it does not explicitly state when to use this tool versus alternatives like mobile_take_screenshot, nor does it mention any exclusions or prerequisites.

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

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

The description adds no behavioral context beyond what annotations already indicate (destructiveHint=true). It does not disclose side effects, reversibility, or any device-specific behavior. Given that this is a mutating operation, more transparency would be valuable, but the annotation covers the basic destructive nature.

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

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

The description is a single, clear, front-loaded sentence with no filler. It efficiently states the action and target resource, earning a high score for conciseness.

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

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

For a simple tool with two well-documented parameters and no output schema, the description and schema provide sufficient information. The only minor gap is the lack of usage guidance, but overall the definition is complete enough for its complexity.

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

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

Schema coverage is 100% and both parameters are fully described, including the enum values for orientation. The description adds no extra parameter semantics, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Change') and a clear resource ('screen orientation'), making the tool's purpose unambiguous. It naturally distinguishes from sibling mobile_get_orientation, which reads orientation rather than changing it.

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 a setter role opposite to mobile_get_orientation, but it does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or side effects. Usage context is only inferred from the verb 'change' and the sibling tool name.

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

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

The annotation destructiveHint:true already signals potential harm, and the description adds behavioral context: the recording runs in the background, requires an explicit stop, and returns a save path. No contradiction with annotations is present.

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 concise sentences, front-loaded with the action, and no fluff or repetition of schema details.

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

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

For a simple start-recording tool with no output schema, the description conveys the key return value (path), the background lifecycle, and the stop counterpart. The schema covers parameter details, making this description sufficient.

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

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

Input schema covers all three parameters with descriptions (100% coverage), so the description adds little beyond noting the returned path. This aligns with the baseline score of 3.

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

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

The description uses the specific verb 'Start recording' with the resource 'screen of a mobile device,' clearly distinguishing the tool from its sibling mobile_stop_screen_recording, which is explicitly named. It states the action and the object precisely.

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

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

It explains that the recording runs in the background until stopped with mobile_stop_screen_recording, giving clear context for when to use this tool and naming its counterpart. It lacks explicit 'when not to use' guidance, but the context is unambiguous.

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

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

Annotations already declare destructiveHint=true, and the description adds value by specifying that the tool returns file path, size, and approximate duration. This discloses the outcome of stopping a recording, which is not captured by the annotation alone.

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

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

The description is a single, well-structured sentence that front-loads the primary action and then tersely lists the return values. Every word 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?

Given the tool's simplicity (one parameter, no output schema), the description adequately covers purpose and return values. It could mention error behavior if no recording is active, but this is a minor omission for such a straightforward stop operation.

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

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

Schema coverage is 100% for the sole parameter 'device', and its description already provides complete guidance including a reference to mobile_list_available_devices. The tool description does not need to add further parameter details beyond what the schema already contains.

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 ('Stop') and the resource ('an active screen recording on a mobile device'). It is distinct from siblings, especially the paired mobile_start_screen_recording, and adds return value information that makes the tool's purpose unambiguous.

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

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

The phrase 'Stop an active screen recording' implies the tool should be used only when a recording is in progress. This provides clear context, but the description does not explicitly state what happens if no recording is active or mention any alternatives, though the sibling list makes the pairing obvious.

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 adds no behavioral details beyond the annotation destructiveHint: true. It does not explain what side effects a swipe might have, whether it triggers scrolling or navigation, or how it interacts with the app's UI. The burden is partially on the annotation, but the description itself contributes nothing about potential consequences.

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

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

The description is a single, short sentence: 'Swipe on the screen.' It is concise and front-loaded with the key verb and object, with no wasted words. However, its brevity borders on under-specification, as it omits any context about direction or intended use, but it remains appropriately size for a simple gesture 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 straightforward swipe tool, the description plus schema and annotations provide a minimally viable level of information. The schema explains parameters, and the annotation flags destructive potential, but the description lacks contextual guidance on when to choose this tool over siblings and what the effect will be on the app state. This leaves some gaps for an agent to reason about.

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

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

The input schema provides 100% coverage with descriptions for all five parameters, including units, defaults, and how to discover device identifiers. The description adds no additional parameter information, so it relies on the schema, which is already sufficient. This aligns with the baseline score of 3 for full schema coverage.

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

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

The description 'Swipe on the screen' clearly states the action (swipe) and the target (screen), making the tool's purpose obvious. It does not explicitly differentiate from sibling interaction tools like tap or long press, but the verb itself is distinct enough to convey the intended gesture.

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

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

The description provides no guidance on when to use this tool versus alternatives such as mobile_click_on_screen_at_coordinates or mobile_long_press_on_screen_at_coordinates. There are no usage scenarios, prerequisites, or conditions specified, leaving the agent to infer appropriateness from the tool 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?

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds valuable behavioral context beyond annotations: 'Do not cache this result,' which is a non-obvious constraint that the agent must know. It also clarifies that the screenshot is for understanding the screen, not for saving or interaction, which supplements the annotation's minimal safety signal.

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 main purpose stated first, followed by usage guidance and a cache warning. Every sentence serves a distinct and valuable purpose, with no wasted words.

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

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

For a simple tool with one well-documented parameter and a read-only annotation, the description is quite complete. It covers purpose, usage guidelines, and a behavioral note about caching. It does not explicitly describe the return format, but given the tool's nature and the lack of an output schema, the omission is acceptable because the screenshot result is inherently visual and the description implies its purpose.

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 100% coverage for the single parameter, and its description already explains how to find available devices. The tool description adds no additional parameter detail, so the schema carries the full burden, which matches the baseline of 3 for high schema coverage.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Take a screenshot of the mobile device.' It also distinguishes its purpose from the sibling tool for listing elements by explaining when each should be used, which is exactly what a clear purpose statement should 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 provides explicit guidance on when to use this tool versus alternatives: use it to understand what's on screen, but if you need to press an element available through the view hierarchy, you must list elements on screen instead. It also adds a constraint not to cache the result, giving clear usage context.

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

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

Annotations declare destructiveHint=true, and the description aligns by saying 'terminate'. However, the description adds no additional context about effects such as process termination vs. data removal, or whether stopping is reversible. Since annotations already convey destructiveness, the description provides minimal extra value.

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 and front-loaded. It is concise but includes slight redundancy with 'Stop and terminate'. Overall, it's appropriately sized but lacks extra useful 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?

The tool is simple, with full schema coverage and a destructive annotation, so the description meets a minimum viable threshold. However, it fails to clarify the distinction from uninstall and provides no usage context, making it only partially complete.

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

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

The input schema provides descriptions for both parameters (device and packageName), covering 100% of the schema. The description itself adds no parameter-specific information, so it does not exceed the baseline.

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 'Stop and terminate' with a clear resource 'app on mobile device'. It clearly conveys the action, but doesn't explicitly distinguish this from mobile_uninstall_app, which could be a source of confusion.

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 provided on when to use this tool versus alternatives. The description doesn't mention that this only terminates the running app and does not uninstall it, nor does it reference sibling tools like mobile_uninstall_app.

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

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

The annotation destructiveHint=true indicates the operation is potentially destructive, and the description adds the condition 'focused element' as the target. However, it does not explain side effects such as overwriting the current text, what happens if no element is focused, or the behavior when 'submit' is true (though this is partially covered in the schema).

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

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

The description is a single sentence of six words, front-loading the core action and target. Every word contributes meaning; there is no fluff 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 typing tool, the description covers the basic operation and the schema covers parameters. However, it lacks usage context (e.g., when to use vs. alternatives, prerequisites like having a focused element clearly established) and does not compensate for the absence of an output schema with information about expected results or errors.

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

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

The input schema provides full descriptions for all three parameters (text, device, submit), including guidance for finding available devices. The tool description itself adds no additional parameter semantics, so the schema's 100% coverage establishes a baseline of 3.

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

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

The description clearly states the tool's function: 'Type text into the focused element.' The verb 'type' and the resource 'text into the focused element' distinguish it from sibling input tools like mobile_press_button or mobile_click_on_screen_at_coordinates, which involve different forms of interaction.

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 such as pressing a button or tapping coordinates. The only context is the parameter description for 'device' recommending mobile_list_available_devices, but this is not about tool selection or exclusions.

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

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

Description adds no behavioral context beyond the destructiveHint annotation. It does not mention permanence, data removal, or any 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?

Single sentence with no redundancy. Front-loaded with the action and resource, making it efficient and 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?

Simple tool with complete schema and destructive annotation. Description conveys the core function but lacks usage context, alternatives, or outcome details.

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

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

Schema provides complete descriptions for both parameters (100% coverage), so the description need not add parametric details. Baseline of 3 is appropriate.

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

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

Clear verb 'uninstall' with resource 'app' and location 'mobile device'. It distinguishes from sibling tools like install, launch, and terminate.

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

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

No guidance on when to use this tool vs alternatives (e.g., terminate vs uninstall). No prerequisites or context provided.

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

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

Annotations already declare destructiveHint=true, and the description adds useful context consistent with that: the tool executes steps in order, spans native and webview, and enumerates the full op set including terminate_app, which is the destructive operation an agent should be cautious about. It does not, however, describe failure modes, side effects, or what happens with assertions/stopOnError behavior beyond what the schema already states – for a destructive tool, some cautionary framing would add value.

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 dense block with the purpose and the key parameter constraint (steps/name 二选一) front-loaded, followed by the device rule, an illustrative example, and the op enumeration. No sentence is wasted. It loses one point for structure: the long op list is run together as one parenthetical dump, making it harder to parse than a list or shorter grouping would be.

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

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

For a composite tool with 5 parameters, a destructive annotation, and no output schema, the description covers invocation essentials well: parameter choice, example step shape, and op set. However, it never states what the tool returns (success/failure, assertion results, collected artifacts), and it defers detailed per-op field requirements to a source file (flows.ts) rather than documenting them. With no output schema, the description carries that burden and leaves a clear gap.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine meaning beyond the schema: the steps array's items are empty objects in the schema, and the description compensates with a concrete step example ({op:'launch_app',...}, {op:'tap_text',text:'登录'}) and enumerates the complete op vocabulary. It also clarifies the mutual-exclusivity and default-device semantics. It falls short of 5 because per-op required fields are not fully specified, and it defers to flows.ts for 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 specific verb ('按序回放' – replay in sequence) and a concrete resource ('一段步骤' – a sequence of steps), and immediately characterizes the tool as a composite '搭积木' (building-blocks) operation over native+webview primitives. This clearly distinguishes it from the many atomic sibling tools (mobile_launch_app, webview_click_text, etc.) and from save_flow/list_flows, which manage flows rather than execute 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 solid internal usage guidance: steps vs. name are mutually exclusive ('传 steps(内联数组)或 name(已存 flow)二选一') and device falls back to a default. However, it never explicitly says when to choose this tool over siblings (e.g., 'for a single action use mobile_*; use this to replay multiple steps') nor references the save_flow/list_flows alternative for flow management. The usage context is implied by the composite nature, not 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?

Annotations already flag destructiveHint=true, so the destructive nature is covered. The description adds the intent (saving for later replay) but does not disclose details like overwriting behavior on duplicate names or what the function returns. Given the annotation, a score of 3 is appropriate – it adds some context but not deep behavioral specifics.

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 concise sentence that front-loads the purpose and includes the key use-case link. There is zero fluff, and 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 two-parameter tool with no output schema and annotations covering the destructive hint, the description is nearly complete. It could mention overwrite behavior or return values, but the core purpose and usage are clear, so it is adequate for an agent to invoke correctly.

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

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

Schema coverage is 100% with minimal descriptions for both parameters ('flow name' and 'step array'). The tool description restates the concept of a step sequence but adds no new detail about step format or constraints. Since the schema covers the parameters, baseline 3 is correct.

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

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

The description states the specific action 'save' and the resource 'flow', and explains that it stores a step sequence under a name. It also explicitly connects to the sibling run_flow, making the distinction clear: save now, replay later with run_flow.

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

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

It gives a clear usage context by mentioning the future replay with run_flow, which implies when to use it. However, it does not explicitly state exclusions or when not to use it (e.g., for listing flows), but the context is sufficient for basic routing.

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

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

Annotations already disclose destructiveHint=true, and the description adds a meaningful selection behavior: it chooses the outermost matching visible element. This goes beyond what the schema or annotations provide. It does not address edge cases like missing text or multiple matches, but the added context is valuable.

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 that front-loads the primary action ('click by visible text') and immediately clarifies the selection rule. There is no redundant or filler content; every clause carries distinct information.

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

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

For a simple two-parameter tool with complete schema coverage and a destructive annotation, the description covers core behavior and selection logic. However, it omits any mention of prerequisites (e.g., a connected webview) or failure behavior, which the schema and annotations do not provide. This is adequate but not exhaustive.

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

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

The schema description coverage is 100%, so both parameters ('text' and 'device') are already fully documented. The description adds no additional parameter-level meaning beyond what the schema states, so baseline 3 applies.

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

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

The description states a specific action ('click') and target ('webview element by visible text'), and adds a precise selection rule ('outermost matching and visible'). This clearly distinguishes it from coordinate-based clicks (mobile_click_on_screen_at_coordinates) and other webview operations (evaluate, screenshot, etc.).

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

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

The description implies usage when an agent needs to click a webview element via its visible text, but it does not explicitly state when to prefer this over alternatives, nor does it mention exclusions or prerequisites (e.g., needing an active webview connection). Guidance is inferred rather than explicit.

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

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

注释已提供 destructiveHint=true，描述未与之矛盾，且添加了自动 adb forward 和返回值细节，但未说明具体副作用（如是否重连会中断现有会话）。由于注释已覆盖破坏性，描述未充分补充行为上下文，评分3。

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?

描述仅一句话，却包含连接/重连、自动 adb forward、返回值及前置条件，无冗余信息，且关键信息前置，结构高效。

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?

无输出 schema，但描述已说明返回 url/title/路由，提供了必要返回值概要。虽未提及连接后的状态或更多细节，但对于简单工具已基本完整，评分4。

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 描述覆盖率为100%，所有参数（port、device、packageName）在 schema 中已有说明，描述本身未额外提供参数语义，按规则基线为3。

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

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

描述明确指出动词'连接/重连'、资源'目标 App 的 in-app 系统 WebView'，并返回 url/title/路由，同时强调是读取 DOM 的前置步骤，与 webview_* 系列兄弟工具（如 evaluate、click）区分明显，目的非常清晰。

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?

描述明确给出使用时机：读取 webview DOM 前必须先调用，提供了清晰的上下文。但未提及何时不应使用或替代方案，不过对于此类前置连接工具，已足够。

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 destructiveHint annotation already marks this as destructive, and the description adds valuable context by naming what is destroyed: the only CDP socket for the page. It also explains the interop reason. It doesn't cover edge cases like calling it when already disconnected, but the main side effect is disclosed.

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

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

The description is a single front-loaded sentence with no filler. The action and resource come first, and the timing rationale is tucked into a short parenthetical that 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 one-parameter destructive tool with annotations and no output schema, this description provides enough context: what it disconnects, what it releases, and when to call it. A no-op or already-disconnected behavior would be a nice extra, but it isn't essential 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 100%, and the single device parameter is already described in the schema as a target device serial matching mobile_list_available_devices id. The description doesn't repeat or expand parameter semantics, but the schema carries the needed 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: disconnecting this tool's CDP connection to the webview and releasing the page's unique CDP socket. This goes beyond the title and makes the tool's role distinct from webview_connect and other webview operations.

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 concrete usage condition: call this before handing the webview over to Appium/chromedriver. It doesn't explicitly mention alternatives or 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?

The readOnlyHint annotation already signals a safe read operation, and the description adds behavioral context by disclosing that the output is truncated and that the element defaults to body. It does not cover error behavior or connection prerequisites, but the annotation lowers the burden.

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

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

The description is one compact sentence with essential behavior front-loaded and no filler. Every part contributes to understanding what the tool does.

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

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

For a simple read-only tool with fully described parametersholistic, the description plus schema is nearly sufficient. The only notable gap is the lack of an output schema or an explicit statement of the return type/format, though 'outerHTML 概要' strongly implies a truncated string.

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

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

Schema description coverage is 100%, so the schema already documents device, maxChars, and selector. The description adds only domain context, not new parameter details, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('取' / get), a specific resource (outerHTML outline of an element in a webview), and the default target (body). This clearly differentiates it from mobile-screen and other webview 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 frames the tool for debugging DOM structure ('排错 DOM 结构用'), giving the agent a clear usage context. It does not name alternative tools or when-not conditions, 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?

Annotations include destructiveHint: true, indicating potential destructive effects. The description does not explain what might be destructive, leaving the agent uncertain. It does provide useful technical details like using returnByValue and awaitPromise, and warns about JS syntax limitations on old devices, which adds value. No contradiction with annotations, but could better clarify 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 concise and information-dense, with no fluff. It front-loads the main action and technical details, then adds a critical compatibility warning at the end. 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?

Given no output schema, the description mentions it returns JSON, which is helpful. However, it does not specify the exact structure of the return value (e.g., whether it includes exceptions, result object). It also lacks behavioral details about side effects, which is important due to destructiveHint. The description is adequate but not complete.

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

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

The schema description coverage is 100%, so parameters are already documented. The description adds an example of expression format and the meaning of device serial, but the schema already provides that. Minimal added value beyond schema.

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

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

The description clearly states the tool evaluates JavaScript in a webview and returns JSON results, specifying the protocol method and options. It mentions execution context and return behavior. It does not explicitly differentiate from sibling tools like webview_click_text or webview_get_computed_style, but the focus on arbitrary JS evaluation is distinct 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?

The description implies usage for running JavaScript in a webview but does not state when to prefer this over alternatives, such as using dedicated tools for clicking or styling. It also does not mention prerequisites like needing a webview connection (via webview_connect). The warning about old devices is a usage constraint but not for alternative 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?

Annotations declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds that it returns computed CSS and bounding box, which is useful. However, it doesn't disclose details like whether the bounding box is in CSS pixels or device pixels, whether the element must be visible, or what happens if the selector matches multiple elements. With annotations covering the safety profile, a 3 is appropriate.

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 core purpose (get computed CSS + bounding box). It's efficient and doesn't waste words. It could add a bit more context about return format, but for its length it's well-structured.

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

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

For a read-only tool with full schema coverage and no output schema, the description is mostly adequate. It tells the agent what it does and what it returns. However, it doesn't mention the bounding box coordinate system, behavior with multiple matches, or whether the webview must be connected first. These are minor gaps for a simple read tool, but they prevent a higher score.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds the default behavior for 'props' (默认常用集 = default common set), which is a small addition beyond the schema. However, it doesn't explain the format of the selector or how the bounding box is returned. Baseline 3 is correct when schema does the heavy lifting.

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

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

The description states a specific verb ('取' = get) and resource (computed CSS + bounding box of an element in a webview), which clearly distinguishes it from sibling webview tools like webview_dom_outline or webview_evaluate. However, it doesn't explicitly name a sibling alternative, so it doesn't fully earn a 5.

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

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

The description implies usage context: it's for reading computed styles and bounding boxes from a webview element. It doesn't explicitly state when to use this vs alternatives like webview_dom_outline or webview_evaluate, nor does it mention prerequisites like needing an active webview connection. The context is clear but exclusions/alternatives are not 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?

The annotation readOnlyHint=true already covers the safety profile, so the description only needs to add non-obvious behavior. It adds that the capture runs for N milliseconds and collects specific fields, which is useful. However, it does not disclose whether the call blocks for the full duration, whether it returns immediately, or whether it affects ongoing network monitoring; it also omits the return format.

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

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

The description is a single compact sentence with zero filler. It front-loads the core action and scope, immediately followed by the relevant captured fields. Every element 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 (2 params, 1 required) and the read-only annotation covers safety. Yet there is no output schema, and the description does not describe the return structure, so an agent must guess at the response format. It also omits any mention of requiring an active webview connection, which is relevant context given the sibling webview_connect/disconnect tools.

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

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

Schema description coverage is 100%: both 'ms' (duration, default 3000) and 'device' (target serial) are already documented in the input schema. The description merely restates the 'N milliseconds' concept and adds no new meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('抓'/'capture') and a clear resource ('webview 的网络请求'/'webview network requests'), scoped by a duration (N milliseconds). It also enumerates the captured fields (url/method/status/type) and explicitly ties it to the Network domain, making it distinct from every sibling webview tool (screenshot, evaluate, DOM outline, etc.).

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

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

Usage is implied by the tool's unique purpose: there is no other network-capture sibling, so an agent can infer when to call it. However, the description does not explicitly state prerequisites (e.g., whether a webview connection via webview_connect is required) or mention any exclusions/alternatives, leaving the when-to-use guidance implicit rather than explicit.

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

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

Beyond the readOnlyHint annotation, the description adds genuine behavioral detail: it uses the /json/list endpoint, automatically performs an adb forward (a side effect on local port forwarding), and filters targets to type:page. These details are consistent with readOnlyHint=true and give the agent useful expectations about mechanism and scope.

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

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

A single dense sentence that front-loads the primary action and packs in the endpoint, the auto-forward behavior, and the page-type filter. All information earns its place, though the mechanism details could arguably have followed the core purpose rather than being embedded mid-sentence.

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 (3 params, no output schema) and the description covers what it does and its mechanism. However, with no output schema, the description never explains what the returned list contains (e.g., whether webSocketDebuggerUrl, title, or url fields are present) or how results feed into webview_connect, leaving a meaningful gap.

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

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

Schema description coverage is 100%, so the schema already documents device, packageName, and the optional port with its default of 9222. The description reinforces that packageName refers to the app whose webview is being debugged, but adds little meaning beyond the schema, making the baseline of 3 appropriate.

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

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

The description states a specific verb and resource: listing the debugging targets of a target app's webview, via the /json/list endpoint, and filtering to type:page targets. This clearly differentiates it from its webview_* siblings, all of which perform actions (connect, evaluate, screenshot) rather than discovery.

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

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

Usage is implied but not explicit: the tool is clearly a discovery step that would naturally precede webview_connect or webview_evaluate, and the '确认 type:page' phrase implies it filters out non-page targets. However, it never says 'use this before connecting' or names alternatives, leaving the agent to infer when this tool is the right choice.

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

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

The description transparently discloses that the tool captures a screenshot and writes it to disk, but the annotations declare readOnlyHint=true. Writing a file is a side effect that modifies the environment, so the description contradicts the annotation. Per the rubric, this contradiction forces a score of 1.

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

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

The description is a single dense sentence with no filler. It packs the protocol, output behavior, and a negative constraint (no base64) into minimal wording.

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

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

With no output schema, the description explicitly covers the return value (file path) and format exclusion (not base64). Both required parameters are fully documented. Minor gaps include prerequisites such as an established webview connection, but these are reasonably inferable from sibling webview tools.

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

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

Schema description coverage is 100%: device is cross-referenced to mobile_list_available_devices, and saveTo is documented with an absolute-path example. The description adds no parameter-specific meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description states a specific action ('page 级截图' using Page.captureScreenshot), the output behavior (save to disk and return file path), and an explicit exclusion (no base64). This distinguishes it from mobile screenshot tools like mobile_take_screenshot and mobile_save_screenshot.

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

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

The 'page 级' phrasing implies this is for webview page screenshots rather than device-level screenshots, and the sibling tools include webview_connect and mobile_take_screenshot. However, it does not explicitly state when to use this tool versus mobile_save_screenshot/mobile_take_screenshot or mention prerequisites like a connected webview.

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