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 checks readiness but doesn't explain what 'ready' means, whether it's a read-only operation, what happens if the session isn't ready, or any error conditions. This leaves significant gaps in understanding 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, clear sentence with no wasted words. It's front-loaded with the core purpose and efficiently communicates the essential function without unnecessary elaboration, 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 session management and lack of annotations or output schema, the description is incomplete. It doesn't explain what 'ready' entails, what the return value indicates, or how it integrates with sibling tools like 'detox.session.start' and 'detox.session.stop', leaving the agent with insufficient context 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?

The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately doesn't mention parameters, and since there are none, it doesn't need to compensate for any gaps, earning a baseline score above 3.

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

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

The description clearly states the tool's purpose as 'Check if Detox session is ready' with a specific verb ('Check') and resource ('Detox session'), making it immediately understandable. However, it doesn't distinguish itself from potential alternatives like 'expo.status' or clarify what constitutes 'ready' versus other session states.

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., after starting a session), exclusions, or how it differs from sibling tools like 'detox.session.start' or 'expo.status', leaving the agent to infer 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 the full burden of behavioral disclosure. It states the tool starts a session and that it's required before UI actions, which implies it's a setup/mutation operation. However, it doesn't disclose other behavioral traits like what happens if a session already exists, error conditions, or what 'starting' entails beyond the schema's reuse parameter.

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

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

The description is extremely concise with just two sentences, both of which earn their place. The first sentence states the core purpose, and the second provides critical usage context. There's no wasted language 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?

Given the tool has 2 parameters with full schema coverage but no annotations or output schema, the description provides adequate basic context about purpose and prerequisites. However, for a session management tool that likely involves state changes and has implications for other tools, more behavioral context would be helpful to understand what 'starting' entails and how it integrates with the sibling UI 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 the schema already documents both parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score of 3. It doesn't compensate with additional context about parameter interactions or usage examples.

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 specific action ('Start a Detox testing session') and resource ('session'), distinguishing it from siblings like detox.session.stop. It also mentions the prerequisite nature ('Required before running UI actions'), which adds important context about its role in the workflow.

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

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

The description provides clear context on when to use this tool ('Required before running UI actions'), indicating it's a prerequisite for UI interaction tools. However, it doesn't explicitly state when not to use it or name specific alternatives among siblings, though the context implies it's foundational for subsequent UI operations.

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 action without behavioral details. It doesn't disclose effects (e.g., whether it terminates processes gracefully, cleans up resources, or requires specific permissions), rate limits, or error conditions, which are critical for a session-stopping operation.

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

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

The description is a single, direct sentence with zero waste—it states exactly what the tool does without fluff. It's front-loaded and efficiently communicates the core purpose, 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 stopping a testing session (a mutation with potential side-effects), the description is incomplete. With no annotations, no output schema, and minimal behavioral disclosure, it lacks details on outcomes, errors, or dependencies, leaving significant gaps 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 coverage, so no parameter documentation is needed. The description appropriately avoids redundant parameter info, earning a high baseline score for not cluttering with 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 action ('Stop') and target resource ('the current Detox testing session'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'expo.stop' or 'simulator.shutdown' that might also stop related processes, which prevents 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., requires an active session started with 'detox.session.start'), exclusions, or relationships with sibling tools, leaving the agent to infer context from 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get recent Expo/Metro logs' implies a read-only operation, but it doesn't specify whether this is real-time streaming, historical retrieval, or if it requires specific permissions. It also doesn't mention rate limits, error conditions, or what 'recent' means in practice. The description is too vague for a tool with no annotation support.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to scan and understand quickly. Every word earns its place, and there's no unnecessary elaboration 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?

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., log format, timestamps, error messages) or behavioral aspects like whether it streams logs or returns a static snapshot. For a logging tool with no structured support, the description should provide more context about output and usage patterns to be fully helpful.

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 'lines' parameter fully documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema, such as typical values or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't need to given the schema's completeness.

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 ('recent Expo/Metro logs'), making the tool's purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'simulator.log_stream.start' or 'simulator.log_stream.stop', which also handle logs but for different systems. The description is specific enough to understand what the tool does but lacks 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. It doesn't mention prerequisites, timing considerations, or comparisons to sibling tools like 'simulator.log_stream.start' or 'expo.status'. Without any usage context, the agent must infer when this tool is appropriate based on the name and description 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 the full burden of behavioral disclosure. It mentions the action ('Reload') but doesn't explain what reloading entails (e.g., whether it restarts the app, refreshes content, or resets state), potential side effects, or error conditions. This leaves significant gaps in understanding 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 with no wasted words. It's front-loaded with the core action and target, making it easy to parse quickly. Every word earns its place in conveying 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?

Given the complexity of a reload operation (which could involve app state changes or errors), the description is incomplete. With no annotations, no output schema, and minimal behavioral details, it fails to provide enough context for safe or effective use, especially compared to more detailed sibling tools like 'expo.logs.tail' or 'simulator.screenshot'.

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 the input schema has 100% description coverage (though empty). The description doesn't need to add parameter details, so it meets the baseline of 4 for tools with no parameters, as there's nothing to compensate for.

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 ('Reload') and target ('the app in the simulator'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'expo.start' or 'expo.stop', which limits its score to 4 rather than 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 like 'expo.start' or 'expo.stop', nor does it mention prerequisites (e.g., whether the app must already be running). It only states what the tool does, not when to invoke it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Start' implies an action that initiates a server, it doesn't describe what happens after starting (e.g., server runs in background, outputs logs, requires manual stop), potential side effects, or any constraints like permissions or rate limits. This leaves significant gaps for a tool that likely has ongoing effects.

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

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

The description is a single, focused sentence that directly communicates the tool's purpose without any 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 complexity of starting a development server (which likely has behavioral nuances and ongoing effects), the absence of annotations, and no output schema, the description is insufficient. It doesn't explain what the tool returns, how to verify success, or any operational details, leaving the agent with incomplete context for proper 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 the single parameter 'clearCache' fully documented in the schema. The description adds no additional parameter information beyond what's already in the structured data, so it meets 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 ('Start') and the target resource ('Expo/Metro development server'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'expo.status' or 'expo.stop', 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 'expo.reload' or 'expo.stop', nor does it mention prerequisites or appropriate contexts. It merely states what the tool does without indicating when it should be invoked.

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 but lacks behavioral details like whether this is a read-only operation, if it requires specific permissions, what the response format might be (e.g., JSON with status codes), or any rate limits. This leaves gaps in understanding how the tool behaves.

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 any wasted words. It's front-loaded and appropriately sized for a simple, parameterless 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's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. However, it could be more complete by specifying the return type (e.g., status indicators like 'running' or 'stopped') or clarifying its role among sibling tools, which would help in a richer context.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, earning a baseline score of 4 as it doesn't need to compensate for any schema gaps.

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

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

The description clearly states the verb 'Get' and the resource 'current status of Expo/Metro', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'expo.logs.tail' or 'expo.start', which could provide overlapping status information in different ways.

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 'expo.logs.tail' for real-time logs or 'expo.start' for initiating Expo, there's no indication of when 'expo.status' is preferred, such as for a quick health check without detailed logs.

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 clearly indicates a destructive action ('Stop') that will terminate the server, which is useful context. However, it doesn't mention potential side effects (e.g., stopping related processes, impact on connected devices) or error conditions, leaving some behavioral aspects unclear.

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 that states the tool's purpose without any fluff. It's front-loaded with the core action and resource, making it highly efficient and easy to parse. Every word earns its place in 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 tool's simplicity (0 parameters, no output schema, no annotations), the description is complete enough for a basic stop operation. It clearly states what the tool does. However, it could be more complete by mentioning what happens after stopping (e.g., no return value, confirmation message) or linking to sibling tools for related actions, but this is a minor gap.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't mention parameters, which is appropriate. A baseline of 4 is applied as it correctly handles the absence of parameters without adding unnecessary 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 action ('Stop') and the target resource ('Expo/Metro development server') with a specific verb+resource combination. It distinguishes from siblings like 'expo.start' (which starts the server) and 'expo.status' (which checks status), making the purpose unambiguous.

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

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

The description implies usage when the server is running and needs to be stopped, but doesn't explicitly state when to use it versus alternatives (e.g., 'expo.reload' for restarting without full stop, or 'expo.status' to check if it's running first). It provides basic context but lacks explicit guidance on 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 the full burden of behavioral disclosure. It mentions execution but lacks critical details: whether it's read-only or destructive (e.g., could modify system state via nested tools), error handling beyond the 'stopOnError' parameter, or performance implications like rate limits. This leaves significant gaps for a tool that orchestrates other tools.

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 a single, front-loaded sentence: 'Execute a sequence of tool calls (macro flow)'. Every word earns its place by defining the core action and scope without redundancy or fluff, making it efficient 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 complexity of executing multiple tool calls and the lack of annotations and output schema, the description is incomplete. It doesn't address behavioral risks (e.g., nested destructive operations), return values, or error formats, which are crucial for safe and effective use in an automated workflow 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 the two parameters ('steps' and 'stopOnError'). The description adds no meaning beyond this, such as explaining the structure of 'steps' or practical examples. However, with high schema coverage, 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 states the tool 'Execute[s] a sequence of tool calls (macro flow)', which provides a clear verb ('Execute') and resource ('sequence of tool calls'). However, it doesn't distinguish this from sibling tools, which are all individual action tools (e.g., ui.tap, simulator.boot) rather than flow execution tools, so the differentiation is implicit rather than explicit.

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, such as needing valid tool names from the sibling list, or specify use cases like automating multi-step workflows. Without this context, an agent might misuse it for single-step operations.

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. It states the action ('Boot') but doesn't describe what happens during booting (e.g., startup time, state changes), potential errors (e.g., device not found), side effects, or output format. 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 resource, making it immediately scannable and appropriately sized for the tool's apparent simplicity.

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 mutation nature (boot implies state change), lack of annotations, no output schema, and incomplete behavioral disclosure, the description is insufficient. It doesn't cover what 'boot' entails operationally, success/failure indicators, or interaction with sibling tools like simulator.shutdown. For a tool that likely affects system state, 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 the single parameter 'device' documented in the schema as 'Device name or UDID. Defaults to config defaultDeviceName.' The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline of 3 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 ('Boot') and target resource ('an iOS simulator device'), making the purpose immediately understandable. It distinguishes from siblings like simulator.shutdown (opposite action) and simulator.list_devices (different operation). However, it doesn't specify what 'boot' entails operationally beyond starting the device.

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

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

No explicit guidance on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites (e.g., device must exist/be available), when-not-to-use scenarios, or direct alternatives like simulator.list_devices for checking device status first. Usage is implied from the action 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 the full burden of behavioral disclosure. It mentions the destructive action ('factory reset') but fails to detail critical aspects like whether this requires elevated permissions, the time it takes, confirmation prompts, or error handling. For a high-impact mutation tool, 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, front-loaded sentence that efficiently conveys the core action without unnecessary elaboration. Every word earns its place, making it easy for an agent to parse and understand the tool's primary function immediately.

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 high complexity (destructive factory reset), lack of annotations, and no output schema, the description is insufficient. It omits critical context such as the irreversible nature of the operation, potential side effects (e.g., data loss), success/failure indicators, or recovery steps, 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 100% description coverage, with the 'device' parameter fully documented. The description does not add any semantic details beyond the schema (e.g., examples of device names, UDID format, or validation rules), so it meets the baseline of 3 where 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 specific action ('Erase all content and settings') and the target resource ('from a simulator'), using the precise verb 'factory reset' to distinguish it from other simulator operations like boot, shutdown, or screenshot. It effectively communicates the tool's destructive nature and scope.

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 (e.g., simulator.shutdown for temporary deactivation or simulator.list_devices for device selection). It lacks context about prerequisites (e.g., simulator must be booted) or exclusions (e.g., irreversible effects), leaving the agent to infer usage scenarios.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it indicates this is a read operation (listing), it doesn't describe what 'states' means, whether the list includes offline/online devices, if there are permission requirements, or how results are formatted. For a 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 a single, efficient sentence that communicates the core purpose without any wasted words. It's appropriately sized for a simple enumeration 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?

Given the tool's simplicity (no parameters, no output schema, no annotations), the description provides adequate basic information about what the tool does. However, without annotations or output schema, it should ideally provide more behavioral context about what 'states' includes and the format of returned data to be fully complete.

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

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

The tool has zero 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, which is correct for a parameterless tool. 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 specific verb ('List') and resource ('all available iOS simulator devices and their states'), making the purpose immediately understandable. It distinguishes this tool from siblings like simulator.boot or simulator.shutdown by focusing on enumeration rather than device control operations.

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

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

The description implies usage context (when you need to see available devices and their states) but doesn't explicitly state when to use this versus alternatives. No guidance is provided about prerequisites, timing considerations, or comparisons with other device-related tools in the sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but lacks critical details: it doesn't specify if this starts a continuous stream (implying ongoing resource use), what format/log-level the logs are in, whether authentication or specific simulator states are required, or how to access the streamed data. For a streaming operation 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 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 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 of a streaming operation (which implies ongoing processes and potential resource consumption), the description is incomplete. With no annotations and no output schema, it fails to explain what 'start streaming' entails behaviorally—such as how logs are delivered, if there are side effects, or what the agent should expect after invocation. This is inadequate for guiding proper tool 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 tool has 0 parameters, and schema description coverage is 100% (though trivial since there are no parameters). The description doesn't need to add parameter semantics, so it meets the baseline expectation. No additional value is required or provided beyond the empty schema.

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

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

The description clearly states the action ('Start streaming') and resource ('simulator system logs'), providing a specific verb+resource combination. However, it doesn't distinguish itself from its sibling 'simulator.log_stream.stop' beyond the obvious action difference, nor does it differentiate from other logging tools like 'expo.logs.tail' in terms of scope or purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a running simulator), when-not-to-use scenarios, or comparisons with sibling tools like 'expo.logs.tail' or 'simulator.log_stream.stop'. 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 the full burden. It states the action but lacks details on behavioral traits such as whether it requires specific permissions, what happens if no stream is active, or if it returns confirmation. This leaves significant gaps for a mutation 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 that directly states the tool's function without unnecessary words. It is front-loaded and wastes no space, 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), the description is adequate but incomplete. It lacks behavioral context needed for a mutation tool with no annotations, such as error conditions or side effects, leaving room for improvement in 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?

With 0 parameters and 100% schema description coverage, the schema fully documents the input structure. The description adds no parameter details, which is acceptable here as there are no parameters to explain, 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 clearly states the action ('Stop streaming') and the resource ('simulator system logs'), making the purpose immediately apparent. It distinguishes from its sibling 'simulator.log_stream.start' by specifying the opposite operation, providing clear 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 implies usage context by referencing 'streaming' logs, suggesting it should be used after starting a log stream. However, it does not explicitly state when to use it versus alternatives or mention prerequisites like needing an active stream first.

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 ('Start recording') but lacks details on permissions, file storage location, format, duration limits, or error conditions. This is a significant gap for a tool that initiates a recording 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, direct sentence that efficiently conveys the core action without unnecessary words. It's front-loaded with the key information, 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 complexity of starting a video recording (a stateful operation with potential side effects), no annotations, and no output schema, the description is incomplete. It doesn't cover what happens after starting (e.g., how to stop, file output details), making it inadequate for full contextual 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?

Schema description coverage is 100%, with the single parameter 'name' documented in the schema as 'Name prefix for the video file.' The description doesn't add any additional meaning beyond this, such as examples or constraints, so it meets the baseline for high schema coverage without 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 specific action ('Start recording') and the target resource ('video of the simulator screen'), making the purpose immediately understandable. It distinguishes itself from sibling tools like 'simulator.record_video.stop' by specifying the initiation of recording rather than termination.

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 by specifying 'simulator screen,' suggesting it's for recording simulator activities, but it doesn't explicitly state when to use this tool versus alternatives like 'simulator.screenshot' or 'ui.screenshot' for different capture needs. No guidance on prerequisites or exclusions 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 mentions the action ('stop') and outcome ('save the file'), but lacks details like where the file is saved, format, permissions needed, or error conditions. For a mutation 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 a single, efficient sentence with zero waste—every word contributes to understanding the tool's purpose. It's front-loaded with the core action and outcome, 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 (simple stop action), no output schema, and zero parameters, the description is minimally adequate. However, as a mutation tool with no annotations, it should ideally include more behavioral context (e.g., file location, errors) to be fully complete for 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?

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description doesn't need to add parameter details, and it appropriately focuses on the action without unnecessary parameter explanation, meeting the baseline 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 specific action ('Stop video recording') and outcome ('save the file'), distinguishing it from sibling tools like 'simulator.record_video.start' and 'simulator.screenshot'. It uses precise verbs and identifies the resource being acted upon.

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 by referencing 'video recording', suggesting it should be used after starting a recording with 'simulator.record_video.start'. However, it doesn't explicitly state when-not to use it or name alternatives, leaving some guidance implicit rather than explicit.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but doesn't describe important behavioral aspects: where the screenshot is saved, what format it's in, whether it requires specific simulator states, or what happens if the simulator isn't booted. 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 extremely concise - a single sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized for a simple screenshot 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?

Given the tool's simplicity (1 parameter, no output schema, no annotations), the description is minimally adequate but has clear gaps. It doesn't explain where screenshots are saved, what happens if the simulator isn't booted, or how this differs from 'ui.screenshot'. For a tool with no output schema and no annotations, more contextual information would be helpful.

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 single parameter 'name' clearly documented as 'Name prefix for the screenshot file.' The description doesn't add any parameter information beyond what the schema provides, which is acceptable given the high schema coverage. The baseline of 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 action ('Take a screenshot') and target ('of the booted simulator'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from 'ui.screenshot' in the sibling list, which appears to be a similar screenshot tool but for UI elements rather than the simulator 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 minimal guidance - it implies the simulator must be booted (from 'booted simulator'), but doesn't explicitly state prerequisites or when to use this vs. alternatives like 'ui.screenshot'. No explicit when/when-not guidance or alternative recommendations are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Shut down') but doesn't clarify what this entails—whether it's a graceful shutdown, immediate termination, reversible, or has side effects (e.g., losing state). 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, direct sentence with zero wasted words. It's front-loaded with the core action and resource, making it highly efficient and easy to parse. Every word earns its place.

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

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

Given the tool's complexity (a mutation with potential side effects), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral details, error conditions, or what happens post-shutdown (e.g., device state). For a tool that alters system state, more context is needed 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 parameter 'device' fully documented in the schema (including default behavior if unspecified). The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline for high 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 ('Shut down') and target resource ('an iOS simulator device'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'simulator.erase' (which might also stop a device) or 'detox.session.stop' (which might involve simulator shutdown), 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. It doesn't mention prerequisites (e.g., whether the device must be booted first), exclusions, or relationships to siblings like 'simulator.boot' or 'simulator.erase'. The agent must infer usage from context 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 'assert' which implies a verification/validation behavior, but doesn't disclose what happens on failure (does it throw an error? return boolean?), timeout behavior, or whether it modifies UI state. For a verification tool with zero annotation coverage, this is insufficient behavioral disclosure.

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

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

Perfectly concise single sentence that states the core functionality. No wasted words, front-loaded with the main purpose. Every word earns its place in this minimal description.

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 testing assertion tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'assert' means operationally (pass/fail behavior), doesn't mention typical testing contexts, and provides no guidance on selector strategies despite the complex nested selector parameter. Should do more given the testing domain complexity.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add any parameter semantics beyond what's in the schema - it doesn't explain selector strategies, text matching nuances, or provide examples. 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 tool's purpose: 'Assert that an element has specific text content'. It uses a specific verb ('assert') and resource ('element'), but doesn't differentiate from siblings like ui.wait_for (which might also involve text verification). The purpose is unambiguous 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?

No guidance on when to use this tool versus alternatives like ui.wait_for or ui.tap. The description doesn't mention prerequisites, error conditions, or typical testing scenarios. It provides no context about when this assertion should be preferred over other UI interaction 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 the action but doesn't mention side effects (e.g., triggering context menus), error handling, or performance implications. This is inadequate for a UI interaction tool with potential side effects.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, 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 and no output schema, the description is incomplete. It doesn't explain what happens after the long press (e.g., UI changes, return values) or address potential complexities like element visibility or timing issues, which are critical for UI testing 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%, with clear documentation for 'selector' and 'duration'. The description adds no extra meaning beyond the schema, such as examples or edge cases, but the schema is comprehensive, so a 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 'Long press on an element' clearly states the action (long press) and target (an element), but it's vague about the context (e.g., mobile UI testing) and doesn't differentiate from siblings like 'ui.tap' or 'ui.swipe'. It provides a basic purpose but lacks specificity.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'ui.tap' for short taps or 'ui.swipe' for swipes. The description offers 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('press') but doesn't describe what 'press' entails (e.g., duration, effect on UI, whether it's a single key event), potential side effects, or error conditions. This leaves significant gaps for a tool that interacts with UI elements.

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, efficient sentence that directly states the tool's purpose with zero wasted words. It's front-loaded with the core action and immediately specifies the allowed keys.

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 for a UI interaction tool. It lacks details on behavioral traits (e.g., what 'press' means operationally), expected outcomes, error handling, and how it fits within the broader UI testing context alongside siblings like ui.tap or ui.type.

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 'key' parameter fully documented via enum and description. The description adds no additional parameter semantics beyond what the schema provides (it merely repeats the allowed keys). Baseline 3 is appropriate when the 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 ('press') and resource ('special key'), specifying the allowed keys (return, backspace, delete). It distinguishes from sibling tools like ui.tap or ui.type by focusing on special keys rather than taps or text input. However, it doesn't explicitly differentiate from all siblings (e.g., ui.long_press also involves key/button actions).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when pressing a special key is appropriate compared to other UI interaction tools like ui.tap, ui.type, or ui.long_press, nor does it specify any prerequisites or exclusions for 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 mentions the action ('Take a screenshot') but doesn't describe what happens after capture (e.g., where files are saved, format, permissions needed, or error conditions). For a tool that presumably creates files, this lack of behavioral context 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 that communicates the core purpose without unnecessary words. It's front-loaded with the main action and includes implementation detail only where relevant. Every word earns its place in this compact formulation.

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 (file creation with no output schema) and absence of annotations, the description is insufficient. It doesn't explain what the tool returns, where screenshots are saved, what format they're in, or error handling. For a tool that presumably produces output files, this leaves critical 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 schema has 100% description coverage for its single parameter, so the baseline is 3. The description adds no additional parameter information beyond what's in the schema (which already explains 'name' is a file prefix with default 'screenshot'). No syntax, format, or constraint details are provided 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 specific action ('Take a screenshot') and target resource ('current UI state'), with additional implementation detail ('via simctl') that distinguishes it from sibling tools like 'simulator.screenshot'. It uses a precise verb-noun structure that leaves no ambiguity about the tool's 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?

The description provides no guidance on when to use this tool versus alternatives like 'simulator.screenshot' or other UI interaction tools. It doesn't mention prerequisites (e.g., requires a running simulator), appropriate contexts, or limitations. The agent must infer usage from the tool name and context 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 for behavioral disclosure. It mentions scrolling but doesn't specify whether this is a simulated user action, how it interacts with UI elements, error conditions, or what happens if the element isn't scrollable. This leaves significant gaps in understanding 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 without unnecessary words. It's appropriately sized and front-loaded with 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 3 parameters and no annotations or output schema, the description is minimally adequate but lacks important context about behavioral expectations, error handling, and differentiation from similar tools. It meets basic requirements but leaves significant gaps.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning about parameters beyond what's in the schema, maintaining 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 ('scroll') and target ('within a scrollable element'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'ui.swipe' which might have overlapping functionality for scrolling, 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 like 'ui.swipe' for scrolling, nor does it mention prerequisites or context for usage. It simply states what the tool does without indicating appropriate scenarios.

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

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

With no annotations, the description carries the full burden but provides minimal behavioral insight. It doesn't disclose that this is a UI interaction tool likely for mobile testing, potential side effects (e.g., triggering navigation), or error conditions (e.g., if the element isn't found). It mentions direction but omits details like swipe distance or speed defaults.

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. However, it's under-specified rather than concise—it could benefit from a bit more context without losing brevity. It's front-loaded but lacks depth.

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 (4 parameters, nested objects, no output schema) and lack of annotations, the description is incomplete. It doesn't cover the tool's role in UI testing, expected outcomes, or error handling. Sibling tools suggest a mobile testing context, but this isn't addressed, leaving gaps for 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?

Schema description coverage is 100%, so the schema fully documents parameters like selector, direction, speed, and percentage. The description adds no meaning beyond the schema, as it doesn't explain parameter interactions or provide examples. Baseline is 3 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 'Swipe on an element in a direction' states the basic action (swipe) and target (element), but is vague about the context (e.g., mobile UI testing) and doesn't differentiate from sibling tools like ui.scroll or ui.long_press. It lacks specificity about what 'swipe' means operationally.

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 ui.scroll for scrolling or ui.tap for tapping. The description doesn't mention prerequisites, such as needing an active UI session or element visibility, nor does it suggest scenarios where swiping is appropriate (e.g., navigating carousels).

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 ('Tap') but doesn't explain what happens after tapping (e.g., triggers a UI event, may navigate, could fail if element not found), nor does it cover error handling, timing, or side effects. This is inadequate for a UI interaction 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 is front-loaded and wastes no space, 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 complexity of a UI interaction tool with no annotations and no output schema, the description is insufficient. It doesn't explain the result of tapping (e.g., success/failure indicators, return values), error conditions, or integration with sibling tools, 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?

Schema description coverage is 100%, so the schema already documents all parameters (selector, x, y) with details like enums for 'by'. The description adds no additional meaning beyond implying a selector is used, which is already clear from the schema. 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 action ('Tap') and target ('on an element identified by selector'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'ui.long_press' or 'ui.press_key' which are also UI interaction tools, so it misses the highest score for 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 'ui.long_press' or 'ui.swipe'. It lacks context about typical use cases, prerequisites, or exclusions, leaving the agent with minimal direction.

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 basic action but doesn't mention important behavioral aspects like whether this requires UI focus, what happens if the selector doesn't match, whether it waits for the element to appear, or any error conditions. This leaves significant gaps for a mutation tool.

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

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

The description is extremely concise - a single 5-word sentence that directly states the tool's purpose. There's zero wasted language, and it's perfectly front-loaded with 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 mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what happens on success/failure, doesn't mention dependencies (like needing an active UI session), and provides no behavioral context beyond the basic action. Given the complexity of UI automation, this leaves too many unanswered questions.

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 baseline is 3. The description doesn't add any parameter-specific information beyond what's already documented in the schema (selector object structure, text parameter, replace default behavior). It simply restates the core action 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 ('type text') and target ('into an input element'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from similar UI interaction siblings like ui.tap or ui.press_key, which prevents 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. There's no mention of prerequisites (e.g., needing an active session), when not to use it, or how it differs from other text input methods like ui.press_key for keyboard input.

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 waiting for visibility or existence but lacks details on behavior: e.g., whether it polls continuously, returns on success/failure, throws errors on timeout, or interacts with the UI state. This is a significant gap for a tool with potential side effects.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded and directly conveys the core functionality without unnecessary elaboration, 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 and no output schema, the description is incomplete. It doesn't explain return values (e.g., success/failure indicators), error handling, or dependencies (e.g., requiring a UI session). For a tool that interacts with dynamic UI elements, this leaves critical gaps for an agent.

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

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

Schema description coverage is 100%, so the schema fully documents the parameters (selector, visible, timeout). The description adds no additional meaning beyond what's in the schema, such as examples or edge cases. 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 tool's purpose with a specific verb ('wait for') and resource ('an element'), specifying the condition ('to be visible or exist'). It doesn't distinguish from siblings like ui.assert_text or ui.tap, which have different purposes, but the core functionality is well-defined.

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 waiting on UI elements, but it doesn't mention prerequisites (e.g., needing an active session) or compare it to siblings like ui.assert_text (which might assert without waiting).

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