mobile-device-mcp

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

No annotations are provided, so the description carries the full burden. It indicates the tool is read-only (analysis), which is a key behavioral trait. It mentions 'uses AI vision', implying it may have latency or require API access, but does not disclose potential costs, rate limits, or that it might fail on non-visual screens. A 3 is appropriate for covering the basic safety profile without deeper details.

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

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

The description is concise at two sentences, front-loading the purpose and listing return elements effectively. One minor issue: the word 'structured' could be replaced with more specificity, but overall it's well-structured and informative.

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 single parameter and no output schema, the description provides a reasonable overview of what the tool returns. It mentions 'app name, screen type, interactive elements with coordinates, visible text, and suggested next actions', which helps the agent understand the tool's capabilities without needing an output schema. Some details like the exact format of coordinates or whether the output is deterministic could enhance completeness.

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

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

The input schema has 100% coverage on the single required parameter 'device_id', which is well-described. The description does not add any additional context about the parameter beyond the schema, but since coverage is high, the 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 states the tool uses AI vision to analyze a mobile device's screen, returning a structured analysis with specific elements like app name, screen type, interactive elements, and suggested actions. It distinguishes itself from siblings as 'the primary tool for understanding what is currently displayed on the device', which contrasts with more specific tools like extract_text, find_element, or take_screenshot.

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

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

The description provides clear context for when to use this tool ('analyze the current screen') and implies it's the primary tool, suggesting it should be used before more specific tools. However, it does not explicitly state when not to use it or mention alternatives like get_screen_size or get_ui_elements.

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

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

No annotations are provided, so the description carries the burden of behavioral transparency. It describes the action as performing a double tap, which implies standard behavior, but lacks details on consequences (e.g., whether it triggers app actions, if it requires screen readiness). This is adequate but minimal.

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 long, efficient, and directly informative. Every sentence adds value: first sentence states the operation and parameters, second gives use cases. No unnecessary 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?

Given the tool's simplicity (no output schema, straightforward parameters), the description is mostly complete. However, it does not mention coordinate handling for different screen orientations or the expected effect on the UI, which could be helpful for an agent.

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

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

Schema coverage is 100%, and the description adds no additional meaning beyond the schema field descriptions. The description does not elaborate on coordinate system or units (e.g., pixels, device-specific scaling). Thus, the parameter semantics score is baseline 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 action ('double tap') and the resource ('screen coordinates'), and distinguishes from siblings like 'tap' and 'long_press' by specifying the double tap action. It also provides typical use cases (zooming, text selection), which helps the agent understand its purpose.

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

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

The description mentions it is useful for zooming and text selection, but does not explicitly state when not to use it or provide alternatives. Given the many sibling tools, explicit guidance on when to choose this over 'tap' or other gestures would improve the score.

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

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

The description discloses the behavioral trait of returning text in reading order (top to bottom, left to right), which is beyond the schema. Since no annotations are provided, this adds value by informing the agent of the output format. It does not contradict any 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 concise with three sentences, each adding value: first states what it does (pro and AI vision), second specifies output order, third gives use cases. No waste.

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

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

Given the single parameter and lack of output schema, the description adequately explains the tool's purpose and usage. However, it could mention returns plain text or format details for full completeness.

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 'device_id' with a clear description. The tool description does not add extra meaning to the parameter 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 clearly states the tool uses AI vision to extract visible text from the current screen, with a specific verb ('extracts') and resource ('current screen'). It distinguishes itself from siblings like 'take_screenshot' (image capture) and 'get_ui_elements' (accessibility tree) by noting it gets text not in the accessibility tree.

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

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

The description says it's useful for 'reading content, checking labels, or getting text that isn't in the accessibility tree,' providing clear use cases. However, it does not explicitly state when not to use it (e.g., if text is accessible via UI elements) or mention alternatives from the sibling list.

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

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

Describes the behavior of clearing and filling fields, but no annotations provided, so description partially covers safety but doesn't mention side effects or failure modes.

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

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

Concise two-sentence description with front-loaded purpose; uses markdown for the [Pro] tag but still efficient.

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

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

Given no output schema and simple parameters, description is largely complete; could add error handling or prerequisites.

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 description only adds that fields are found by natural language description; baseline 3 since schema already covers 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?

Clearly states it fills multiple form fields in a single operation, specifying it as a batch operation that uses natural language descriptions, which distinguishes it from smart_type.

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

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

Explicitly says it's more efficient than calling smart_type multiple times, but doesn't specify when not to use it or alternatives beyond smart_type.

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

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

No annotations are provided, so the description carries full burden. It indicates the tool is a read operation (vision-based, returns info) and mentions it is 'Pro', but does not disclose potential latency, error cases, or that AI vision may require network or permissions.

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

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

The description is extremely concise with three sentences; the first sentence explains the core action, the second lists return values, and the third provides usage guidance and examples. No filler.

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

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

Given no output schema, the description compensates by listing return values (coordinates, type, confidence). The two parameters are well-covered by schema. However, it could mention that the query must be descriptive or that results may vary based on AI model.

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 describes both parameters. The description adds example queries for the 'query' parameter but does not provide additional semantics beyond the schema.

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

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

The description clearly states it uses AI vision to find a UI element by natural language description and returns coordinates, type, and confidence. It effectively distinguishes from siblings like get_ui_elements (which returns all elements) and find_element (non-pro version presumably), though the sibling list includes similar tools like wait_for_element and verify_screen.

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

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

The description advises using it when locating a specific button, field, or other UI element, with example queries. It does not explicitly exclude alternatives like get_ui_elements or analyze_screen, but the context is clear enough for an AI agent to decide.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the app must be running in debug or profile mode, and that auto-discovery may fail, requiring manual URL input. This is sufficient behavioral transparency for a connection tool, though it could mention any side effects like network calls.

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 (three sentences), front-loading the core purpose and prerequisites, then adding the optional fallback detail. Every sentence serves a purpose without 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 is a connection setup with two params and no output schema, the description is mostly complete: it states prerequisites, return values, and fallback. It could mention that device_id is typically from 'list_devices', but that's implied by sibling context. Overall, adequate 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%, but the description adds value by explaining the role of vm_service_url as a fallback and hinting at its format. For device_id, it simply restates the param name; however, the schema already provides a clear description. The description does not add much beyond the schema for device_id, but the vm_service_url explanation is helpful.

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

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

The description clearly states that the tool discovers and connects to a running Flutter app via the Dart VM Service Protocol, specifying the required conditions (debug or profile mode). It also mentions the return of connection details like isolate ID and app name, distinguishing it as a prerequisite for other flutter_* 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 instructs to call this before using other flutter_* tools, providing clear usage context. It also mentions an optional param for when auto-discovery fails, which guides conditional usage. However, it doesn't explicitly state when not to use it or list specific alternatives among siblings.

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

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

Description states it shows overlays, but does not disclose if it affects app performance, requires specific Flutter setup, or if the effect persists. Without annotations, more detail on behavioral impact would be beneficial.

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?

Concise, two-sentence description with clear structure. First sentence states action, second explains benefit. Could be slightly more compact, but 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?

Given the tool's simplicity (single boolean parameter, no output schema), description adequately covers purpose and use case. Could mention that the overlay appears on the device screen, but not necessary.

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 a simple boolean parameter. Description adds no extra meaning beyond the schema's parameter description, so 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?

Description clearly states the tool toggles a debug paint overlay on a Flutter app, listing specific visual aids (widget boundaries, padding, alignment guides, construction lines). The verb 'toggle' and resource 'debug paint overlay' are specific and distinguishable from siblings.

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

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

Describes use case for debugging layout issues, implying when it's useful. However, does not explicitly state when not to use it or mention alternatives among sibling tools, though none directly compete.

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

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

No annotations provided, so the description must carry the burden. It mentions 'clean up resources' which adds behavioral context beyond the name. However, it does not specify what resources are cleaned up or if any side effects occur.

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

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

Very concise single sentence. The '[Pro]' prefix is front-loaded but could be separated. No unnecessary 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 disconnect action with no parameters, the description is adequate. However, no output schema exists, and the description doesn't mention return value or confirmation. Sibling tools like 'flutter_connect' imply a state, but no context about requiring prior connection.

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?

No parameters exist, schema coverage is 100%. The description does not need to add parameter meaning since there are none. Baseline is 4 for zero-parameter tools.

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?

Purpose is clear: disconnects from the connected Flutter app and cleans up resources. The verb 'Disconnect' and resource 'Flutter app' are specific. However, there are sibling tools like 'flutter_connect' which this differentiates from, but no note about that distinction.

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 explicit when-to-use or when-not-to-use guidance. The description implies it should be used after connecting, but no alternatives or prerequisites mentioned. Sibling 'flutter_connect' is related, but no comparison.

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 mentions that the tool searches the widget tree and returns source locations, but it does not disclose behavioral details such as whether the tool modifies the app state, or any limitations like performance impact. Since no annotations are provided, the description carries the full burden, and it falls short of explaining all behavioral traits.

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

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

The description is concise (3 sentences) and front-loaded with the core purpose. Every sentence adds value: the first states purpose and scope, second gives examples, third describes output. It could be slightly more structured, but overall efficient.

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

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

Given the tool has 2 parameters (both covered by schema), no output schema, and no annotations, the description provides adequate but not comprehensive context. It covers purpose, search scope, and output, but omits details like return format, pagination, or error conditions. For a search tool in a complex environment, more detail would be beneficial.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds value by explaining that 'summary_only' filters to user-created widgets, which is not explicitly in the schema description (which says 'Search only user-created widgets (true) or full tree (false)'). However, the description does not elaborate on the 'query' parameter beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states that the tool searches the widget tree for widgets matching a query, and it specifies searchable attributes (type name, description, text content). It provides example queries and states the return value (matching widgets with source locations). However, it does not explicitly distinguish this tool from sibling tools like 'find_element' or 'flutter_get_widget_tree', which have similar purposes.

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 by giving examples of queries and mentioning search scopes (widget type, text, description). It does not explicitly state when to use this tool over alternatives (e.g., 'find_element'), nor does it provide scenarios where it might not be appropriate or prerequisites. The guidance is functional but lacks comparative context.

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

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

With no annotations provided, the description must fully disclose behavior. It describes the output format (list of {widget, file, line, column} entries) but does not mention performance, pagination, or any side effects. This is adequate but minimal.

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 with two sentences. The first sentence states the mapping function and output structure, while the second emphasizes its utility. It is front-loaded and without fluff.

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

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

Given no output schema and zero parameters, the description is reasonably complete, explaining what the tool returns. However, lacking annotations, it could briefly mention any prerequisites (e.g., needing a Flutter connection) or limitations (e.g., only works in debug mode).

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 high schema coverage (100%), so the description's role is minimal. It adds value by explaining the return structure, which helps an agent understand the output without needing further elaboration.

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 maps every user-created widget to its source code location (file:line:column). While it is specific and action-oriented, it could slightly improve by differentiating from siblings like flutter_get_widget_details or flutter_get_widget_tree.

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 mentions it is 'the key tool for connecting what you see on screen to where it is in code,' implying a debugging or development context. However, it does not explicitly state when to use this tool versus alternatives (e.g., flutter_get_widget_details) or when not to use it.

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

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

No annotations provided, but description discloses return types (properties, children, bounds, location). However, lacks details on side effects, rate limits, or auth needs, which would improve transparency.

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

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

Two sentences, front-loaded with purpose, no fluff. Could combine 'Pro' tag and mention of return types more efficiently, but overall concise.

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, description partially covers return values. No instructions on error handling or performance considerations. Adequate for a detailed getter, but leaves gaps.

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

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

Schema coverage is 100%, so baseline 3. Description briefly mentions valueId source but adds no extra semantics beyond schema for subtree_depth.

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

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

Description clearly states it gets details for a specific widget using valueId, listing return types. No explicit differentiation from siblings, but context implies unique 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?

Implies use after flutter_get_widget_tree (mentions valueId from it), but no explicit when-to-use or when-not-to-use, and sibling tools like flutter_find_widget are not distinguished.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It explains the default behavior (summary tree), what each widget includes, and the prerequisite. It also mentions the optional parameter effect. This is thorough for a read-only tool, though it could mention that the tree structure might be large or slow for complex apps.

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 long, front-loading the main purpose and notable features. It wastes no words. However, the mention of '[Pro]' could be integrated more naturally, but that's minor.

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

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

Given the low complexity (1 optional boolean parameter), no output schema, and no annotations, the description covers the tool's purpose, usage prerequisite, and parameter behavior adequately. It doesn't discuss return format or performance, but the parameter is well-described. The context is sufficient for an agent to use the tool correctly.

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

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

Schema description coverage is 100%, with a clear description for the single parameter. The tool description adds the context that summary_only=true returns 'user-created widgets only' and false returns 'full framework tree', which slightly amplifies the schema but doesn't add new meaning beyond what the schema already states. 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 states it gets the widget tree from a Flutter app, specifies the summary/full tree distinction, and mentions key details like type, properties, source location. However, it doesn't differentiate from similar tools like flutter_find_widget or flutter_get_widget_details, missing the opportunity to clarify when to use this over those.

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 indicates a prerequisite ('Call flutter_connect first'), which is helpful for usage. However, it does not specify when to use this tool vs alternatives, nor does it provide guidance on when not to use it. The context is clear but lacks exclusions or comparative advice.

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 explains that hot reload preserves app state (variables, navigation, scroll positions) and is faster than a full restart. However, it does not mention limitations like unsupported code changes (e.g., static fields) or potential side effects. No annotations are provided, but the description adds value beyond the name.

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

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

The description is three sentences, each adding value: purpose, state preservation advantage, and prerequisite. 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?

Given the tool's simplicity (no params, no output schema), the description covers essential aspects: what it does, its key benefit, and a prerequisite. It could mention unsupported code changes for completeness, but overall 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 tool has no parameters (schema coverage 100%), so the description's role is minimal. It adds no param info, but there are no params to describe. Baseline for 0 params is 4, and the description does not contradict this.

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 triggers a hot reload on a connected Flutter app. It specifies the verb 'trigger' and the resource 'hot reload', and distinguishes itself from sibling tools like flutter_hot_restart by emphasizing state preservation.

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 advises calling flutter_connect first, providing a prerequisite. It also implicitly suggests use when needing fast iteration, but does not explicitly state when not to use it (e.g., for full restart) or list alternatives.

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

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

The description explicitly states the behavioral trait: 'Restarts the app from scratch, losing all state'. No annotations are provided, so the description carries full burden; it fully discloses the destructive nature. No contradiction with missing 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 three sentences, each serving a distinct purpose: identifies the tool as Pro, explains behavior, and provides usage guidance. No redundancy or 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?

Given zero parameters, no output schema, and no annotations, the description covers the essential behavior and prerequisite completely. It tells the agent exactly what happens and when to use it. No gaps remain.

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

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

The input schema has no parameters (0), and schema description coverage is 100% (trivially, as there are no parameters to describe). The description adds meaning by explaining what the tool does, but since there are no params, the baseline is 4 as per guidelines.

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 triggers a hot restart on a connected Flutter app, and distinguishes it from hot reload by specifying it applies all code changes including static field initializers and global variables. However, the name already conveys the purpose, so no deduction for lack of differentiation from siblings beyond the explicit comparison to hot reload.

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 tells when to use (when hot reload is insufficient) and provides a prerequisite (call flutter_connect first). No sibling named with similar purpose among siblings (flutter_hot_reload is separate), so the alternative is clearly stated.

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

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

No annotations provided, so description carries full burden. It states the return format (PNG) but doesn't mention side effects, permissions, or rendering behavior. It's adequate but not thorough.

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?

Description is concise (one sentence) and front-loaded with key information. However, it could include more details without being verbose.

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 3 parameters, no output schema, and no annotations, the description is minimally complete. It explains what the tool does and the return type, but lacks details on error conditions or rendering context.

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

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

Schema coverage is 100%, so parameters are well-documented. The description adds no extra meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool takes a screenshot of a Flutter widget by valueId, returning a PNG image. However, among siblings like 'take_screenshot' and 'flutter_get_widget_details', the distinction is clear enough, but 'flutter_screenshot_widget' could be more unique.

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

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

The description implies when to use (to screenshot a widget), but no explicit guidance on when not to use or alternatives. With siblings like 'take_screenshot' and 'flutter_get_widget_details', the agent might need more context.

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

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

With no annotations provided, the description carries full burden. It states what the tool returns (package and activity name) but does not disclose any side effects, permissions needed, or edge cases (e.g., what happens on lock screen or if no app is foreground). It is minimally transparent.

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

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

The description is two sentences long, no wasted words. Front-loads the purpose and adds a brief usage context. Could be slightly improved by removing the generic 'useful for' phrase, but overall concise.

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 is simple (1 param, no output schema, no nested objects), the description is largely complete: it explains what is returned and a key use case. It lacks details about potential errors or permissions, but these are less critical for a read-only information retrieval tool.

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

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

Schema description coverage is 100% for the single parameter 'device_id' which is described as 'Device serial ID'. The description does not add any extra meaning beyond what the schema already provides, so 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 clearly states it gets the package name and activity name of the foreground app, which is a specific verb+resource. It distinguishes itself from sibling tools like 'get_device_info' or 'list_apps' by focusing on the current foreground app.

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

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

The description mentions it is useful for determining what the user is looking at, which implies when to use it, but does not provide explicit alternatives or conditions for other tools that might provide similar information (e.g., 'get_ui_elements' might also infer the current app). No exclusion criteria or when-not-to-use guidance.

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

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

With no annotations, the description provides basic behavioral information: it returns detailed device information. However, it does not disclose side effects (none expected for read), response format, or any potential delays. The description is adequate but lacks depth.

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, front-loaded with purpose, lists specific data items. 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?

Given low complexity (1 param, no output schema), the description is sufficiently complete. It covers what data is returned, matching the tool's purpose. Missing details like error handling or response format are minor for a simple info tool.

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

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

Schema coverage is 100% with one parameter, but the description does not add meaning beyond the schema's description 'Device serial ID'. Since coverage is high, baseline is 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 'Get' and the resource 'device info', listing specific details like model, manufacturer, Android version, etc. It distinguishes itself from sibling tools like 'list_devices' and 'get_screen_size' by focusing on a single device's comprehensive details.

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 that this tool is used to retrieve information for a specific device identified by device_id, but it does not explicitly state when to use it versus alternatives like list_devices or when not to use it. No context about prerequisites or related tools is provided.

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

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

No annotations provided, so the description carries full burden. It describes the output format and filtering options but does not disclose potential behavioral traits like rate limits, performance impact, or permission requirements. The description is accurate but lacks depth.

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: first states purpose, second covers filtering and output. Efficient and front-loaded, but could be more concise by removing redundancy (e.g., 'Retrieve recent Android logcat entries' vs 'from the device').

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 adequately describes return format. However, it lacks guidance on the number of returned entries, error handling, or logcat command equivalency. Still, it is sufficient for basic use.

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 four parameters. The description adds meaning by explaining the log level mapping (V=Verbose, etc.) and tag filter usage, but does not go beyond confirming the schema's details. Baseline 3 plus extra context for the level enum explanation.

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 retrieves recent Android logcat entries, specifying the source (Android device) and output format (structured JSON with timestamp, PID, TID, level, tag, message). It distinguishes from sibling tools like get_device_info or get_ui_elements.

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

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

The description implies usage for debugging or log analysis but does not explicitly state when to use this tool vs. alternatives like extract_text or find_element. No exclusionary guidance is provided.

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

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

No annotations are provided, so the description carries the full burden. It states the tool is non-destructive ('without stopping'), which is a positive behavioral hint. However, it does not disclose other behaviors such as whether it returns data or how it handles empty recordings.

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

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

The description is one short sentence with a 'useful for' clarification. Every word earns its place, and it is highly efficient.

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

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

Given the tool is simple (no parameters, no output schema), the description is adequate for basic use. However, it lacks context on what the 'recorded actions' are (e.g., format, scope) and how to interpret the output.

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 parameter semantics are not applicable. Schema description coverage is 100% (none needed). The description adds no parameter info but does not need to.

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

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

The description clearly states the action: 'view the actions recorded so far without stopping the recording.' It identifies the tool as a read operation for inspecting captured actions. However, it does not differentiate from siblings like 'start_test_recording' or 'stop_test_recording' beyond the 'without stopping' mention.

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 it is used during an active recording to inspect captured actions, but it does not explicitly state when to use this vs. alternatives like 'stop_test_recording' or 'start_test_recording'. It lacks guidance on prerequisites (e.g., must have an active recording) or when not to use it.

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

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

No annotations are provided, so the description must handle behavioral disclosure. It clarifies the output (width and height in pixels) but does not mention if the device must be connected or any potential errors (e.g., device not found). The mutability aspect is clear: it's a read operation.

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

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

The description is very concise: two sentences that clearly state purpose and output. 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?

The description is complete for a simple read tool with one parameter and no output schema. It explains the purpose and return values. Could mention error conditions (e.g., device not connected) but overall sufficient.

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

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

Schema description coverage is 100% (device_id documented). The description does not add additional meaning beyond the schema, which is fine when coverage is high. 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 uses specific verb+resource: 'Get the screen resolution of a connected Android device. Returns the width and height in pixels.' It clearly states what it does and distinguishes from siblings like take_screenshot or analyze_screen.

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

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

The description states when to use it (to get screen resolution), but provides no guidance on when not to use it or alternatives. Siblings like analyze_screen could be related but no exclusions are 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?

No annotations provided, so description carries full burden. It describes that 'By default only interactive elements are returned' and that setting interactive_only to false gets all elements. It doesn't disclose performance characteristics, caching, or side effects, which are minor gaps for a read 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?

Four sentences, each adding essential information: purpose, data fields, default behavior, and usage guidance. No filler words. Front-loaded with 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 retrieval tool with no output schema and no annotations, the description adequately covers what data is returned (fields enumerated) and how to control filtering. It is complete enough given the tool's complexity. Slight deduction for not mentioning performance or rate limits.

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 baseline is 3. The description adds value beyond schema by explaining the default behavior of interactive_only and its purpose (returning interactive elements vs all). This lifts the score to 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 'Retrieve the current UI element tree from the device screen' with specific verb 'Retrieve' and resource 'UI element tree'. It distinguishes itself from siblings like 'tap' and 'take_screenshot' by explicitly positioning as 'the primary tool for understanding what is on screen and deciding where to tap.'

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

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

The description provides context on when to use it: 'primary tool for understanding what is on screen and deciding where to tap.' However, it does not explicitly state when not to use it or mention alternatives among siblings (e.g., 'analyze_screen' or 'find_element'), missing explicit contrast.

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 explains the behavior of each action (dismiss declines/skips, accept allows/confirms, auto handles automatically). However, no annotations are present, so description carries full burden. Could better explain how 'auto' decides.

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?

Description is two sentences, concise and front-loaded. Every sentence contributes useful information. Could be slightly more structured with bullet points for actions, but overall efficient.

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

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

Given the tool's simplicity (two params, no output schema), the description is adequate. It explains the tool's purpose, the actions, and common use cases. However, it could mention what happens if no popup is detected.

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 description adds little beyond what schema provides. The description does list the actions and their meanings, which reinforces but doesn't significantly extend schema info.

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?

Tool description clearly states it 'detects and handles system dialogs and popups' with specific examples of dialog types. The action parameter is well-explained with three options. However, the title includes '[Pro]' which adds ambiguity about tool availability.

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?

Description implicitly explains when to use the tool (when popups appear) and what the actions do, but does not explicitly contrast with sibling tools. No mention of prerequisites or when not to use.

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 mentions the Pro version tag, which indicates licensing requirements not covered by annotations (which are absent). It also states that the APK is pushed to the device, disclosing a multi-step behavior beyond the schema. For a tool with no annotations, this is fairly transparent.

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

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

The description is concise with three sentences. The first sentence gives the main purpose, the second adds a requirement (full path), and the third explains the process. It is front-loaded and efficient, though it could be slightly more structured (e.g., bullet points).

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 2 parameters, 100% schema coverage, no output schema, and no annotations, the description covers the key aspects: purpose, required parameter detail, and process steps. It is missing return value information (e.g., success/failure output), but the tool seems straightforward. Completeness is high given the 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 has 100% description coverage for both parameters, but the description adds value by explaining that 'apk_path' must be a full path to the APK file and that the APK will be pushed to the device. However, it doesn't provide additional semantics beyond what the schema already covers, so a score of 3 is appropriate per guidelines.

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 installs an Android app from an APK file, specifying that it requires the full path to the .apk file and will push the file to the device. This uniquely distinguishes it from sibling tools like 'launch_app' (which launches an installed app) and 'uninstall_app'.

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

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

The description explains that the APK will be pushed to the device, which implicitly guides the user that the file must be on the host machine. However, it does not explicitly state when not to use this tool or mention alternatives, such as using 'launch_app' for apps already installed. Sibling names provide context but are not referenced.

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

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

No annotations are provided, so the description carries full burden. It indicates this is a boot (startup) operation and notes it's a Pro feature, but doesn't mention side effects (e.g., if the simulator is already booted) or permissions needed. Adequate but minimal.

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

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

Two short, front-loaded sentences. Every sentence serves a purpose: one states the action and requirement, the other provides the source for the required data. No fluff.

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

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

Given the tool is simple (one required parameter, no output schema, no nested objects), the description is complete. It tells what to do and where to get the identifier. Could mention if it fails silently or requires a simulator to be created first, but for a straightforward boot operation it's sufficient.

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

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

Schema description coverage is 100% (one parameter 'device_id' described as 'Simulator UDID'). The description adds context that the UDID comes from ios_list_simulators, which links to a sibling tool, but doesn't add meaning beyond what the schema provides. Baseline 3 stands.

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?

Clearly states the specific action (boot an iOS simulator) and the required resource (by UDID). Distinguishes itself from sibling tools like ios_shutdown_simulator by the action and uses '[Pro]' to indicate a pro feature.

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 instructs to get the UDID from another tool (ios_list_simulators), providing a clear prerequisite. No explicit when-not-to-use guidance, but it's implied to be used after listing simulators.

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

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

No annotations provided, so description must convey all behavioral traits. States 'Works on macOS only', which is important context. No mention of side effects or permissions, but as a read-only list, no major hidden behaviors.

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

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

Single sentence with key details: purpose, output fields, platform constraint. 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?

Zero parameters and no output schema, so description need not explain return format. Covers platform restriction and output fields. Slightly missing mention of error conditions (e.g., no Xcode installed), but adequate for a simple list tool.

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

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

Input schema has zero parameters and 100% coverage. Description adds no parameter info because none exist, but the schema is empty, so baseline is 4 for clarity that no inputs needed.

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

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

Description states 'List all available iOS simulators' with details like status, UDID, name, and iOS version. Clearly a list tool, distinct from siblings like ios_boot_simulator or ios_shutdown_simulator.

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 explicit when-to-use or when-not-to-use guidance. Implicitly useful for inspecting simulators before booting or shutting down, but doesn't mention alternatives.

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

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

No annotations are provided, so the description must shoulder the behavioral disclosure burden. It correctly states the tool is read-only (screenshot) and identifies the output format (base64). However, it does not mention potential side effects (none expected), authorization requirements, or performance characteristics. For a non-destructive tool, this is adequate but minimal.

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 (two clauses) with no fluff. It front-loads the core purpose: '[Pro] Take a screenshot of a running iOS simulator.' and completes with return info. Every part is necessary and efficient.

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

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

Given there is no output schema and no annotations, the description provides the essential information: purpose, target (simulator), and return format (base64). It does not explain the output schema or potential errors, but for a simple screenshot tool with two well-described parameters, this suffices. Lacks mention of the need for a booted simulator, but that is implied by 'running iOS simulator'.

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 parameters have descriptions). The description does not add extra meaning beyond 'device_id' (Simulator UDID) and 'format' (png/jpeg default png), but the schema already provides this clearly. According to rules, baseline is 3 since coverage is high and description does not add new info.

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

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

The description explicitly states 'Take a screenshot of a running iOS simulator' with a specific verb ('Take') and resource ('screenshot of iOS simulator'). It also mentions the return format ('Returns the image as base64'), which distinguishes it from other screenshot tools like 'take_screenshot' (likely for device) and 'flutter_screenshot_widget' (Flutter-specific). The '[Pro]' tag is cosmetic but does not detract.

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 screenshot of an iOS simulator is needed, but does not explicitly state when to use this tool versus alternatives like 'take_screenshot' (for device) or 'flutter_screenshot_widget'. It also lacks prerequisites (e.g., simulator must be booted) or exclusions. Given the sibling context, some differentiation is implied but not articulated.

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

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

No annotations are provided, so the description carries the full burden. It states that the simulator must be 'running' (a constraint), but does not disclose whether the operation is safe or destructive, or any side effects (e.g., unsaved data loss). The description adds minimal behavioral context beyond the action itself.

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

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

The description is a single sentence of 9 words, conveying essential information without extraneous text. It is front-loaded with the action and resource, and efficiently uses parentheses for the UDID specification.

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

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

The tool is simple with one required parameter and no output schema, so the description is mostly complete. However, it lacks mention of error cases (e.g., simulator not found) or behavioral details like safe shutdown vs force kill. Given the simplicity, a 3 is appropriate.

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

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

Schema coverage is 100% with one parameter 'device_id' described as 'Simulator UDID'. The description names the parameter ('by its UDID') and its purpose, aligning with the schema. It provides enough context for selecting the correct parameter value.

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

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

The description clearly states the action ('Shutdown'), the resource ('running iOS simulator'), and the identifier ('by its UDID'). It distinguishes the tool from siblings like ios_boot_simulator and ios_list_simulators, though it could be more specific.

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 a simulator is running and needs to be shut down, but provides no guidance on when not to use it (e.g., if simulator is already off) or alternatives. Since there is a sibling ios_boot_simulator, the description could clarify that this tool is for shutdown only.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions the app starts with its default/main activity, but does not disclose potential side effects (e.g., if the app is already running, it may be brought to foreground) or permissions needed. It does not state that the app must be installed, so this is adequate but not comprehensive.

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

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

The description is two clear sentences with zero waste. It front-loads the purpose and provides an example and alternative tool reference efficiently.

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

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

Given the tool has 2 required parameters, no output schema, and no annotations, the description adequately covers the purpose, usage, and parameter hint. However, it could mention that the app must be installed or the result of a successful launch (e.g., app opened or error). The existence of sibling tools like stop_app and install_app adds context, but the description is still fairly complete.

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

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

Schema description coverage is 100% (both parameters are described in the schema), so baseline is 3. The description adds value by explaining the purpose of package_name and giving an example, but does not add extra meaning beyond the schema for device_id.

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

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

The description specifies the exact verb (launch), resource (installed application by package name), and scope (default/main activity). It distinguishes itself from siblings like list_apps, stop_app, and install_app by stating that it launches an app by package name.

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

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

The description explicitly tells when to use this tool ('Launch an installed application'), and provides a clear alternative for discovering package names ('Use list_apps to discover available package names'). It also gives an example ('com.android.chrome') for clarity.

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?

Describes default filtering behavior and content of each entry. With no annotations, the description fulfills the burden adequately, though could note if there are permissions or timeout considerations.

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

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

Three sentences providing purpose, default behavior, optional parameter, and output content. No wasted words, front-loaded with primary function.

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?

Covers purpose, parameters, and output format despite no output schema. Could be slightly more complete by mentioning if the list is sorted or includes package names only.

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 described in the input schema, and the description adds context about default behavior for include_system and the device_id implicitly. With 100% schema coverage, baseline is 3; the description adds value with behavior 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?

Clearly states it lists installed applications on a device, distinguishes default behavior (user-installed only) and notes optional inclusion of system apps. Differentiates from sibling tools like install_app, uninstall_app, and launch_app.

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

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

Explains when to use the include_system parameter. However, no explicit mention of when not to use this tool or alternatives for other device-related queries.

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

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

No annotations are provided, so the description carries the full burden. It clearly indicates the tool is a read operation (lists devices) and describes the output content (id, model, etc.). It does not mention any side effects, permissions, or error cases (e.g., what happens if no devices are connected), but for a simple list operation, the level of detail is sufficient. A 4 reflects that the description adds value beyond a bare statement like 'List devices'.

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 long: the first states the action and scope, the second details the return value. No extraneous words, front-loaded with the core purpose. It is admirably concise while still being informative.

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

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

Given that the tool has zero parameters and no output schema, the description fully explains what the tool does and what it returns. It does not mention edge cases (e.g., no devices connected) or performance implications, but for a simple list operation, these are not essential. The lack of annotations is compensated by the clarity of the description. Score 4 because it is complete enough for reliable use, but could add notes on expected behavior when the list is empty.

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

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

The tool has zero parameters, so the dimension shifts to 'no parameters needed.' The description does not need to explain parameters. According to the guidelines, 0 params = baseline 4. The description does not add parameter information (none needed), and the schema coverage is 100%, so no penalty.

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 action ('list'), the resource ('connected Android devices and emulators'), and even enumerates the fields returned (id, model, manufacturer, etc.). This uniquely identifies the tool's purpose and distinguishes it from siblings like get_device_info (which likely returns details for a single device) and list_apps (which lists apps).

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

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

The description explicitly mentions the scope ('all connected Android devices and emulators') and the return structure. However, it does not specify when to use this tool versus alternatives (e.g., get_device_info for a specific device), nor any prerequisites (e.g., that the server must be running). The absence of guidelines is mitigated by the fact that the tool has no parameters and a well-defined output, making it straightforward.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool performs a long press which can trigger context menus, drags, or secondary actions, but does not mention any side effects, prerequisites (e.g., element must be present), or system behavior. It does not contradict annotations (none given).

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 (two sentences) and front-loaded with the action. It efficiently conveys purpose and common use cases without waste.

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

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

Given the tool is a simple gesture with parameters fully described in schema, the description is adequate. However, it lacks information about return values, error conditions, or system behavior, which would be helpful for completeness.

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 baseline is 3. The description does not add parameter-level details beyond the schema. It mentions coordinates and duration in the context of use cases, but the schema already documents them adequately.

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

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

The description explicitly states the tool performs a 'long press (touch and hold)' at given coordinates, with clear purpose: opening context menus, starting drag operations, or triggering secondary actions. The verb 'Perform a long press' and resource 'screen coordinates' are specific, and the examples distinguish it from other gestures like double_tap or swipe.

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 mentions common use cases but does not explicitly state when to use this tool versus siblings like tap, double_tap, or swipe. It implies usage through examples but lacks clear guidance on when not to use it or alternatives.

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

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

Description accurately describes pressing a key, listing many specific keys. No annotations exist, so description carries full burden. Provides good detail without contradiction.

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

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

Two sentences: first states purpose, second lists accepted formats. No wasted words. Could be slightly shorter but effective.

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 simplicity (2 required params, no output schema) and informative sibling context, description covers essentials. No need for additional details like return value or error cases.

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 baseline is 3. Description adds example values for 'key' parameter but no new semantics beyond what schema description 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?

Description clearly states it presses a hardware/system key. Lists many friendly names and raw keycode option. Distinct from sibling tools like tap, double_tap, long_press which are touch-based, and type_text which inputs text characters.

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?

Description explains accepted key formats (friendly names or raw keycode). Does not explicitly say when to use vs alternatives, but given sibling names, context is clear.

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

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

No annotations provided, so description carries full burden. Discloses format (MP4), limits (3-min Android, one at a time), and required complementary action (call stop_recording).

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

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

Three concise sentences with no wasted words. Each sentence adds distinct value: purpose, constraints, follow-up action.

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?

Covers key behavioral aspects for a screen recording tool. No output schema, but return is implied (saved video). Could mention whether resolution is required or optional.

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 baseline is 3. Description adds context: max_duration is capped at 180, bit_rate default is 20Mbps, resolution example format. Small added value.

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

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

Clearly states it records device screen as MP4 video. Distinguishes from sibling tools like take_screenshot (static image) and stop_recording (ends recording).

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 mentions Android has a 3-minute maximum and only one recording per device. Does not specify when to use alternatives like record_screen vs. other recording 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?

Correctly describes the tool's behavior (finds element, taps its center) and return value (success flag and element tapped). With no annotations, it carries the full burden and does so well.

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

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

Three sentences covering purpose, combined nature, example, and return value. Concise and well-structured.

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

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

Given 2 simple parameters, no output schema, and no annotations, the description adequately explains the tool's behavior: finds and taps via natural language, returns success info. Minor gap: doesn't explain failure behavior or limitations (e.g., if element not found).

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 already covers both parameters with descriptions, so baseline is 3. The description provides a useful example mapping parameter to use but doesn't add additional semantics beyond what the schema and example provide.

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?

Clearly states it uses natural language to find and tap a UI element, combining two actions into one. The example makes the purpose concrete and distinct from siblings like 'find_element' or 'tap'.

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

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

Provides an example with typical usage ('the Sign In button'), implying when to use it (when element description is known). However, it doesn't explicitly differentiate from alternatives like 'tap' or 'find_element' combined with 'tap', nor suggest when not to use it.

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

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

With no annotations, the description adds value by stating the sequence of actions (find, tap, type) and that it uses natural language input. However, it doesn't disclose error handling, what happens if field not found, or auth requirements.

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

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

Two sentences: one for purpose and an illustrative example. Zero wasted words. Front-loaded with key 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?

Given 3 required params, no output schema, and moderate complexity with natural language processing, the description covers the basic use case but omits details like supported field types or multi-device considerations.

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 baseline is 3. The description adds a practical example and explains the 'field_description' parameter, but doesn't add deeper semantics 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 finds a field by natural language, taps it, and types text, distinguishing from type_text (which likely requires a locator) and smart_tap (tap only). The example reinforces the verb+resource pattern.

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

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

The description implies use when you want to type into a field described by natural language, but doesn't explicitly contrast with siblings like type_text or find_element. No when-not-to-use guidance is provided.

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

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

Description notes that tool calls are logged until stop_test_recording is called, which is a key behavioral trait beyond the input schema. Since annotations are missing, the description carries the burden; it sufficiently indicates it starts a recording session, but could mention that it persists across calls or that calls are stored.

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 that effectively conveys purpose and usage with no wasted words. It is front-loaded with the key action and context.

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

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

For a tool with one optional parameter and no output schema, the description is sufficiently complete. It explains the tool's role in a test recording workflow and mentions the lifecycle (until stop_test_recording). Could note what happens if a test already exists, but overall 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 has 100% coverage with a single parameter 'test_name' described as 'Name for the test (used in generated code)'. The description adds no additional param info, but given full schema coverage, the baseline of 3 is exceeded because the description's context about generating a test script adds meaning to the parameter's purpose.

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

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

The description clearly states the tool starts recording MCP tool calls to generate a reproducible test script, which is a specific verb+resource combination. It distinguishes from sibling tools like 'stop_test_recording' and 'get_recorded_actions' by noting that subsequent calls are logged until stopped.

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

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

The description explicitly says to use when you want to generate a test script and that it logs subsequent calls until 'stop_test_recording' is called, providing clear context. It does not explicitly state when not to use it or mention alternatives, but the sibling tools list includes related ones.

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 clearly states the behavior: 'immediately terminates the app process.' This goes beyond the input schema to explain the effect (brutal vs graceful stop). With no annotations, the description carries the full burden and does well. It could mention that the app might crash or lose unsaved data, but it already signals destructiveHint=false implicitly.

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

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

Two sentences, no fluff. The critical info (force-stop, package name, effect) is front-loaded. Every sentence adds value.

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

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

Given the tool has only two simple parameters, no output schema, and no annotations, the description covers the core behavior and use case. It could mention return value (vs output) or side effects in more detail, but for a straightforward force-stop, it is sufficient.

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

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

Schema coverage is 100% (both parameters described in schema). The description adds no extra detail about 'device_id' or 'package_name' beyond the schema. Since both are self-explanatory and schema covers them, baseline 3 is appropriate.

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

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

The description states a specific verb ('force-stop'), resource ('running application'), and scope ('by its package name'). It distinguishes from siblings like 'launch_app' or 'close_app' by being explicit about force-stopping; although 'stop_test_recording' is different, the description clearly targets app process termination, which differentiates it from other device control 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 gives a use case ('resetting app state or freeing resources'), which implies when to use it. However, it does not explicitly mention when not to use it or provide alternative tools (e.g., 'close_app' or 'uninstall_app'). No explicit guidance on prerequisites like device ownership or permissions.

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

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

With no annotations, the description must disclose behavioral traits. It states the tool stops a recording and optionally pulls the file, but doesn't specify what happens if no recording is active, or if the pull overwrites files. It adds some context beyond the schema but lacks 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?

Two sentences, no redundant words. Front-loaded with the main action.

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

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

With no output schema and no annotations, the description should cover return values and side effects. It's simple enough that stopping and optionally pulling is clear, but it could mention what happens on success (file path?) or if no recording exists.

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

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

Schema coverage is 100%, so the schema already describes both parameters. The description adds that pull_to_path is optional and for saving locally, which is slightly beyond schema description, but not substantial. 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 states the action (stop recording, save video) and resource (active screen recording). It distinguishes from sibling tools like record_screen and start_test_recording by mentioning 'save the MP4 video' and optionally pulling the 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 usage when a recording is active and you want to save it, but provides no explicit when-not-to-use or alternatives. For example, it doesn't mention that there's a start_test_recording sibling for test recordings.

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?

Discloses that it stops recording and generates a test script, along with supported output formats. However, no annotations are provided, so the description partially fills the gap but could mention whether the recording is deleted or if the script is returned directly.

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 that efficiently conveys the tool's purpose, action, and output formats. No unnecessary 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?

Given only one parameter, no output schema, and no annotations, the description adequately explains the tool's function. It could mention output details (e.g., whether the script is saved or returned) for full completeness.

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 enum values. Description adds context by specifying the parameter's purpose (output format) and listing the allowed values (TypeScript, Python, JSON) which the schema already provides. Still a clear explanation.

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?

Clearly states the action (stop recording and generate a test script) and the specific resource (recorded actions). Distinguishes from siblings like stop_recording and start_test_recording by calling out generation of a test script with output formats.

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?

Implies usage context (after starting a recording) but does not explicitly state when to use this tool vs alternatives. For example, it doesn't differentiate from stop_recording which also stops recording but may not generate a script.

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

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

No annotations are provided, so the description must disclose behavioral traits. It indicates the tool returns coordinates and step-by-step instructions, but does not mention required permissions, potential delays, or whether it can handle complex goals. Without annotations, a score of 3 is appropriate for moderate disclosure.

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

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

The description is concise with two sentences and examples, avoiding unnecessary detail. The '[Pro]' tag and examples are useful. Slightly lower than 5 because it could be even more succinct without losing clarity.

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 only 2 parameters and no output schema or nested objects, the description covers the core purpose and provides examples. It explains what the tool returns, which is sufficient for a simple tool. However, lacking usage guidance prevents 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?

Both parameters are fully described in the schema (100% coverage). The description re-emphasizes 'goal' with examples but does not add new meaning beyond the schema. The baseline is 3, which is fitting.

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

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

The description clearly states it uses AI to analyze the screen and suggest actions for a goal, providing step-by-step instructions. It includes example goals, which adds clarity. However, it doesn't explicitly differentiate from siblings like 'analyze_screen' or 'fill_form' which might handle similar tasks.

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 suggests use cases via examples but does not specify when not to use this tool or mention alternative tools. It implies usage for high-level goals but lacks guidance on limitations or when other tools might be more appropriate.

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

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

With no annotations, the description carries the full burden. It reveals that shorter durations result in faster swipes and longer in slower drags, which is helpful. However, it does not mention whether the swipe is instantaneous or if there are any side effects (e.g., triggering scroll inertia). It also does not specify coordinate system origin or bounds.

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, each adding value: first states action and coordinates, second lists use cases and explains duration effect. No filler or repetition.

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

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

Given the tool's simplicity (swipe gesture) and that input schema covers all parameters with descriptions, the description is quite complete. It covers purpose, usage scenarios, and behavioral nuance of duration. A small gap is the lack of coordinate origin clarification, but overall it is sufficient for an agent to use 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%, and each parameter has a clear description in the schema. The description adds a note about duration affecting speed, which is already implied by the default and schema description but adds context. However, it does not elaborate on coordinate expectations (e.g., origin at top-left) or provide typical values beyond duration.

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 performs a swipe gesture between two coordinates. It lists common use cases (scrolling, dismissing notifications, navigating pages, pulling down notification shade), but does not explicitly distinguish it from sibling tools like scroll or drag. However, other sibling names (tap, long_press, double_tap) are distinct enough, so purpose is clear.

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

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

The description explicitly states when to use the tool: 'to scroll through lists, dismiss notifications, navigate between pages, or pull down the notification shade.' It also explains the effect of the duration parameter (flick vs drag). However, it does not mention when not to use it or alternatives among sibling tools.

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

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

The description discloses that the tool returns image with metadata and explains the trade-offs between PNG and JPEG formats. Since annotations are absent, the description carries the full burden. It does not mention any potential side effects or performance impacts.

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

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

The description is extremely concise with only three sentences, no filler words, and front-loaded with the core purpose. Every sentence adds value.

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

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

The description lacks details about return format (the schema has no output schema), but given the tool's simplicity and rich parameter descriptions, it is nearly complete. No mention of potential errors or performance impacts.

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

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

The description adds significant meaning beyond the schema by explaining the purpose of each parameter (e.g., quality reduces file size, max_width resizes to reduce file size). Schema coverage is 100%, but the description provides high-level guidance.

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

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

The description clearly states what the tool does (capture a screenshot of the device screen) and what it returns (image with metadata). It also distinguishes between PNG and JPEG formats, giving specific guidance for AI analysis use cases.

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 advises when to use certain parameters (e.g., format='jpeg' for reducing file size for AI analysis), but does not explicitly mention when not to use this tool or compare it with sibling tools like 'record_screen' or 'verify_screen'.

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

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

With no annotations, the description carries the full burden. It states the action is a single tap and coordinates are in pixels, but does not disclose any potential side effects, timing, or constraints (e.g., failure if element is not visible).

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

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

The description is two sentences, front-loaded with the action, and every sentence adds value. No unnecessary 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?

Given the simple tool (3 parameters, no output schema), the description sufficiently explains what it does and how to use it. However, missing information about return value (success/failure) or error handling keeps it from being complete.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds meaning by explaining the coordinate usage (centerX/centerY from get_ui_elements), which is a notable addition 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 performs a single tap at given screen coordinates. It specifies the action (perform a single tap) and the resource (screen coordinates), distinguishing it from siblings like double_tap or long_press.

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 advises to use get_ui_elements first to find coordinates, providing clear context for when to use this tool. It implies the tool is for tapping a specific element, not for arbitrary coordinate tapping.

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 mentions support for special characters and Unicode, which is useful behavioral context. However, it does not disclose any potential side effects (e.g., what happens if no input field is focused, or if the text is too long). Given no annotations are provided, the description carries the burden, and it partially fulfills it.

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 long, with no wasted words. It front-loads the core action and adds necessary prerequisite in the second 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?

Given the tool has only 2 parameters with full schema coverage and no output schema, the description provides the essential prerequisite and feature support. It is mostly complete for a simple input action, though it could mention error behavior or limitations.

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 both parameters with descriptions ('Device serial ID' and 'Text to type on the device'), achieving 100% coverage. The description does not add meaningful semantics beyond what the schema already provides, 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 clearly states the verb 'Type text' and the resource 'currently focused input field', distinguishing it from sibling tools like 'press_key' (types keys rather than text) and 'smart_type' (likely types intelligently). It is specific and unambiguous.

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

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

The description explicitly instructs the agent to make sure an input field is focused first (tap on it), which is a crucial prerequisite. This provides clear guidance on when to use this tool and the necessary precondition.

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 clearly discloses that the tool removes the app and all its data, which is critical behavioral information. It also warns about system apps requiring root access. Without annotations, the description carries the burden; it meets it well.

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 (two sentences) and front-loaded with the core purpose. It wastes no words, though the '[Pro]' prefix is minor noise. Still, every sentence adds value.

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

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

Given the tool's simplicity (2 parameters, no output schema, no nested objects), the description is adequate. It covers purpose, effect, and a key limitation (system apps). No major gaps are present.

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

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

Schema description coverage is 100%, with 'device_id' and 'package_name' clearly documented. The description adds context about 'package name' but does not provide additional semantics beyond the schema; baseline 3 is appropriate.

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

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

The description uses specific verbs ('uninstall', 'removes') and clearly identifies the resource (application by package name). It distinguishes this tool from siblings like 'stop_app' or 'install_app' by focusing on removal and data deletion.

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 implicitly states when to use (to uninstall an app) and explicitly notes a limitation: system apps cannot be uninstalled without root access. However, it does not explicitly mention when not to use or compare with alternative tools like 'stop_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?

Discloses that AI is used, returns boolean with confidence and evidence. With no annotations provided, description carries full burden; however, it lacks details like potential latency, need for device connectivity, or that verification may fail for ambiguous assertions.

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?

Concise at two sentences, plus examples. Title includes '[Pro]' which adds context. No waste, but could be slightly more structured (e.g., bulleted list).

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, description hints at output (boolean, confidence, evidence) but doesn't specify types or structure. With 2 params and straightforward purpose, description is minimally adequate but would benefit from more detail on return values and error cases.

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 already has 100% coverage with descriptions for both 'device_id' and 'assertion'. Description adds example assertions but doesn't add significant meaning beyond schema. Baseline 3 is appropriate.

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

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

Description clearly states the tool verifies assertions about the current screen using AI, returns a boolean with confidence and evidence. It distinguishes from siblings like 'analyze_screen' (which likely does generic analysis) by focusing on specific assertion verification.

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

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

Provides example assertions to suggest use cases, but does not explicitly state when not to use it or alternatives. For instance, no mention that for simple element existence one might use 'find_element' instead.

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

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

No annotations provided, so description carries full burden. Discloses Pro feature, input format (base64 PNG), behavior (captures current screen as after), and output (list of changes with descriptions and regions). Fully transparent without contradiction.

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

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

Two sentences, front-loaded with purpose and key details. No waste.

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

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

Given 2 params, no output schema, and no annotations, description covers everything needed: what it does, how to use it, input format, output format. No gaps.

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

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

Schema coverage is 100%, description adds value by explaining usage context: before_screenshot is base64 PNG of previous screen state, and tool captures current screen automatically. Goes beyond schema descriptions by clarifying the 'after' image is captured by the tool.

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

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

Clearly states it compares current screen with a previous screenshot to identify what changed. Provides specific verb 'compares' and resource 'screenshot', and distinguishes from siblings like take_screenshot and verify_screen by focusing on diffing.

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

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

Explicitly says to provide a base64 PNG screenshot as the 'before' image, and that the tool captures the current screen as the 'after' image. Also includes 'Useful for verifying that an action had the expected effect', giving clear context for when to use.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains the polling mechanism and that it returns upon detection, but does not mention what happens on timeout (likely returns an error or null), resource implications, or whether it modifies state. With no annotations, a 3 is appropriate as it covers core behavior but leaves some uncertainty.

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 sentences, each serving a purpose: states functionality, compares with sibling, and gives usage example with example. No filler or tautology.

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 moderate complexity (4 parameters, no output schema, no annotations), the description adequately covers purpose, usage, and a basic example. It does not detail error handling or return value, but the example helps. With 4 parameters and 100% schema coverage, the description is sufficiently complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter meaning beyond what the schema already states, except for an example usage that illustrates how query might be used. This does not significantly augment understanding.

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

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

The description clearly states the tool waits for a UI element to appear by polling the UI tree, with a specific verb ('waits for') and resource ('UI element'). It distinguishes from the sibling tool wait_for_settle by noting it is 'more reliable and faster' and 'returns as soon as the target element is found'.

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 usage context: 'Use after navigation to wait for a specific button, text, or field to appear.' It also contrasts with wait_for_settle, but does not explicitly state when not to use this tool or list alternatives beyond that sibling.

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

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

No annotations are provided, so description fully handles transparency. It explains the polling mechanism: polling until two consecutive snapshots are identical. This discloses the behavioral trait of waiting for stability, which is valuable for an agent to understand potential time consumption.

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

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

Two sentences, no filler. The first sentence states the purpose, the second explains the mechanism and usage. Every sentence earns its place.

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

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

Given no output schema and annotations, the description is fairly complete. It explains what the tool does, how it works, and when to use it. A minor gap: the description does not mention what happens on timeout (e.g., error or return), but overall it's sufficient for an agent to use correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by explaining the purpose of timeout and poll_interval in context of polling, though the schema already describes them. The justification for these parameters is slightly enhanced by the behavioral context.

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

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

The description clearly states the tool waits for the UI to stop changing after navigation or action, which is a specific verb+resource purpose. It distinguishes from siblings like wait_for_element by specifying it waits for the entire screen to settle, not a particular element.

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

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

The description explicitly recommends use after tapping navigation buttons or screen transitions. It does not explicitly state when not to use it or alternatives, but the context of polling for identical snapshots implies it's for dynamic screen updates, which is clear enough.

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