MCP Appium Server

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. While 'Take a screenshot' implies a read operation, it doesn't specify whether this requires specific device states, what happens if the device is locked, whether it saves files locally or returns data, or any error conditions. The description is minimal and lacks important operational context.

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

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

The description is extremely concise with just 4 words that directly convey the core function. There's zero wasted language or unnecessary elaboration. It's front-loaded with the essential action and context in a single efficient statement.

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

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

For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns (file path, binary data, success status), doesn't mention dependencies on Appium session state, and doesn't differentiate from similar screenshot tools in the sibling list. The minimal description leaves too many operational questions unanswered.

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% description coverage with the 'name' parameter clearly documented as 'Base name for the screenshot file'. The description adds no additional parameter information beyond what the schema provides, which is acceptable given the high schema coverage. The baseline score of 3 reflects adequate but not enhanced parameter documentation.

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

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

The description 'Take a screenshot using Appium' clearly states the action (take) and resource (screenshot) with the technology context (Appium). However, it doesn't differentiate from the sibling tool 'take-screenshot' - the distinction between 'appium-screenshot' and 'take-screenshot' is unclear from this description alone.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'take-screenshot' or 'xcode_take_screenshot'. There's no mention of prerequisites, appropriate contexts, or comparison with sibling tools that perform similar functions.

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 mentions capturing 'all UI elements' but doesn't specify what 'capture' entails (e.g., does it return a list, save to memory, or require permissions?), potential side effects (e.g., performance impact), or error conditions. For a tool with 3 parameters and no annotations, this is insufficient.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and easy to parse, though it could be slightly more structured (e.g., by hinting at parameters) to enhance clarity without sacrificing brevity.

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

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

Given the complexity of a UI capture tool with 3 parameters, no annotations, and no output schema, the description is incomplete. It lacks details on behavior, output format, error handling, and differentiation from siblings. While concise, it doesn't provide enough context for an agent to use the tool effectively without guesswork.

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%, meaning all parameters are documented in the schema itself. The description adds no additional context about the parameters, such as default behaviors or interactions between them. Since the schema handles the heavy lifting, the baseline score of 3 is appropriate, though no extra value is provided.

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

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

The description clearly states the tool's purpose: 'Capture all UI elements and their locators for future use.' It specifies the verb ('capture'), resource ('UI elements and their locators'), and intended outcome ('for future use'). However, it doesn't explicitly differentiate from sibling tools like 'extract-locators' or 'generate-element-locators,' which appear to have related functionality, preventing a score of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'extract-locators' and 'generate-element-locators' present, there's no indication of scenarios where 'capture-ui-locators' is preferred, nor any mention of prerequisites or exclusions. This lack of context leaves usage ambiguous.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('clear text') but doesn't describe how it behaves: e.g., does it simulate user input or directly set value? Does it require the element to be focused? What happens on failure? For a mutation tool with zero annotation coverage, this is a significant gap in 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?

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and target, making it easy to scan. No unnecessary words or redundancy are present.

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 complexity of a UI automation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavior (e.g., error handling, interaction method), usage context (e.g., when to prefer this over other tools), and output (e.g., what's returned on success/failure). For a mutation tool in a rich sibling set, this is inadequate.

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 both parameters ('selector' and 'strategy') with descriptions. The description doesn't add any parameter-specific details beyond what's in the schema (e.g., examples of selectors, default behavior). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Clear text from an input element' states a clear action ('clear text') and target ('input element'), but it's somewhat vague about scope (e.g., does it clear all text or specific text?) and doesn't differentiate from sibling tools like 'send-keys' (which might input text) or 'tap-element' (which might focus an element). It avoids tautology but lacks specificity for a UI automation context.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., 'send-keys' with empty string, 'tap-element' to focus then clear, or other UI interaction tools). The description implies usage for clearing text but doesn't mention prerequisites (e.g., element must be interactable) or exclusions (e.g., not for non-input 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('close') but doesn't explain what 'close' entails—e.g., whether it gracefully terminates the app, leaves it in background, affects app state, or requires specific permissions. For a mutation tool with zero annotation coverage, this is insufficient.

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

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

The description is a single, clear sentence with zero waste—it directly states the tool's action and scope. It's front-loaded and appropriately sized for a simple tool with no parameters.

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 complexity (a mutation operation with no annotations and no output schema), the description is incomplete. It lacks details on behavior (e.g., what 'close' means, side effects), prerequisites (e.g., requires an active session), and output (e.g., success/failure indication). For a tool in a testing/automation context, this leaves critical gaps.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, which is appropriate. A baseline of 4 is given since the schema fully handles parameters, and the description doesn't need to compensate.

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 ('close') and target ('the app associated with the current Appium session'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'close-appium' (which likely closes the Appium server/session) or 'terminate-app' (which might force-quit an app), leaving room for ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., requires an active Appium session), exclusions (e.g., not for closing the Appium server itself), or comparisons to siblings like 'close-appium' or 'xcode_terminate_app'. This lack of context could lead to misuse.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Close' implies a destructive operation that terminates a session, but it doesn't specify whether this is reversible, what happens to associated resources, or if there are side effects like losing connection to the device. For a session management tool with zero annotation coverage, this is inadequate.

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, direct sentence with no wasted words. It's front-loaded with the core action and target, making it immediately understandable without unnecessary elaboration.

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

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

For a session management tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'close' entails behaviorally, what happens after closure, or what (if anything) is returned. Given the complexity of managing Appium sessions and the lack of structured documentation, more context is needed.

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 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description doesn't need to add parameter information, and it correctly doesn't mention any parameters. Baseline 4 is appropriate 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?

The description clearly states the action ('Close') and target ('current Appium driver session'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'close-app' or 'xcode_shutdown_simulator', which might have overlapping purposes in the Appium testing context.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'close-app' or 'xcode_shutdown_simulator'. It doesn't mention prerequisites (e.g., requires an active Appium session) or consequences of closing the session versus other termination methods.

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 but only states the basic function. It doesn't disclose behavioral traits like whether this is a read-only operation (implied but not stated), if it returns a boolean or detailed result, error handling (e.g., invalid selector), performance characteristics, or dependencies (e.g., requires Appium session). For a tool with zero annotation coverage, this is insufficient.

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, direct sentence with zero wasted words. It's front-loaded with the core purpose and efficiently communicates the essential action. Every word earns its place, making it highly scannable and easy to parse.

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

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

Given the tool's moderate complexity (checking element existence in a UI automation context), no annotations, no output schema, and rich sibling tools, the description is incomplete. It lacks context on return values (e.g., boolean vs. element details), error conditions, typical workflows, and differentiation from similar tools. This leaves significant gaps for effective agent 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%, with both parameters ('selector' and 'strategy') well-documented in the schema. The description adds no parameter-specific information beyond what the schema provides, such as examples of common selectors or when to choose different strategies. This meets the baseline for high schema coverage but doesn't enhance 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 verb ('Check if') and resource ('an element exists on the current page'), making the purpose immediately understandable. It doesn't explicitly differentiate from siblings like 'find-by-text' or 'wait-for-element', but the checking vs. finding distinction is somewhat implied. This is clear but lacks explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'find-by-text', 'wait-for-element', or 'inspect-element'. It doesn't mention prerequisites (e.g., requires an active page/session) or typical use cases (e.g., validation before interaction). This leaves the agent with minimal context for tool selection.

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

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

No annotations are provided, so the description carries the full burden. It mentions execution but does not disclose behavioral traits like required permissions, potential side effects (e.g., device changes), error handling, or output format. This is inadequate for a tool that likely interacts with device systems.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded and clear, though it could benefit from more detail given the tool's complexity.

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 potential complexity (executing arbitrary ADB commands), lack of annotations, no output schema, and incomplete behavioral disclosure, the description is insufficient. It does not provide enough context for safe or effective use, such as command examples, safety warnings, or expected results.

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 the parameter 'command' documented as 'The ADB command to execute (without 'adb' prefix).' The description adds no additional meaning beyond this, such as examples or constraints, so it meets the baseline for high schema coverage.

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

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

The description states the tool 'Execute[s] a custom ADB command,' which clearly indicates the verb (execute) and resource (ADB command). However, it does not differentiate from sibling tools like 'execute-mobile-command' or specify what ADB commands are suitable, making it vague in context.

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

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

There is no guidance on when to use this tool versus alternatives, such as 'execute-mobile-command' or other ADB-related siblings. The description provides no context, prerequisites, or exclusions, leaving usage unclear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool executes commands but lacks critical details: it doesn't specify if this requires device setup, what permissions are needed, potential side effects (e.g., app state changes), error handling, or response format. This leaves significant gaps in understanding how the tool behaves in practice.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and scope, making it easy to parse quickly, which is ideal for conciseness in a tool definition.

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 complexity of executing mobile commands (which could involve device interaction, varied outputs, or errors), the description is inadequate. With no annotations, no output schema, and minimal behavioral details, it fails to provide enough context for safe and effective use, especially compared to more specific siblings in the list.

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% description coverage, with 'command' and 'args' clearly documented. The description adds minimal value beyond this, mentioning 'mobile command name' and 'arguments' but not elaborating on command syntax, examples, or platform-specific nuances. This meets the baseline for high schema coverage but doesn't enhance parameter understanding.

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

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

The description states the tool 'Execute[s] a custom mobile command for iOS or Android', which provides a basic verb ('execute') and resource ('custom mobile command') with platform scope. However, it's vague about what constitutes a 'custom mobile command' and doesn't distinguish it from sibling tools like 'execute-adb-command' or other command-execution tools in the list, leaving ambiguity about its specific role.

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

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

The description offers no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., device connection), exclusions, or comparisons to siblings like 'execute-adb-command', leaving the agent to infer usage context from the tool name alone, which is insufficient for effective selection.

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

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

With no annotations, the description carries full burden but provides minimal behavioral insight. It doesn't disclose output format (e.g., list of locators, structured data), error conditions (e.g., invalid XML), performance traits (e.g., processing time for large sources), or side effects (likely none, but unspecified). The phrase 'extract' implies read-only analysis, but this isn't explicitly confirmed.

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

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

The description is a single, front-loaded sentence with zero wasted words. It directly states the tool's function without redundancy or fluff, making it highly efficient for quick comprehension by an AI agent.

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

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

For a tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on return values (critical for 'extract' operations), error handling, and integration with sibling tools (e.g., how it complements 'get-page-source'). Given the complexity of UI testing contexts, more guidance is needed for effective agent 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 parameters are well-documented in the schema. The description adds no additional semantic context beyond implying analysis of XML for locators, which is already inferred from the tool name. It doesn't explain parameter interactions (e.g., how elementType filtering works with maxResults) or provide examples, 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 ('extract') and resource ('element locators'), specifying the source ('from UI XML source'). It distinguishes from some siblings like 'capture-ui-locators' (which likely captures live UI) and 'generate-element-locators' (which may generate rather than extract), but doesn't explicitly contrast with all relevant alternatives like 'get-element-tree' or 'inspect-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?

No guidance on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites (e.g., needing XML source from 'get-page-source' or 'save-ui-hierarchy'), nor does it clarify use cases like static analysis versus dynamic inspection, leaving the agent to infer context from sibling tool names alone.

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

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

With no annotations provided, the description carries full burden but lacks behavioral details. It doesn't disclose whether this is a read-only operation, what happens on timeout, if it returns a single element or multiple, or error conditions. The mention of 'iOS only' is useful context but insufficient for a mutation/query tool.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and includes essential platform constraint. Every word earns its place.

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

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

For a tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'Find an element' returns (e.g., element reference, attributes, or null), error handling, or interaction with sibling tools. The platform limitation is noted, but other critical context is missing.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description adds no parameter semantics beyond what's in the schema (e.g., no examples beyond the schema's example, no clarification on timeout behavior). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Find an element') and the method ('using iOS class chain'), with explicit platform limitation ('iOS only'). However, it doesn't distinguish this from sibling tools like 'find-by-ios-predicate' or 'find-by-text', which serve similar element-finding purposes but use different methods.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'find-by-ios-predicate' or 'find-by-text', nor does it mention prerequisites (e.g., iOS environment, Appium session). It only states the platform limitation without context for tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the iOS-only restriction but doesn't describe what happens when an element is found (e.g., returns element reference), what happens on timeout, whether it waits for element appearance, or error conditions. For an element-finding tool with zero annotation coverage, this leaves significant behavioral gaps.

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 (one sentence) with zero wasted words. It's front-loaded with the core purpose and includes the important platform restriction. Every word earns its place in this minimal but complete statement.

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

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

For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns (element reference, success/failure, error details), doesn't describe behavioral aspects like waiting behavior or timeout handling, and doesn't provide guidance on predicate string syntax beyond the minimal example in the schema. Given the complexity of element finding and the lack of structured metadata, the description should do more.

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

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

Schema description coverage is 100%, with both parameters well-documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions. The baseline of 3 is appropriate when the schema does the heavy lifting, though the description could have provided context about predicate string syntax beyond the basic example.

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 ('Find') and resource ('an element') with the specific method ('using iOS predicate string'). It distinguishes from siblings like 'find-by-text' or 'find-by-ios-class-chain' by specifying the iOS predicate approach. However, it doesn't explicitly contrast with these alternatives in the description text itself.

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 some context with '(iOS only)', which implicitly suggests platform restrictions. However, it doesn't explicitly state when to use this tool versus alternatives like 'find-by-text' or 'find-by-ios-class-chain', nor does it mention prerequisites or typical use cases for predicate-based element finding.

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 states the tool generates XPath but doesn't disclose behavioral traits: whether it's read-only or mutative (likely read-only, but unspecified), if it has side effects, rate limits, authentication needs, or what happens on failure (e.g., if no element matches). For a tool with no annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and uses precise terminology ('XPath', 'element', 'text'). Every word earns its place, making it easy for an agent to parse quickly.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a string XPath, an error if no match), behavioral constraints, or error handling. For a tool that likely interacts with mobile testing frameworks, more context on usage and output is needed.

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 fully documents all 4 parameters. The description adds no parameter-specific information beyond implying 'text' is the search criterion. Since the schema does the heavy lifting, the baseline score of 3 is appropriate—the description doesn't compensate but doesn't 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 'Generate XPath to find element by text' clearly states the action (generate XPath) and target (find element by text). It distinguishes from many siblings like 'find-elements-by-text' (which likely returns elements rather than XPath) and 'tap-element-by-text' (which performs an action). However, it doesn't explicitly contrast with all similar tools like 'find-by-ios-class-chain' or 'find-by-ios-predicate'.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'find-elements-by-text' and 'find-by-ios-predicate', there's no indication of trade-offs (e.g., XPath vs. direct element retrieval, platform-specific optimizations). The agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries full burden. It mentions 'find all elements' but doesn't disclose behavioral traits like whether it returns a list, handles partial matches, requires UI visibility, has performance implications, or what happens if no elements are found. This is inadequate for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for a simple tool, making it easy to parse quickly.

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

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

Given no annotations, no output schema, and a simple parameter, the description is incomplete. It doesn't explain return values, error conditions, or behavioral context, leaving significant gaps for an AI agent to understand how to use the tool effectively.

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 the parameter 'text' fully documented in the schema. The description adds no additional meaning beyond what the schema provides, such as text matching rules or examples. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the verb ('find') and resource ('elements'), specifying the search criterion ('containing specific text'). It distinguishes from some siblings like 'find-by-text' by emphasizing 'all elements' rather than a single match, but doesn't explicitly differentiate from similar tools in the list.

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

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

No guidance is provided on when to use this tool versus alternatives like 'find-by-text', 'has-text-in-screen', or 'element-exists'. The description lacks context about prerequisites, timing, or comparison with sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't describe how it behaves: no information about output format, whether it modifies state, error conditions, or performance characteristics. For a tool with no annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.

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

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

Given the complexity of generating multiple locator types and the absence of both annotations and output schema, the description is insufficient. It doesn't explain what types of locators are generated, the output format, or how the generation process works. For a tool with no structured behavioral information, the description should provide more context.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('generate') and target ('multiple types of locators for an element'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'capture-ui-locators' or 'extract-locators', which appear related to locator generation, so it doesn't fully distinguish from alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'capture-ui-locators' or 'extract-locators'. There's no mention of prerequisites, context, or exclusions, leaving the agent with no usage direction beyond the basic purpose.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does but lacks critical details: it doesn't specify if this is a read-only generation or if it modifies state, what the output format is (e.g., code file, text), any rate limits, or error handling. For a tool with no annotations, this leaves significant gaps in understanding its behavior.

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

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

The description is extremely concise and front-loaded with a single sentence: 'Generate Appium test script from actions'. It wastes no words and directly communicates the core function, making it easy to parse quickly. Every part of the sentence earns its place by specifying key elements.

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 complexity (generating scripts from actions) and lack of annotations and output schema, the description is incomplete. It doesn't explain what the generated output looks like (e.g., a Python file, JSON), how to use it, or any behavioral traits. For a tool that likely produces code, more context is needed to be fully helpful to 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?

The input schema has 100% description coverage, clearly documenting all parameters like 'platformName', 'actions', and their sub-properties. The description adds no additional semantic context beyond the schema, such as example usage or constraints not in the schema. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the tool's purpose: 'Generate Appium test script from actions'. It specifies the verb ('generate'), resource ('Appium test script'), and source ('from actions'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'generate-element-locators' or 'capture-ui-locators', which might involve related test automation tasks, so it misses full sibling 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing initialized Appium), exclusions (e.g., not for real-time execution), or compare to siblings like 'execute-mobile-command' or 'perform-element-action'. Without such context, an agent might struggle to select this tool appropriately in a workflow.

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. 'Get' implies a read operation, but it doesn't disclose behavioral traits like whether this requires device connectivity, what format the information returns (percentage, health, etc.), or if there are any prerequisites (e.g., device must be unlocked). This leaves significant gaps for an agent.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose and appropriately sized for a simple tool with no parameters.

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 complexity (simple read operation) but lack of annotations and output schema, the description is incomplete. It doesn't explain what battery information is returned (e.g., level, status, health) or any behavioral context, leaving the agent with insufficient information to understand the tool's full behavior.

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 0 parameters with 100% schema description coverage, so the schema already fully documents the absence of parameters. The description doesn't need to add parameter semantics, and it correctly doesn't mention any parameters. Baseline for 0 parameters is 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 the action ('Get') and resource ('device battery information'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools that might also retrieve device information (like 'get-device-time' or 'get-orientation'), so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools that retrieve device information (e.g., 'get-device-time', 'get-orientation'), there's no indication of when battery info is specifically needed versus other device metrics.

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 retrieves contexts but doesn't disclose behavioral traits such as whether this is a read-only operation, if it requires specific device states, potential errors, or the format of the returned data. For a tool with zero annotation coverage, this is a significant gap in 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?

The description is a single, efficient sentence that front-loads the core purpose ('Get all available contexts') and provides clarifying examples. There is no wasted verbiage, making it highly concise and well-structured for quick understanding.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output format, or usage context. For a tool in a complex Appium/Xcode environment, more completeness would be helpful, but it meets the baseline for a basic retrieval function.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param details, which is appropriate, but it could have mentioned that no inputs are required. Baseline is 4 for zero parameters, as the schema fully covers the absence of inputs.

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 resource ('all available contexts'), with specific examples like 'NATIVE_APP, WEBVIEW, etc.' This distinguishes it from other tools that perform actions on contexts rather than retrieving them. However, it doesn't explicitly differentiate from 'get-current-context' which retrieves only the active context, so it misses full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get-current-context' or 'switch-context'. It lacks any mention of prerequisites, typical use cases, or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries full burden but only states what the tool does, not how it behaves. It doesn't disclose whether this requires specific device states, what happens if no activity is running, whether it returns structured data or just a string, or any error conditions. For a diagnostic tool with zero annotation coverage, this is insufficient.

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

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

The description is a single, focused sentence that states exactly what the tool does with zero wasted words. It's front-loaded with the core functionality and doesn't include unnecessary elaboration for such a simple tool.

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

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

Given the tool has no annotations, no output schema, and operates in a complex Android/Appium testing context with many similar sibling tools, the description is inadequate. It should explain what format the activity name returns in, when this tool is applicable versus alternatives, and any prerequisites or limitations for successful execution.

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 0 parameters with 100% schema description coverage, so the schema already fully documents the absence of parameters. The description appropriately doesn't discuss parameters since none exist, earning a baseline 4 for not creating confusion about non-existent inputs.

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

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

The description clearly states the action ('Get') and resource ('current Android activity name'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get-current-package' or 'get-contexts' that might retrieve related but different information about the Android environment.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools related to Android/Appium testing (like 'get-current-package', 'get-contexts', 'get-page-source'), there's no indication of when this specific activity retrieval is appropriate versus other diagnostic 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?

No annotations are provided, so the description carries full burden but offers minimal behavioral insight. It doesn't disclose if this is a read-only operation, what format the context information returns, potential errors, or dependencies like requiring an active Appium session. The description is too basic for a tool in a complex mobile testing environment.

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 ('Get the current context'), which is efficient but under-specified. While it avoids unnecessary words, it fails to provide essential context that would help an AI agent, making it feel incomplete rather than optimally 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?

For a tool in a complex Appium/mobile testing server with no annotations and no output schema, the description is inadequate. It doesn't explain what 'context' means, what data is returned, or how it fits with sibling tools like 'get-contexts' and 'switch-context', leaving significant gaps for agent understanding.

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 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add parameter semantics, but this is acceptable given the lack of parameters, aligning with the baseline expectation 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?

The description 'Get the current context' is a tautology that restates the tool name 'get-current-context' without adding meaningful specificity. It doesn't clarify what 'context' refers to in this mobile testing environment (e.g., WebView vs. native context) or what information is retrieved, making it vague despite the simple 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?

No guidance is provided on when to use this tool versus alternatives. Given sibling tools like 'get-contexts' (plural) and 'switch-context', the description doesn't explain if this tool retrieves a single active context versus listing all available contexts, or when it's appropriate compared to those 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but reveals nothing about behavior: no indication of whether this requires an active appium session, what happens if no app is running, error conditions, or return format. 'Get' implies a read operation, but without annotations, the description doesn't confirm safety or provide operational context.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable. Every word earns its place in this minimal but complete statement.

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

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

For a tool with no annotations and no output schema, the description is insufficiently complete. While concise, it doesn't address what the tool returns (just the package name? with metadata?), error conditions, dependencies, or behavioral context. Given the Appium testing context implied by sibling tools, more operational guidance would be helpful for agent decision-making.

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 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description appropriately doesn't waste space discussing parameters. Baseline for 0 parameters is 4, as no parameter information is needed and the description doesn't attempt to add unnecessary details.

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

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

The description clearly states the verb ('Get') and resource ('current active app package name'), making the purpose immediately understandable. It doesn't explicitly differentiate from siblings like 'list-installed-packages' or 'get-current-activity', but the specificity of 'current active' provides some implicit distinction. This is clear but lacks explicit sibling comparison.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (e.g., whether an app must be running), comparison to similar tools like 'get-current-activity' or 'list-installed-packages', or context about when this information is needed. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It states the action ('Get') but doesn't disclose behavioral traits such as whether this requires device access permissions, if it works offline, what format the time is returned in, or potential errors. This leaves significant gaps for a tool that interacts with a device.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse.

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

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

Given the complexity of device interaction and lack of annotations or output schema, the description is incomplete. It doesn't explain what 'device time' means (e.g., system time, uptime), the return format, or error conditions. For a tool in a mobile testing/automation context, this leaves too much ambiguity.

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 0 parameters, and schema description coverage is 100%, so no parameter information is needed. The description appropriately doesn't mention parameters, which aligns with the schema. A baseline of 4 is applied since it doesn't add or detract from parameter understanding.

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

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

The description 'Get the current device time' clearly states the verb ('Get') and resource ('current device time'), making the purpose immediately understandable. It doesn't distinguish from siblings (e.g., get-system-info tools), but it's specific enough to avoid vagueness or tautology.

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

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

The description provides no guidance on when to use this tool versus alternatives. In a context with many device-related tools (e.g., get-battery-info, get-orientation), it doesn't specify scenarios where retrieving device time is appropriate or mention prerequisites like device connectivity.

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 states it 'gets' attributes, implying a read-only operation, but doesn't disclose behavioral traits like whether it requires element visibility, what happens if the element doesn't exist, error handling, or the format of returned attributes. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place without redundancy or unnecessary elaboration.

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 complexity (a read operation with parameters) and lack of annotations and output schema, the description is incomplete. It doesn't explain what 'attributes' include (e.g., HTML attributes like 'id', 'class'), the return format, or error conditions. For a tool with no structured output documentation, more context is needed to guide effective 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?

The input schema has 100% description coverage, with clear documentation for both parameters ('selector' and 'strategy'). The description adds no additional meaning beyond what the schema provides, such as examples of attribute output or parameter interactions. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('Get') and resource ('all available attributes of an element'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get-element-text' or 'get-element-tree', which also retrieve element properties but focus on different aspects. The purpose is specific but lacks sibling 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?

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get-element-text' (for text content) and 'get-element-tree' (for hierarchical structure), there's no indication of when retrieving attributes is preferred. No context, exclusions, or prerequisites 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?

With no annotations provided, the description carries full burden for behavioral disclosure but provides minimal information. It doesn't mention what happens if the element doesn't exist, whether it waits for the element to appear, what format the returned text is in, or any error conditions. For a tool that interacts with UI elements, this leaves significant behavioral unknowns.

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

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

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized for a straightforward tool and gets straight to the point with zero wasted verbiage.

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

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

For a tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns (text format, null handling), error behavior, or how it differs from similar text-related tools in the extensive sibling list. Given the complexity of UI automation and the many alternative tools available, more context is needed.

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

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

The schema description coverage is 100%, with both parameters well-documented in the schema itself. The description adds no additional parameter information beyond what's already in the schema, so it meets the baseline expectation but doesn't provide extra value. The description doesn't explain parameter interactions or provide examples of selector usage.

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

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

The description clearly states the action ('Get text content') and target ('from a UI element'), making the purpose immediately understandable. It doesn't specifically differentiate from sibling tools like 'get-element-attributes' or 'find-by-text', but the verb+resource combination is precise enough for basic understanding.

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

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

No guidance is provided about when to use this tool versus alternatives like 'get-element-attributes' (which might include text among other attributes) or 'find-by-text' (which searches for elements containing text). The description offers no context about prerequisites, limitations, or appropriate scenarios for this specific text extraction method.

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 mentions the output is a 'hierarchical view' but doesn't specify format (e.g., JSON, XML), whether it's read-only (implied by 'Get'), performance implications, or error conditions. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with a helpful analogy. It's front-loaded with the core functionality and has zero wasted words, making it easy to parse quickly.

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

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

For a tool with no annotations and no output schema, the description is insufficient. It doesn't explain the return format, error handling, or how the hierarchical view relates to other UI inspection tools in the sibling list. Given the complexity of UI testing and the rich sibling context, more completeness is needed to guide effective 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?

The description adds no parameter information beyond what's in the schema, which has 100% coverage for the single parameter 'maxDepth'. The schema description explains it well ('Maximum depth to traverse in the element tree (default: 5)'), so the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Get a hierarchical view of the UI elements' with a helpful analogy to 'Appium Inspector'. This specifies the verb ('Get') and resource ('hierarchical view of UI elements'), making it understandable. However, it doesn't explicitly differentiate from siblings like 'get-page-source' or 'save-ui-hierarchy', which might offer similar functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for UI inspection (e.g., 'get-page-source', 'inspect-element', 'save-ui-hierarchy'), there's no indication of when this hierarchical view is preferred over other methods, nor any prerequisites or exclusions 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?

With no annotations provided, the description carries full burden for behavioral disclosure but offers minimal information. It states the tool retrieves orientation but doesn't describe what orientation values to expect (e.g., portrait, landscape), whether it requires an active device session, or potential errors. This is inadequate for a tool with zero annotation coverage.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded with the core purpose and efficiently communicates the essential action. Every word earns its place, making it highly 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 the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate but lacks depth. It doesn't explain the return format or behavioral context, which could be important for integration. For a read-only tool with no structured output, more detail on expected results would improve 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 tool has zero parameters, and schema description coverage is 100%, so the schema fully documents the absence of inputs. The description doesn't need to compensate for any parameter gaps, making it appropriately minimal in this dimension. A baseline of 4 is justified as no parameter information is required.

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

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

The description clearly states the action ('Get') and resource ('current device orientation'), making the purpose immediately understandable. It distinguishes itself from siblings like 'set-orientation' by focusing on retrieval rather than modification. However, it doesn't explicitly contrast with other device info tools like 'get-battery-info' or 'get-device-time', which would have earned a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., device connectivity), timing considerations, or relationships to sibling tools like 'set-orientation' for changing orientation. This leaves the agent with minimal context for decision-making.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves XML representation but doesn't clarify if this is a read-only operation, whether it requires specific UI state, potential side effects, or output format details. This is inadequate for a tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that directly states the tool's function without any fluff. It's front-loaded and appropriately sized for a simple tool, with every word contributing to understanding.

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

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

Given the complexity (a UI inspection tool with no annotations and no output schema), the description is insufficient. It lacks details on behavioral traits, output format, or usage context, making it incomplete for an agent to reliably invoke this tool without additional assumptions.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, but that's acceptable here. A baseline of 4 is appropriate since the schema fully covers the absence of parameters, and the description doesn't need to compensate.

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

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

The description clearly states the action ('Get') and resource ('XML representation of the current UI'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get-element-tree' or 'save-ui-hierarchy', which might provide similar UI structure data, so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools related to UI inspection (e.g., 'get-element-tree', 'save-ui-hierarchy'), there's no indication of context, prerequisites, or exclusions, leaving the agent to guess based on the name alone.

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

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

No annotations are provided, so the description carries full burden. It mentions the action ('Check if specific text exists') but lacks behavioral details like whether it's case-sensitive, if it searches hidden elements, timeout behavior, return format, or performance implications. For a tool with no annotation coverage, this is insufficient.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core purpose and efficiently conveys the essential information without unnecessary elaboration.

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 (single parameter, no output schema, no annotations), the description covers the basic purpose but lacks behavioral context and usage guidance. It's minimally adequate but leaves gaps in understanding how the tool behaves in practice.

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 the single parameter 'text' documented as 'Text to search for'. The description adds no additional parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('Check if') and resource ('specific text exists anywhere on the current screen'), making the purpose explicit. It distinguishes from siblings like 'find-by-text' or 'get-element-text' by focusing on existence checking rather than location retrieval or text extraction.

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

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

The description implies usage context ('on the current screen') but doesn't explicitly state when to use this tool versus alternatives like 'element-exists' or 'find-by-text'. No guidance on prerequisites, exclusions, or specific scenarios is provided.

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

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

With no annotations provided, the description carries full behavioral disclosure burden. It states the conditional behavior ('if it's currently visible') but doesn't mention what happens if the keyboard isn't visible (error? no-op?), whether this requires specific device states, or any side effects. For a UI manipulation tool with zero annotation coverage, this is inadequate.

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

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

The description is a single, efficient sentence that states exactly what the tool does with no wasted words. It's appropriately sized for a simple, parameter-less tool and front-loads the essential information.

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

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

For a simple UI control tool with no parameters and no output schema, the description is minimally adequate. However, with no annotations and behavioral gaps (like not specifying what happens when the keyboard isn't visible), it leaves important context uncovered. The description works for basic understanding but doesn't provide complete operational guidance.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the empty input. The description doesn't need to add parameter information, and it correctly doesn't mention any parameters. Baseline for 0 parameters is 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 the action ('hide') and target ('keyboard') with a conditional ('if it's currently visible'), providing specific verb+resource. It doesn't explicitly distinguish from sibling tools, but given the unique nature of keyboard hiding among many UI/device control tools, the purpose is sufficiently 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 implies usage when the keyboard is visible, but doesn't provide explicit when-not scenarios or alternatives. Among siblings like 'send-keys' or 'tap-element' that might involve keyboard interaction, there's no guidance on when to choose this tool over others or prerequisites for its 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 states the tool initializes a session but omits critical details such as whether this is a one-time setup, if it requires specific permissions or server availability, potential side effects (e.g., app installation), or error handling. This is inadequate for a tool with 12 parameters and no output schema.

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

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

The description is a single, clear sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and efficiently communicates the core function, making it highly 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 the complexity (12 parameters, no annotations, no output schema) and the critical nature of session initialization in mobile automation, the description is insufficient. It lacks details on behavioral traits, usage context, return values, or error scenarios, leaving significant gaps for an AI agent to understand how to invoke it correctly.

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

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

The input schema has 100% description coverage, with each parameter well-documented (e.g., 'platformName' with enum values, 'udid' as required for real devices). The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for high schema coverage without compensating 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 ('Initialize') and resource ('Appium driver session for mobile automation'), making the purpose evident. However, it does not explicitly differentiate this tool from its many siblings, such as 'close-appium' or 'launch-appium-app', which might involve related session management, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, prerequisites, or context for invocation. Given the extensive list of sibling tools, including session-related ones like 'close-appium', this lack of usage direction is a significant gap.

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 mentions inspecting UI and performing actions but fails to describe critical behaviors like error handling, performance implications, or what happens if elements are not found. For a tool with 8 parameters and no annotations, this is a significant gap in 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?

The description is a single, concise sentence that efficiently states the tool's purpose. It is front-loaded and wastes no words, though it could benefit from more detail given the tool's complexity. The structure is clear but minimal.

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

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

Given the tool's complexity (8 parameters, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits, return values, error cases, and how it integrates with sibling tools. For a multi-step tool involving UI inspection and actions, more context is needed to guide effective 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?

The schema description coverage is 100%, meaning all parameters are documented in the input schema. The description does not add any additional meaning or context beyond what the schema provides, such as explaining parameter interactions or usage examples. With high schema coverage, the baseline score of 3 is appropriate as the description adds no extra value.

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

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

The description states the tool's purpose as inspecting UI to identify element locators and then performing an action, which is clear but vague. It specifies the general function but lacks specificity about what types of actions or how it distinguishes from similar sibling tools like 'inspect-and-tap' or 'perform-element-action'. The description is not tautological but could be more precise.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It mentions 'inspect UI' and 'perform an action' but does not specify scenarios, prerequisites, or exclusions compared to sibling tools such as 'inspect-element' or 'tap-element'. This leaves the agent without clear usage context.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral disclosure. It mentions 'best available locator' which suggests some intelligent selection logic, but doesn't explain what makes a locator 'best', error handling, whether it retries failed locators, or what happens if the element isn't found. For a tool with potential complexity, this is insufficient.

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

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

The description is a single, efficient sentence that communicates the core functionality without waste. It's appropriately sized for what it does convey, though it could benefit from additional context about when and how to use it.

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 that combines inspection and action with potential complexity (selecting 'best available locator'), the description is inadequate. No annotations exist, no output schema is provided, and the description doesn't explain what happens after tapping, error conditions, or performance characteristics. Given the rich sibling tool ecosystem, more context is needed.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain how 'selector' and 'strategy' interact, or how 'preferredOrder' influences the 'best available locator' logic. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('inspect an element' then 'tap') and specifies the resource ('using one locator' and 'best available locator'). It distinguishes from simpler tools like 'tap-element' by combining inspection and tapping, but doesn't explicitly differentiate from 'inspect-and-act' which might have similar functionality.

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

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

No guidance is provided on when to use this tool versus alternatives like 'tap-element', 'smart-tap', or 'inspect-and-act'. The description implies it's for tapping after inspection, but doesn't specify scenarios where this combined approach is preferred over separate inspection and tapping steps.

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 mentions 'detailed information' and debugging purpose but fails to disclose critical behaviors: what information is returned, format, permissions needed, side effects, or error handling. This leaves significant gaps for a tool with potential complexity.

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, zero waste, front-loaded with core purpose. Every word earns its place without redundancy or fluff, making it efficient for quick comprehension.

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

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

Given no annotations and no output schema, the description is incomplete. It lacks details on return values, error cases, or behavioral nuances needed for effective debugging. For a tool with potential complexity in mobile/app testing context, this is insufficient.

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%, providing clear documentation for both parameters. The description adds no additional parameter semantics beyond implying element inspection, which the schema already covers. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb ('Get') and resource ('detailed information about an element'), specifying it's for debugging. It distinguishes from siblings like 'get-element-attributes' or 'get-element-text' by emphasizing debugging focus, though not explicitly naming alternatives.

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

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

No guidance on when to use this tool versus similar siblings (e.g., 'get-element-attributes', 'get-element-tree'), no prerequisites, and no explicit exclusions. The debugging hint implies a specific context but lacks actionable alternatives or constraints.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Install' implies a write/mutation operation, the description doesn't mention permission requirements, whether the installation is reversible, potential side effects, or what happens if installation fails. For a tool that modifies device state, this is a significant gap in behavioral 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?

The description is extremely concise at just 5 words, front-loading the essential information with zero wasted words. Every word earns its place by specifying the action, target, and platform. The structure is optimal for quick comprehension.

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 that performs device modification (installing applications) with no annotations and no output schema, the description is inadequate. It doesn't explain what happens after installation, whether verification occurs, what errors might be returned, or how to handle installation failures. Given the complexity of device operations and the lack of structured metadata, the description should provide more complete 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?

With 100% schema description coverage, both parameters are already documented in the schema. The description doesn't add any additional semantic context about the parameters beyond what's in the schema descriptions. It doesn't explain APK file format requirements, device connectivity prerequisites, or installation behavior details. The baseline of 3 is appropriate given the schema does the parameter documentation work.

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 ('Install') and resource ('Android application APK'), making the purpose immediately understandable. It doesn't specifically differentiate from sibling tools like 'xcode_install_app' or 'uninstall-app', but the Android focus provides some distinction. The description avoids tautology by specifying what's being installed.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'xcode_install_app' (for iOS) and 'uninstall-app' (for removal), there's no indication of when this Android-specific installation tool is appropriate versus other installation methods. No prerequisites or contextual usage information 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 full burden. It states the tool's function but lacks behavioral details: it doesn't specify what 'locked' means (screen lock, authentication lock), whether this requires device permissions, potential errors (e.g., if device is unreachable), or the return format (boolean, status object).

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every word earns its place, making it easy to parse quickly.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. However, it lacks context about the return value (e.g., boolean vs. detailed status) and behavioral nuances, which could be important for integration. It's complete enough for basic understanding 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?

The tool has 0 parameters with 100% schema description coverage. The description doesn't need to explain parameters, and it correctly implies no inputs are required. A baseline of 4 is appropriate since there are no parameters to document.

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

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

The description 'Check if the device is currently locked' clearly states the action (check) and resource (device lock status). It distinguishes from siblings like 'lock-device' and 'unlock-device' by focusing on status inquiry rather than state modification.

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

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

No guidance is provided on when to use this tool versus alternatives. While the purpose is clear, there's no mention of prerequisites (e.g., device connectivity), timing considerations, or related tools like 'get-device-time' or 'list-devices' that might provide 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 for behavioral disclosure. While 'Launch an app' implies an action that changes device state, it doesn't specify what happens (e.g., does it bring app to foreground, does it require specific permissions, what errors might occur). The description lacks details about side effects, error conditions, or expected outcomes.

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

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

The description is a single, clear sentence with no wasted words. It's appropriately sized for a straightforward tool and gets directly to the point without unnecessary elaboration.

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 that performs device operations with 3 parameters and no annotations or output schema, the description is insufficient. It doesn't explain what 'launch' entails operationally, what happens on success/failure, or how it differs from similar sibling tools. The context demands more behavioral and usage information.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter information beyond what's in the schema (deviceId, packageName, activityName). This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the action ('Launch') and target ('an app on an Android device'), providing a specific verb+resource combination. However, it doesn't distinguish itself from sibling tools like 'launch-appium-app' or 'xcode_launch_app', which appear to serve similar purposes on different platforms or contexts.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'launch-appium-app' or 'xcode_launch_app' from the sibling list. It also doesn't mention prerequisites (e.g., device must be connected, app must be installed) or usage constraints.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Launch') but doesn't explain what happens during launch (e.g., app state, permissions, errors), whether it requires an active session, or any side effects. This is inadequate for a tool with potential operational dependencies.

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

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

The description is a single, clear sentence that directly states the tool's function without unnecessary words. It's front-loaded and efficiently conveys the essential information, making it highly 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 the tool has 0 parameters, no annotations, and no output schema, the description is minimally adequate but lacks depth. It explains what the tool does but doesn't cover behavioral aspects like session requirements or error handling, which are important for a launch operation in a testing context. It meets the bare minimum for such a simple tool.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the inputs. The description doesn't need to add parameter details, and it appropriately doesn't mention any, earning a baseline score near the top of the scale for this dimension.

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 ('Launch') and the target ('the app associated with the current Appium session'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'launch-app' or 'xcode_launch_app', which appear to serve similar functions in different contexts, so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'launch-app' or 'xcode_launch_app' from the sibling list. It mentions 'current Appium session' but doesn't clarify prerequisites or exclusions, leaving usage context implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but doesn't describe what 'list' entails (e.g., format of returned data, whether it includes offline devices, or if it requires specific permissions). For a tool with zero annotation coverage, this is a significant gap in 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?

The description is a single, efficient sentence with no wasted words. It's appropriately sized for a simple tool and front-loads the core action, making it easy to parse quickly.

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

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

Given the tool's simplicity (0 parameters, no output schema), the description is minimally adequate but lacks depth. It doesn't explain the return format or behavioral nuances, which could be important for an agent to use it correctly. With no annotations and no output schema, more context would improve 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 tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and a baseline of 4 is appropriate as it doesn't mislead or omit necessary details about inputs.

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 ('List') and resource ('all connected Android devices'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'list-ios-simulators' or 'list-installed-packages', which would require a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list-ios-simulators' or 'get-device-time'. It lacks context about prerequisites (e.g., whether Appium must be initialized) or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries full burden. It states a read operation ('List'), implying non-destructive behavior, but lacks details on permissions needed, output format (e.g., list structure, package details), error conditions, or whether it requires an active device session. This leaves significant behavioral gaps.

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, direct sentence with zero wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse.

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

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

Given the tool's low complexity (single parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks behavioral context (e.g., output details, error handling) and usage guidance, leaving room for improvement despite the simple schema.

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

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

Schema description coverage is 100%, with the single parameter 'deviceId' fully documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 without compensating or detracting.

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 ('List') and resource ('all installed packages on an Android device'), making the purpose unambiguous. However, it doesn't differentiate from potential siblings like 'list-devices' or 'xcode_list_installed_apps', which would require explicit comparison to achieve a 5.

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

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

No guidance is provided on when to use this tool versus alternatives. While the description specifies 'Android device', it doesn't mention prerequisites (e.g., device connectivity), exclusions (e.g., iOS devices), or related tools like 'list-devices' for device selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but doesn't describe how it behaves—such as whether it returns a structured list, what format the output is in, if it requires specific conditions (e.g., Xcode installed), or potential errors. This leaves significant gaps for an agent to understand execution.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place by conveying essential 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 the complexity of iOS simulator tools and the lack of annotations or output schema, the description is incomplete. It doesn't explain what 'available' means (e.g., booted, installed), the return format, or how this integrates with other tools like 'xcode_get_ios_simulators'. For a tool in a rich ecosystem, more context is needed.

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 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, but it also doesn't mention the lack of parameters, which could be slightly helpful. Baseline is 4 for zero parameters.

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

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

The description clearly states the verb ('Get') and resource ('list of available iOS simulators'), making the purpose immediately understandable. It distinguishes itself from most siblings by focusing on listing simulators rather than interacting with them, though it doesn't explicitly differentiate from 'xcode_get_ios_simulators' which appears to serve a similar function.

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

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

No guidance is provided on when to use this tool versus alternatives like 'xcode_get_ios_simulators' or 'list-devices'. The description implies usage for retrieving simulator information but offers no context about prerequisites, timing, or complementary tools.

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

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits like: whether this requires device permissions, if it's reversible only via 'unlock-device', potential side effects (e.g., interrupting current activities), or what happens when durationSec expires. For a mutation tool with zero annotation coverage, this is inadequate.

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 perfectly concise at 4 words, front-loaded with the core action. Every word earns its place with zero waste or redundancy.

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

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

For a device mutation tool with no annotations and no output schema, the description is incomplete. It should explain what 'locking' means in this context (just screen? full device?), what happens after locking, how to verify success, and relationship to sibling tools like 'is-device-locked' and 'unlock-device'.

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

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

Schema description coverage is 100% (durationSec clearly documented), so the baseline is 3. The description doesn't add any parameter semantics beyond what's in the schema - it doesn't explain default behavior if durationSec is omitted, valid ranges, or units clarification beyond 'seconds'.

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 'Lock the device screen' clearly states the action (lock) and target (device screen) with a specific verb+resource. However, it doesn't distinguish from sibling 'unlock-device' or clarify if this is physical device locking versus screen timeout locking, which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'unlock-device' or other device control tools. There's no mention of prerequisites (e.g., device must be unlocked first) or typical use cases (security, testing scenarios).

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

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

No annotations are provided, so the description carries the full burden. It mentions a 'long press gesture' but doesn't disclose behavioral aspects like whether this requires an active app session, what happens if the element isn't found, or if it triggers UI changes. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

For a tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It lacks details on behavior, error handling, or return values, leaving significant gaps in understanding how to use it effectively in context.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters (selector, duration, strategy). The description adds no additional meaning beyond what's in the schema, such as examples or edge cases, resulting in the baseline score for high schema coverage.

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

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

The description clearly states the action ('Perform a long press gesture') and target ('on an element'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'tap-element' or 'smart-tap' that involve similar touch interactions, preventing a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives like 'tap-element' or 'swipe'. The description only states what it does without context about appropriate scenarios or prerequisites, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action but doesn't describe what 'Open' entails operationally - whether this triggers a system UI change, requires specific permissions, has side effects on app state, or what happens if notifications are already open. For a UI interaction tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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 perfectly concise - a single sentence that communicates the essential information without any wasted words. It's front-loaded with the core action and includes the platform limitation efficiently. Every word earns its place in this minimal but complete phrasing.

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

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

For a zero-parameter tool with no output schema, the description provides the basic purpose and platform constraint. However, as a UI interaction tool with no annotations, it should ideally mention what constitutes success/failure or any observable effects. The description is minimally adequate but lacks operational context that would help an agent understand what 'success' looks like for this action.

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 0 parameters with 100% schema description coverage, so the schema already fully documents the empty parameter set. The description appropriately doesn't add parameter information beyond what the schema provides. Baseline for 0 parameters with full coverage is 4, as there's no need for parameter semantics in the description.

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

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

The description clearly states the action ('Open') and target ('notifications panel'), making the purpose immediately understandable. It distinguishes from siblings by specifying 'Android only', which is useful context. However, it doesn't explicitly differentiate from similar UI interaction tools like 'tap-element' or 'inspect-and-tap' that might also open panels.

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 'Android only' limitation provides some contextual guidance about when this tool is applicable versus iOS-specific tools. However, it doesn't offer explicit alternatives for iOS scenarios or explain when to use this versus other notification-related tools (none appear in the sibling list). The guidance is implied rather than comprehensive.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'perform a specific action' but doesn't disclose behavioral traits such as error handling, side effects (e.g., UI changes), performance implications, or response format. For a tool with multiple actions and parameters, this lack of detail is a significant gap, though it doesn't 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 a single, efficient sentence that states the core function without waste. It is appropriately sized and front-loaded, but could benefit from more detail given the tool's complexity. No redundant information is present, making it concise yet under-specified.

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 complexity (5 parameters, no output schema, no annotations), the description is incomplete. It lacks details on return values, error cases, and practical usage examples. With rich input schema but no behavioral context, the description doesn't provide enough information for effective tool invocation in a UI automation context.

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

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

Schema description coverage is 100%, with clear descriptions for all parameters, including enums for 'action' and 'locatorType'. The description adds no additional meaning beyond the schema, as it doesn't explain parameter interactions or provide examples. With high schema coverage, the baseline is 3, but the description fails to compensate with any extra insights.

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

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

The description states the tool performs actions on elements using locator strategies, which is a vague purpose. It mentions 'specific action' without detailing what actions are available, and while it distinguishes from some siblings like 'clear-element' or 'tap-element' by being more generic, it doesn't clearly differentiate from others like 'inspect-and-act' or 'perform-touch-id'. The verb 'perform' is generic, and 'element' is broad without specifying UI context.

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

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

No explicit guidance on when to use this tool versus alternatives is provided. The description implies usage for element interactions but doesn't specify scenarios, prerequisites, or exclusions. With many sibling tools for similar actions (e.g., 'tap-element', 'send-keys', 'swipe'), the lack of differentiation leaves the agent without clear decision criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions simulation and iOS-only, but fails to describe critical traits: whether this triggers system-level authentication dialogs, if it requires specific app permissions, what happens on match vs. mismatch (beyond the parameter), or any side effects like app state changes. For a security-related tool, this is a significant gap.

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

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

The description is extremely concise—a single, front-loaded sentence with zero wasted words. It directly states the core functionality and constraint without any fluff, making it efficient for quick comprehension.

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 complexity of simulating a biometric feature with security implications, no annotations, and no output schema, the description is incomplete. It misses behavioral details, error conditions, return values, and integration context, leaving the agent under-informed for safe and effective 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%, with the single parameter 'match' fully documented in the schema. The description adds no additional parameter semantics beyond implying fingerprint simulation, which the schema already covers. Baseline 3 is appropriate as the schema does the heavy lifting, but no extra value is added.

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 ('Simulate Touch ID fingerprint') and specifies the platform constraint ('iOS only'), which distinguishes it from generic biometric tools. However, it doesn't explicitly differentiate from sibling tools like 'unlock-device' or 'lock-device' that might involve device security, leaving some ambiguity about its unique role in the toolset.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites (e.g., requiring an iOS device or simulator setup), typical use cases (e.g., testing authentication flows), or exclusions (e.g., not for Android). This leaves the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions reliability compared to TouchAction API, it doesn't describe what the tool actually does behaviorally (e.g., whether it performs gestures on a specific element or screen coordinates, error handling, or what happens after execution). For a tool with 10 parameters and no annotations, this is a significant gap in 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?

The description is extremely concise—a single sentence that efficiently communicates the core purpose and key advantage. It's front-loaded with the main action and includes no unnecessary details, making it easy to parse quickly.

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

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

Given the tool's complexity (10 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain what the tool returns, how gestures are executed (e.g., on what context or element), error conditions, or dependencies. For a gesture-performing tool with many parameters, more context is needed to guide effective 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%, meaning all parameters are documented in the input schema. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't explain coordinate systems, default values beyond duration, or gesture specifics). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the tool's purpose: 'Perform touch gestures using the W3C Actions API.' It specifies the action type (touch gestures) and the implementation method (W3C Actions API). However, it doesn't explicitly differentiate from sibling tools like 'swipe', 'long-press', or 'tap-element', which appear to be similar gesture 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 provides some usage guidance by mentioning that the W3C Actions API is 'more reliable than TouchAction API,' which implies this tool should be preferred over alternatives using the older API. However, it doesn't explicitly state when to use this tool versus specific sibling tools like 'swipe' or 'tap-element', nor does it mention any prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden but only states the action without behavioral details. It doesn't disclose effects (e.g., if it simulates a physical key press, requires device state, or has side effects), rate limits, or error conditions, leaving significant gaps.

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

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

The description is a single, efficient sentence with no wasted words, making it front-loaded and easy to parse. It directly conveys the core action without unnecessary elaboration.

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

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

Given no annotations and no output schema, the description is insufficient for a tool that performs an action on a device. It lacks details on behavior, results, or error handling, making it incomplete for safe and effective use by an AI 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?

The input schema has 100% description coverage, with 'keycode' clearly documented. The description doesn't add extra meaning beyond the schema, such as examples or constraints, so it meets the baseline for high schema coverage without enhancing parameter understanding.

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

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

The description clearly states the action ('press') and target ('Android key code'), making the purpose evident. However, it doesn't differentiate from sibling tools like 'send-key-event' or 'send-keys-to-device', which may have overlapping functionality, so it misses full sibling 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 guidance is provided on when to use this tool versus alternatives like 'send-key-event' or other input-related siblings. The description lacks context, prerequisites, or exclusions, leaving usage unclear.

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 mentions 'pull a file' but doesn't specify what happens (e.g., copies to local storage, returns file content, requires device access), potential side effects (e.g., file locks), or error conditions (e.g., missing file permissions). This leaves significant gaps for a tool that interacts with device files.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action ('pull a file'), making it easy to scan and understand quickly.

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

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

For a tool that interacts with device files (a potentially complex operation), the description is insufficient. With no annotations, no output schema (so return values are undocumented), and minimal behavioral context, it fails to provide enough information for safe and effective use, especially given the many sibling tools in this server.

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% description coverage, with the 'path' parameter clearly documented as 'Path to the file on the device'. The description doesn't add any extra meaning beyond this, such as path format examples or constraints, but the schema provides adequate baseline information.

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

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

The description clearly states the verb ('pull') and resource ('a file from the device'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its sibling 'push-file', which handles the opposite operation, nor does it specify what 'pull' means in this context (e.g., copy, download, or retrieve).

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

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

The description provides no guidance on when to use this tool versus alternatives. Given the sibling list includes 'push-file' (for sending files to the device) and other file-related tools like 'xcode_copy_to_simulator', there's no indication of prerequisites, context (e.g., device connectivity), or comparisons to similar 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?

No annotations are provided, so the description carries full burden. 'Push' implies a write operation, but it doesn't disclose behavioral traits like whether this overwrites existing files, requires specific permissions, has side effects, or handles errors. For a file-write tool with zero annotation coverage, this is a significant gap in 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?

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly without unnecessary elaboration.

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 complexity of a file-write operation to a device, no annotations, and no output schema, the description is incomplete. It lacks crucial context like success/failure behavior, file system interactions, or compatibility with sibling tools, making it inadequate for safe and effective 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%, with clear documentation for both parameters ('path' and 'data'). The description doesn't add any meaning beyond what the schema provides (e.g., it doesn't explain path format constraints or data encoding details), so it meets the baseline for high schema coverage.

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

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

The description clearly states the action ('push') and target resource ('a file to the device'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'pull-file' or 'xcode_copy_to_simulator' that might handle similar file operations, so it doesn't reach the highest score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for device operations (e.g., 'pull-file', 'xcode_copy_to_simulator'), there's no indication of context, prerequisites, or exclusions, leaving the agent to guess based on the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'terminate and relaunch,' implying a destructive mutation, but does not specify side effects (e.g., loss of app state, session persistence), permissions required, or error conditions. This leaves significant gaps for a tool that alters app state.

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

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

The description is a single, well-structured sentence that front-loads the core action ('Reset the app') and efficiently elaborates with 'terminate and relaunch' in parentheses. There is no wasted verbiage, making it highly concise and easy to parse.

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

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

Given the tool's complexity (a mutation operation with potential side effects), lack of annotations, and no output schema, the description is insufficient. It fails to explain behavioral traits like state loss, error handling, or what 'reset' entails beyond the basic action, leaving the agent under-informed for safe invocation.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, focusing solely on the tool's action. A baseline of 4 is applied as it efficiently handles the lack of parameters without redundancy.

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 ('Reset the app') and specifies the resource ('associated with the current Appium session'), with the parenthetical 'terminate and relaunch' providing additional clarity on what 'reset' entails. However, it does not explicitly differentiate from sibling tools like 'close-app' or 'launch-app', which handle similar app lifecycle operations, leaving some ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'close-app' or 'launch-app' for partial app lifecycle management, or 'xcode_terminate_app' for simulator-specific contexts. It lacks explicit when/when-not instructions or prerequisite conditions, offering only a basic functional statement.

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 states 'Save' which implies a write operation, but doesn't disclose behavioral traits like file system permissions needed, whether it overwrites existing files, error handling, or what happens on success/failure. For a file-writing tool with zero annotation coverage, this is a significant gap in 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?

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it immediately understandable. Every word earns its place without unnecessary elaboration.

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

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

Given no annotations, no output schema, and a mutation tool (file writing), the description is incomplete. It doesn't explain what happens after saving (e.g., success confirmation, error messages), file format details, or integration with other tools in the ecosystem. For a tool that modifies the file system, more context is needed.

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

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

Schema description coverage is 100%, with both parameters ('xmlSource' and 'filePath') clearly documented in the schema. The description doesn't add any meaningful parameter semantics beyond what the schema already provides (e.g., format expectations, path conventions). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('Save') and resource ('UI hierarchy XML'), making the purpose understandable. However, it doesn't differentiate from potential sibling tools like 'save' operations for other data types, though no obvious direct siblings exist in the provided list. The description is specific but lacks sibling distinction context.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., whether UI hierarchy XML must be obtained first from another tool like 'get-element-tree'), nor does it specify typical use cases or constraints. This leaves the agent without contextual usage information.

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 mentions scrolling behavior but doesn't describe what 'scroll' means operationally (e.g., smooth vs. jump, visual feedback, timing), whether it requires specific screen states, or what happens on failure. For a UI interaction tool with zero annotation coverage, this is insufficient.

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

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

The description is a single, efficient sentence that directly states the tool's function without any wasted words. It's appropriately sized for this simple tool and front-loads the essential information.

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

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

For a UI interaction tool with no annotations and no output schema, the description is too minimal. It doesn't explain what 'scroll' means in this context, what visual or state changes occur, error conditions, or how it differs from similar tools like 'swipe'. The context signals show this is part of a mobile testing/automation suite where such details matter.

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

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

The schema description coverage is 100%, with both parameters ('direction' and 'distance') fully documented in the schema. The description adds no additional parameter information beyond what's in the schema, so it meets the baseline of 3 for adequate coverage without adding 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 ('scroll') and resource ('the screen') with a specific direction specification. It distinguishes from sibling tools like 'swipe' or 'scroll-to-element' by focusing on general screen scrolling rather than targeted actions, though it doesn't explicitly name these alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'swipe' or 'scroll-to-element', nor does it mention any prerequisites or context requirements. It simply states what the tool does without usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions scrolling until visibility is achieved, implying iterative attempts, but does not detail critical behaviors such as success/failure conditions, timeouts, error handling, or interaction with the UI state. For a tool with no annotations, this is insufficient to guide safe and effective use.

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 and front-loaded with a single, clear sentence: 'Scroll until an element becomes visible.' It wastes no words and directly communicates the core functionality, making it easy for an agent to parse and understand quickly.

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

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

Given the complexity of a scrolling tool with 4 parameters, no annotations, and no output schema, the description is incomplete. It lacks information on behavioral outcomes, error cases, and how parameters interact, which is crucial for an agent to invoke the tool correctly in a testing or automation context. The high schema coverage helps, but the description does not compensate for the missing behavioral and output details.

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

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

Schema description coverage is 100%, meaning all parameters are documented in the schema itself. The description does not add any semantic details beyond what the schema provides (e.g., it doesn't explain how 'selector' interacts with 'strategy' or what happens if 'maxScrolls' is exceeded). With high schema coverage, the baseline score of 3 is appropriate, as the description adds no extra value but doesn't detract either.

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

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

The description clearly states the tool's purpose: 'Scroll until an element becomes visible.' It specifies the action (scroll) and the goal (make an element visible), which is specific and actionable. However, it does not explicitly differentiate from sibling tools like 'scroll-screen' or 'wait-for-element,' which might have overlapping functionality, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios where scrolling is necessary, prerequisites like element existence, or comparisons to siblings such as 'scroll-screen' (which might scroll without targeting an element) or 'wait-for-element' (which might wait without scrolling). This lack of context leaves the agent without clear usage instructions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions sending a key event but fails to describe critical traits like required device state (e.g., unlocked, app open), permissions, side effects (e.g., navigation changes), or error conditions. This leaves significant gaps for an agent to understand the tool's behavior.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with relevant examples. It is front-loaded and wastes no words, making it easy to parse quickly.

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

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

For a tool with no annotations, no output schema, and a single parameter, the description is incomplete. It lacks details on behavioral traits, return values, error handling, and differentiation from siblings, making it inadequate for an agent to fully understand the tool's context and usage.

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 the parameter 'keyEvent' documented as 'Key event name or code'. The description adds minimal value by providing examples (HOME, BACK), which slightly clarify semantics but don't go beyond what the schema already states. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('send') and resource ('key event to the device'), with examples like HOME and BACK that help specify the action. However, it doesn't explicitly differentiate from sibling tools like 'press-key-code' or 'send-keys', which might have overlapping functionality, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'press-key-code' or 'send-keys-to-device' from the sibling list. It lacks context about prerequisites, device states, or specific scenarios, offering only a basic example without usage boundaries.

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 but offers minimal behavioral context. It mentions 'send text input' which implies a write operation, but doesn't disclose whether this requires specific element states (focusable, visible), what happens if the element doesn't exist, whether it clears existing text first, or any error conditions. For a mutation tool with zero annotation coverage, this is inadequate.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a tool with three parameters and gets straight to the point without unnecessary elaboration.

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 UI automation tool that performs text input (a mutation operation), the description is insufficient. With no annotations, no output schema, and minimal behavioral context, it doesn't provide enough information for safe and effective use. The agent won't know what happens on success/failure, what permissions are needed, or how this differs from similar sibling tools.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any meaningful parameter semantics beyond what's already in the schema (selector types, text content, strategy options). It doesn't explain relationships between parameters or provide examples of valid selector formats.

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 ('send text input') and target ('to a UI element'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'send-keys-by-ios-class-chain' or 'send-keys-to-device', which appear to be similar text-input tools with different targeting methods.

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

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

No guidance is provided about when to use this tool versus alternatives like 'send-keys-by-ios-class-chain' or 'send-keys-to-device'. The description doesn't mention prerequisites (e.g., whether an element must be focused or visible) or context about when text input is appropriate versus other interaction methods.

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 but offers minimal behavioral insight. It doesn't disclose what happens on failure (e.g., timeout behavior), whether the tool waits for element visibility, if it clears existing text first, or any side effects. 'Send text' implies a write operation, but safety implications are unspecified.

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?

Extremely concise single sentence with zero wasted words. Every component ('Send text', 'to an element', 'using iOS class chain', 'iOS only') serves a distinct purpose. The structure is front-loaded with the core action immediately clear.

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

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

For a 3-parameter tool with no annotations and no output schema, the description is inadequate. It doesn't explain what happens on success/failure, return values, error conditions, or interaction patterns. Given the complexity of mobile automation and multiple sibling alternatives, more context about when and how to use this specific tool is needed.

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%, providing complete parameter documentation. The description adds no additional parameter semantics beyond what's in the schema - it mentions 'iOS class chain' and 'text' but provides no extra context about format, constraints, or usage patterns. Baseline 3 is appropriate when schema does all the work.

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 ('Send text') and target ('to an element using iOS class chain'), with platform specificity ('iOS only'). It distinguishes from generic 'send-keys' by specifying the iOS class chain method, but doesn't explicitly differentiate from sibling 'send-keys-by-ios-predicate' which serves a similar purpose with a different locator strategy.

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 minimal guidance - it mentions 'iOS only' which helps exclude non-iOS contexts, but offers no explicit when-to-use advice versus alternatives like 'send-keys-by-ios-predicate' or regular 'send-keys'. No prerequisites, error conditions, or performance considerations 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Send text') which implies a write operation, but doesn't describe what happens on failure (e.g., if element not found), whether it waits for element visibility, how it handles existing text, or error conditions. The timeout parameter suggests some waiting behavior, but this isn't explained in the description 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, efficient sentence that communicates the core purpose, method, and platform constraint without any wasted words. It's appropriately sized for a focused tool and front-loads the essential information.

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

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

For a 3-parameter tool with no annotations and no output schema, the description provides basic purpose and platform context but lacks behavioral details about how the operation works, what it returns, or error handling. Given the complexity of mobile automation and the presence of many sibling tools, more context about when and how to use this specific tool 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 description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter information beyond what's in the schema (predicateString, text, timeoutMs). The baseline score of 3 is appropriate when the schema does the heavy lifting for parameter documentation.

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

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

The description clearly states the action ('Send text') and target ('to an element'), and specifies the platform constraint ('iOS only'). It distinguishes from generic 'send-keys' by mentioning the iOS predicate string method, but doesn't explicitly differentiate from sibling 'send-keys-by-ios-class-chain' which serves a similar purpose with a different locator strategy.

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

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

The description implies usage context through 'iOS only' and 'using iOS predicate string', suggesting it's for iOS automation with predicate-based element location. However, it doesn't provide explicit guidance on when to choose this over alternatives like 'send-keys-by-ios-class-chain' or regular 'send-keys', nor does it mention prerequisites like needing an active Appium session or iOS device/simulator.

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 mentions 'without focusing on any element', which hints at a behavioral trait (bypassing UI focus), but doesn't disclose critical details like whether this requires device unlock, what happens if the device is locked, whether it's safe for automation, or if there are rate limits. For a tool that sends input to a device with zero annotation coverage, this is insufficient.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and includes a key behavioral note ('without focusing on any element'). Every word earns its place, making it appropriately sized for a simple tool.

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

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

Given the complexity (device interaction tool with potential side effects), no annotations, no output schema, and minimal description, this is incomplete. The description doesn't cover what the tool returns, error conditions, or important behavioral constraints. For a tool that could affect device state, more context is needed to use it safely and effectively.

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

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

The schema description coverage is 100% with one parameter ('text'), and the description doesn't add any parameter-specific information beyond what's in the schema. The baseline is 3 when the schema does the heavy lifting, but the description could have clarified what 'text' means in this context (e.g., raw keyboard input vs. commands).

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

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

The description states the tool 'Send keys directly to the device without focusing on any element', which provides a clear verb ('send keys') and resource ('device'), but it's somewhat vague about what 'keys' means (text input vs. keyboard keys) and doesn't distinguish from sibling tools like 'send-keys' or 'send-key-event'. It's not tautological but lacks specificity compared to other device interaction 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 provides minimal guidance: it mentions 'without focusing on any element', which implies this is for raw input rather than element-specific interaction. However, it doesn't explain when to use this versus alternatives like 'send-keys' (which might require element focus) or 'send-key-event' (which might send hardware key codes). No explicit when/when-not rules or prerequisite context 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 full burden for behavioral disclosure. While 'Set' implies a mutation operation, the description doesn't disclose whether this requires specific device states, what happens if orientation change fails, whether the change persists, or any side effects. For a mutation tool with zero annotation coverage, this is inadequate.

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 maximally concise with a single clear sentence that states the tool's purpose without any wasted words. It's front-loaded with the essential information and contains no unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after setting orientation, whether there's confirmation feedback, error conditions, or device compatibility requirements. Given the complexity of device control operations and the rich sibling tool ecosystem, this description leaves too much unspecified.

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

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

With 100% schema description coverage, the input schema already fully documents the single parameter 'orientation' with its enum values. The description adds no additional parameter information beyond what's in the schema, so it meets the baseline but doesn't provide extra 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 ('Set') and target ('device orientation'), providing a specific verb+resource combination. However, it doesn't differentiate from its sibling tool 'get-orientation' (which presumably reads rather than sets orientation), missing the opportunity to clarify this 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 guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (like device state), when this operation is appropriate, or what happens if the device doesn't support orientation changes. With many sibling tools available, this lack of contextual guidance is a significant gap.

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. While 'simulate' implies this is a non-destructive action that mimics user behavior, it doesn't specify whether this requires specific device states, what happens if the device is locked, or any side effects. The iOS-only constraint is helpful but insufficient for a tool with zero annotation coverage.

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

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

The description is perfectly concise - a single parenthetical phrase that communicates both the core function and the platform limitation. Every word earns its place with zero waste or redundancy.

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

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

For a zero-parameter tool with no output schema, the description provides the essential 'what' and platform constraint. However, given the complex mobile testing context with many sibling tools and no annotations, it should ideally clarify the relationship to 'xcode_shake_device' and provide more behavioral context about when and how to use this simulation.

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 0 parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't waste space discussing parameters that don't exist, earning a baseline score of 4 for parameter-free 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?

The description clearly states the action ('simulate shake gesture') and specifies the platform constraint ('iOS only'), which distinguishes it from generic gesture tools. However, it doesn't explicitly differentiate from the sibling tool 'xcode_shake_device', which appears to serve a similar function in the Xcode simulator context.

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

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

The description provides minimal guidance - it only indicates this is for iOS devices. No information is given about when to use this tool versus alternatives like 'xcode_shake_device' or other gesture tools in the sibling list, nor any prerequisites or context for when shaking simulation is 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 provided, the description carries full burden but lacks critical behavioral details. It mentions trying different locator strategies but doesn't specify what those strategies are, the order, error handling, or performance implications. For a tool that interacts with UI elements, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that conveys the core functionality without unnecessary words. It's appropriately sized and front-loaded with the main action, making it easy to understand at a glance.

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

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

For a tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'intelligently' means in practice, what happens on success/failure, or how it differs from simpler tap tools. Given the complexity of UI automation, more context is needed for effective 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 parameters are well-documented in the schema. The description doesn't add any additional meaning about parameters beyond what's in the schema, maintaining the baseline score of 3 for adequate but not enhanced parameter semantics.

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 ('intelligently tap') and target ('an element'), specifying it uses different locator strategies in a specific order. It distinguishes from simpler tap tools like 'tap-element' by emphasizing intelligent fallback strategies, though it doesn't explicitly name alternatives.

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

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

The description implies usage when standard tapping might fail due to locator issues, suggesting it's for robust element interaction. However, it doesn't explicitly state when to use this over alternatives like 'tap-element' or 'inspect-and-tap', nor does it mention prerequisites or exclusions.

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

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

No annotations are provided, so the description carries full burden. While 'Start recording' implies a write/mutation operation, it doesn't disclose behavioral traits like whether recording begins immediately, what happens if recording is already active, permission requirements, or side effects. This leaves significant gaps for a tool that initiates a potentially resource-intensive process.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a straightforward tool and front-loads the core functionality without unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after starting recording (e.g., returns a recording ID, starts immediately in background), error conditions, or interaction with sibling tools like 'stop-recording'. The minimal description leaves too many operational questions unanswered.

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