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 explains that the press does not activate the session app, that nothing is re-observed so state is preserved, that the system's response is not observed, and that the command times out after 90 seconds. This is unusually thorough.

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

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

The description is three focused sentences with no filler. The core action is front-loaded, followed by the most important behavioral caveat and the timeout. Every sentence adds information an agent needs.

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

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

The tool has no annotations but has a rich input schema and an output schema. The description covers the essential non-obvious runtime behavior: side-effect scope, observation behavior, simulator limitations, verification constraints, and timeout. Nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, so the baseline applies: the schema already explains every parameter. The description adds no parameter-specific guidance, which is acceptable because the structured 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 opens with a specific verb and resource: 'Press the iPhone or iPad Action Button once.' It also differentiates the action from generic siblings by noting the press is dispatched without activating the session app and that nothing is re-observed afterwards, making the tool's scope unmistakable.

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

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

The description gives clear context for when the tool is meaningful, notably that delivery to a Shortcut is verifiable only on a physical iPhone and that simulators run no Shortcuts or App Intents. It does not explicitly name alternative sibling tools or state 'use this instead of X', but the practical when/when-not context is present.

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 discloses that each iOS XCTest execution 'activates once, then only observes,' that the tool 'Times out after 90s,' and that accept/dismiss change state. This is valuable behavioral context beyond what the schema conveys. It does not describe the return format or error behavior, but the core behavioral traits are transparent.

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

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

The description is three sentences with no redundancy. It front-loads the core purpose, then provides usage guidance, and finally behavioral caveats. Every sentence adds value, and the structure is compact and well-ordered.

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 18 parameters and no output schema, the description covers the essential behavioral aspects: action selection, state changes, timeout behavior, and the execution model. It lacks information about the response format, but given the schema's high coverage and the tool's specific scope, this is a minor gap. It is sufficiently complete for an agent to call the tool correctly.

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

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

Schema description coverage is 89%, so the schema already documents most parameters. The description adds no parameter-specific details beyond the action semantics ('Use get before acting...'), but the schema's enum for action already explains the possible values. Since the schema covers the parameters well, a baseline score of 3 is appropriate; the description does not need to compensate for low coverage.

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

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

The description clearly states the tool's core function: 'Inspect, wait for, accept, or dismiss a platform alert.' It names the resource (platform alert) and the specific verbs (get, wait, accept, dismiss), making its purpose unambiguous. It distinguishes itself from generic sibling tools like 'get' or 'wait' by being alert-specific, and the action enum is 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 provides explicit usage guidance: 'Use get before acting when the alert content matters; accept and dismiss change the active alert state.' It also warns about the timeout behavior and advises to 'Inspect again after an unconfirmed action.' This gives clear when-to-use directives for each action and cautions against misinterpretation of timeouts, which is exactly the kind of guidance needed.

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

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

With no annotations provided, the description carries the behavioral burden; it does disclose a 90s timeout, which is useful operational context. However, it does not state side effects, default filtering behavior, or failure modes beyond the timeout, and the system/OEM sentence reads more like policy than 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?

Two sentences, front-loaded with the action, then a scoping rule and timeout. There is no filler; every clause 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 output schema and 100% parameter coverage, the description does not need to explain return values or selector semantics. It includes the non-obvious operational constraint (90s timeout) and the policy on system/OEM apps, which is sufficient for a low-complexity listing tool.

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

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

Schema description coverage is 100%, so the schema fully documents all 16 parameters; the description does not need to repeat parameter details. It adds only the system/OEM condition, which overlaps with the appsFilter parameter rather than extending its meaning.

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

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

The description opens with a specific verb and resource: 'List the apps installed on the selected device.' This clearly distinguishes the tool from siblings like install, appstate, and snapshot. The system/OEM qualification adds scope without obscuring the core 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?

It gives a conditional usage hint—include system/OEM apps only when they are needed as automation targets—but does not name alternative tools or state when not to use this one. The guidance is implied rather than explicit, so an agent must infer that apps is for enumeration before automation.

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

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

With no annotations, the description carries the disclosure burden. It does add non-obvious behavior: the 90-second timeout and the platform-specific Android/iOS split. But it does not clarify what 'iOS answers per command' means in practice, and there is no statement about side effects or prerequisites.

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

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

The description is two short sentences with the core action front-loaded, followed by two high-value caveats (platform behavior and timeout). Every word earns its place; there is no filler or redundant restatement of the tool name.

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

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

The tool has 15 optional parameters and no annotations, but the schema is fully described and an output schema exists, which lowers the burden. The description provides purpose, platform nuance, and a timeout warning. Still, it omits when to use it versus siblings and leaves the ambiguous iOS behavior unexplained, so it is adequate but not complete.

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

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

Schema description coverage is 100%, so the parameter semantics baseline is 3. The description adds no parameter-level meaning, but it does not need to because the input schema already documents all 15 parameters clearly and includes enums where relevant.

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

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

States a specific verb and resource: 'Show foreground app/activity'. The platform qualifier (Android; iOS answers per command) adds useful scoping, and the timeout clause is a concrete behavioral detail. This clearly distinguishes it from generic siblings like apps or snapshot, even without naming them.

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

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

The intended use is implied by the purpose ('when you need the current foreground app/activity'), and the platform note gives context. However, it never explicitly says when to prefer this over sibling tools like app-switcher, apps, or snapshot, nor does it state any exclusion conditions.

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

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

With no annotations provided, the description carries the disclosure burden. It honestly warns that the tool 'changes the visible system UI,' 'may move focus away from the current app,' and 'times out after 90s.' These are the key behavioral side effects an agent should know before invoking the tool.

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

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

The description is compact and front-loaded: purpose first, then the key side effect, then the timeout. Every sentence provides necessary information and there is no filler 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?

An output schema exists, so return-value details are not needed in the description. The description gives the essential behavioral context: it changes system UI, may move focus, and times out. It is sufficient for a safe call, though it could also have pointed to sibling alternatives.

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

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

The schema description coverage is 100%, so all 16 parameters are already documented in the input schema. The description adds no parameter-level detail, and the baseline of 3 is appropriate because the schema does the semantic 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 identifies the action and resource: 'Open the device app switcher.' It also states the purpose ('inspect or change foreground apps'), which makes the tool's intent understandable. It does not explicitly distinguish itself from sibling tools like apps, open, or focus, so it misses top marks.

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 intended use is implied by 'to inspect or change foreground apps,' but there is no explicit guidance about when to use this tool versus siblings such as focus, open, or apps. An agent must infer the appropriate context rather than being told directly.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses a 90-second timeout, which is useful, and the verb 'List' implies a read-only operation. However, it does not mention pagination, response format, or whether structuredContent is included by default. Given the minimal disclosure, this is adequate but not thorough.

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

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

The description is very short—two sentences—and front-loads the purpose. The timeout note is a useful extra detail. There is no wasted wording. While it is terse, it is efficient and not padded, so it earns a high score for conciseness, though it sacrifices completeness.

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 17 parameters, no output schema, and no annotations, the description is incomplete. It does not explain what the returned artifacts look like, whether they are structured or textual, or how the many parameters interrelate. The agent must rely entirely on the schema, and the description fails to provide the higher-level context needed to confidently invoke the tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific information beyond the schema, and with 17 parameters it does not attempt to summarize or prioritize them. The schema's detailed descriptions carry the weight, so the description neither helps nor hurts here.

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

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

The description states a clear verb ('List') and resource ('daemon or cloud provider artifacts') and scopes it to 'an active or completed session.' This distinguishes it from most siblings, though it doesn't explicitly name an alternative. It is more specific than a tautology and gives the agent a concrete idea of what the tool does.

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

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

The description implies usage for sessions, but provides no guidance on when to choose this over sibling tools or when not to use it. There are no exclusions or alternative tool references. The 'active or completed session' context offers a mild cue, but it falls short of explicit 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 the full behavioral disclosure burden. It discloses three important behaviors: the stateful probe lifecycle, the need to start before status/stop, and the 90-second timeout. This is meaningful operational context beyond what the schema alone provides.

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

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

Two sentences with no fluff. The primary purpose is front-loaded, and the lifecycle constraint and timeout are stated concisely. Every sentence adds useful information.

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

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

The description covers the core operation and lifecycle, but the tool has 19 parameters, no required parameters, no output schema, and no explanation of how durationMs and bucketMs interact. Common selectors are documented in the schema, but an agent still lacks clear guidance on the minimal invocation or expected structured response.

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 high at 89%, so the baseline is 3. The description adds value beyond the schema by explaining that 'start', 'status', and 'stop' correspond to probe lifecycle phases, and by framing outputs as 'dBFS buckets,' which gives meaning to bucketMs and durationMs.

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

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

The description states a specific verb and resource: 'Measure browser or host-rendered simulator/emulator audio as compact dBFS buckets.' This clearly defines what the tool does and the output format, making it distinguishable from sibling tools like record or logs.

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

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

The description gives explicit lifecycle guidance: 'Start a probe before requesting its status or stopping it.' This tells the agent the correct order of operations. It does not mention alternative tools or when not to use audio, but the core usage context is clear.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It mentions timeout (90s) and budget extension, and the settle behavior is described as best-effort. However, it does not disclose what happens on navigation failure, whether the action is reversible, or any side effects. For a navigation tool, this is adequate but not comprehensive.

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

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

Two sentences with zero fluff. The first sentence states the purpose and modes, the second adds usage and timeout behavior. Information is front-loaded and every clause earns its place. Ideal conciseness.

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

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

Given the tool has 20 parameters but 95% schema coverage and an output schema, the description covers the essential behavioral aspects: the two modes, timeout, and settle behavior. It doesn't explain return values (output schema handles that) or list all parameters (schema does). It is complete for an agent to call it correctly, though it could briefly mention what happens when no mode is specified (defaults are not stated).

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 95%, so most parameters are already documented. The description adds meaningful context for the 'mode' parameter (in-app vs system) and clarifies the settle option ('wait for the UI to go quiet and return the settled diff'). This goes beyond the schema and helps the agent understand parameter purpose and interaction.

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

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

The description clearly states the tool's function: navigating back in-app or through system navigation. It names the resource (navigation) and the two modes (in-app vs system), which distinguishes the two distinct behaviors. However, it does not explicitly differentiate from sibling navigation tools like app-switcher or home, though the context is clear.

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

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

It provides explicit guidance on when to use each mode: 'Use in-app for the app navigation stack and system when the platform back behavior is required.' This is actionable and clarifies the primary decision. It does not mention alternatives or exclusion cases, but the mode selection is well-covered.

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?

Only discloses a 90s timeout. With no annotations provided, the description carries the full burden of behavioral disclosure. It doesn't mention whether steps run sequentially, what happens on failure, whether output is aggregated, or any error handling behavior. The timeout is useful but 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 extremely short (two sentences), but this is under-specification rather than conciseness. The only substantive information is the timeout; the rest is generic and doesn't justify its place. A more useful description would explain the steps structure and batching semantics.

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 (19 parameters, nested steps object, many command options), the description is severely inadequate. It doesn't explain that each step uses a command name and input matching the corresponding MCP tool schema, the maxSteps limit, or the onError policy. An agent would have to infer all usage details from the schema, which is insufficient for effective invocation.

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

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

Schema coverage is 100%, so all parameters are documented in the schema. The description adds no parameter-specific information beyond what the schema provides. Baseline of 3 is appropriate since the schema handles 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?

States a clear verb ('Execute multiple commands') and resource ('daemon request'), but does not differentiate from the many sibling command tools. It doesn't explain that this is a batch wrapper for individual commands, nor mention the steps array. The purpose is identifiable but lacks specificity to distinguish it 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?

No guidance on when to use this tool versus calling individual command tools separately. It doesn't mention performance benefits, batching use cases, or when not to use it. The description provides no context for selection among siblings.

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

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

No annotations are provided, so the description must carry the behavioral transparency burden. It usefully discloses a 90-second timeout and the selection mechanism. It does not describe side effects, idempotency, whether boot waits for readiness, or failure behavior beyond timing, so it provides only partial behavioral 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?

Three terse sentences front-load the core action, then clarify device selection and add the timeout. Every sentence contributes operational information, no repetition of schema content, and no irrelevant details.

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

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

With all 16 parameters described in the schema and an output schema available, the description correctly avoids restating parameter details. It supplies the missing context: device resolution approach, follow-up readiness, and 90-second timeout. Minor gaps remain around whether boot is asynchronous and how an already-booted device is handled, but the definition is adequate for selecting and invoking the tool correctly.

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

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

The schema already documents all 16 parameters, so the baseline is 3. The description adds value by clarifying that no device name is passed directly and that the target is resolved via the device-selection inputs. This helps an agent understand how to populate selector parameters correctly rather than looking for a 'name' field.

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

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

The description states a clear action ('Boot or prepare') with a specific resource ('selected device or simulator') and the intended outcome ('so later commands can target it'). This distinguishes it from device-management siblings like shutdown or devices by focusing on bringing the device into a usable state.

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

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

It clearly implies when to use it: before later commands that target the device. It also advises that the device is chosen through device-selection inputs, not by naming it directly. However, it does not explicitly state when not to use it or mention sibling alternatives such as shutdown or open.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It usefully notes the 90s timeout and distinguishes device-based vs active-session operation, but it does not mention whether the command is read-only, has side effects, or what failure modes to expect.

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

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

Two sentences carry the core purpose, the key usage context, and a critical timeout warning. Every sentence earns its place and the most important information is front-loaded.

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

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

Given the tool's 15 optional parameters, no annotations, and no output schema, the description covers the central usage but leaves the agent to infer return shape and how multiple selectors like udid, session, leaseId, and runId interact. The 100% schema coverage compensates substantially, but some contextual gaps remain.

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

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

The input schema covers all 15 parameters, so the baseline is 3. The description adds cross-parameter context by advising to use device-selection inputs before a session is open, which is not stated in the schema itself.

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

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

The description states a clear action and resource: 'List the commands supported by the selected device or active session.' It communicates the tool's function specifically, though it does not explicitly distinguish it from the sibling 'help' tool or other listing-style commands.

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

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

The description gives concrete context: 'Use device-selection inputs when checking support before a session is open.' This tells the agent which parameter family to use in a common scenario, but it does not mention exclusions or explicitly contrast with alternatives like 'help'.

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, and it delivers: it explicitly warns 'This can change app state', recommends settle or verify to confirm results, and discloses the 90s timeout plus caller-budget extension. It omits some behavioral aspects such as the default action-recording implied by the noRecord parameter, but the core mutation warning and timeout are clearly stated.

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

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

Four sentences with zero filler; the action and targeting modes are front-loaded, followed by the state-change warning and timeout. Every sentence contributes distinct information.

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

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

For a 29-parameter tool with no annotations, the description covers the essential operational facts: what it acts on, how to choose a target, how to confirm the result, and the timeout. An output schema exists, so return values need no description, and the schema itself documents all parameters; the main residual gap is sibling differentiation.

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

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

Schema description coverage is 100% and every parameter already has a rich description, so the baseline of 3 applies. The description adds only the preference ordering among target kinds (ref/selector before coordinates), which is useful but minor relative to 29 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?

States a specific verb and resource ('Activate a UI target') and enumerates three targeting mechanisms (snapshot ref, selector, coordinates), going well beyond the tautological tool name. However, it does not explicitly differentiate from similarly-scoped siblings like press, longpress, and gesture, so it falls just short of 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?

Gives actionable when-to-use rules: prefer a ref or selector after a snapshot, and reserve coordinates for when semantic targeting is unavailable. It also prescribes settle/verify as the confirmation path instead of a follow-up snapshot. There is no explicit routing versus sibling input tools (press, gesture, longpress), but the targeting-mode guidance is genuinely operational.

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

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

With no annotations, the description carries the full behavioral burden. It discloses mutability, the Android shell-command mechanism, the refusal behavior on unsupported builds, and the 90-second timeout. This is strong operational context, though it does not detail return/response behavior beyond what the output schema presumably covers.

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

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

Three compact sentences with no filler. The core purpose comes first, followed by the Android-specific caveat and the timeout constraint. Every sentence earns its place.

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

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

Given an output schema, the description does not need to explain return values. It covers purpose, mutation, platform-specific failure behavior, and timeout. It is complete for practical invocation, though platform coverage beyond Android relies on the schema's platform selector.

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 89%, so the baseline is 3. The description adds only that 'given text' replaces clipboard contents, which lightly maps to the text parameter, but it does not enrich parameter meaning beyond the schema's existing descriptions.

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

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

Clearly states the two operations ('read' / 'write') and the resource (device clipboard text) with a specific verb. It is unambiguous and distinguishable from the sibling list, where no other tool is clipboard-specific.

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

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

The description makes the tool's purpose obvious, but it does not explicitly say when to use this tool versus alternatives or when not to use it. The usage context is implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses a 90s timeout and the distinction from shutdown, but omits side effects (e.g., whether unsaved data is lost), error handling, or what happens when the app is not running. For a close operation 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?

Two sentences with no redundancy. The first sentence states the core action, the second adds a usage caveat and a timeout. Information is front-loaded and every sentence earns its place.

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

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

Despite high schema coverage, the description does not mention output or return values (no output schema exists), error behavior, or how to select an app (by name, bundle ID, etc.). With 20 parameters and no output schema, the description leaves an agent uncertain about what happens after the call, making it incomplete for a complex tool.

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

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

Schema description coverage is 95%, so the schema already documents all parameters. The description adds no parameter-specific meaning beyond what is in the schema, which is acceptable given the high coverage. Baseline of 3 is appropriate.

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

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

The description clearly states the tool closes a named app, or the active session app when omitted. It explicitly contrasts with shutdown, distinguishing this tool from the sibling 'shutdown' tool. The verb-resource pair is specific and unambiguous.

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

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

Provides a clear condition for when to use shutdown instead of close ('Use shutdown only when the selected simulator or emulator should also stop'). However, it does not offer broader guidance on when to prefer close over other app-management tools, nor does it state when not to use it. The guidance is present but narrow.

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 adds the useful 90-second timeout and the narrow-scope behavior, but it does not disclose side effects, output behavior, or failure modes beyond that. Some meaningful behavioral context is present, but not enough 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 three sentences with no filler. It front-loads the core purpose, then provides sibling routing, and ends with the timeout constraint. Every sentence contributes information an agent needs.

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 20-parameter tool with no annotations and no output schema, the description is relatively complete: it clarifies purpose, sibling boundaries, and a key operational limit. It leaves some details such as output path defaults or multi-dSYM matching behavior to the schema, but the schema picks up most of that burden.

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 95%, so the schema already documents nearly all parameters. The description adds the key conceptual detail that dSYM matching is done by UUID, which helps make sense of dsym and searchPath, but it does not need to add more and does not go beyond that.

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 opens with a specific verb and resource: 'Symbolicate Apple crash artifacts with matching dSYM UUIDs.' It clearly distinguishes this tool from sibling tools by stating the debug namespace is intentionally narrow and naming what each sibling should be used for.

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

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

The description explicitly routes an agent to alternatives: 'use logs for app logs, network for HTTP evidence, perf for performance samples, record/trace for media and traces, and react-devtools for React Native profiles.' This makes the selection boundary between debug and neighboring tools 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 the full burden of behavioral disclosure. It reveals a 90-second timeout, which is a concrete operational detail. However, it does not state whether the operation is read-only, whether it requires special permissions, or how it behaves on failure or partial results. The timeout is useful but the overall behavioral picture is incomplete.

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

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

Two sentences with zero waste. The purpose is stated first, followed by a practical usage hint and a timeout note. Every sentence earns its place, and the description is appropriately brief for a list 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?

The tool has a rich output schema (true) and 15 optional parameters all documented in the schema, so the description need not explain return values. It covers the core purpose, the selector reuse pattern, and the timeout. For a discovery tool, this is sufficient; the only minor gap is that it doesn't explicitly mention that the filters are optional or that the output is a list, but these are implied by the verb 'List' and the 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%, so each parameter is already documented in the input schema. The description mentions platform, device, udid, or serial as selectors, but this primarily guides usage of later commands, not the parameters of this tool itself. It adds little semantic meaning beyond what the schema provides, so the baseline 3 is appropriate.

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

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

States the action 'List' and the resource 'available devices and simulators' explicitly, and clarifies the purpose 'can be selected for automation.' The verb is specific and distinguishes it from action-oriented siblings like boot, click, or install, which have clearly different purposes.

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

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

Gives clear guidance on how to use the output: 'Use platform, device, udid, or serial inputs on later commands to target one result.' This explains the primary use case. However, it does not explicitly mention when not to use this tool or name alternative listing tools (e.g., get, find), though the siblings suggest those might serve other resources. The guidance is sufficient but not exhaustive.

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

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

No annotations are provided, so the description carries the full burden. It discloses a 90-second timeout, which is useful, but does not state whether the operation is read-only, what prerequisites exist (e.g., prior artifacts), or the nature of side effects. Limited transparency beyond the timeout.

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

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

Two sentences with zero filler. The primary purpose is front-loaded, and the mode-specific guidance is presented immediately. Every sentence earns its place.

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

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

With 22 parameters and an output schema, this description is too sparse. It does not explain how to supply the artifacts being compared (there is no obvious parameter for a baseline or target), nor what the output looks like. An agent would struggle to construct a valid call beyond the required kind parameter.

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 implies two kinds ('snapshot' and 'screenshot'), but the schema constrains kind to only 'snapshot', creating a direct inconsistency that could mislead an agent. The description adds no meaning for the other parameters (out, raw, depth, scope, etc.) beyond their schema descriptions, and does not clarify how to specify the two artifacts to compare.

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 (compare), the resource (accessibility snapshots or screenshots), and the purpose (identify UI changes). It also distinguishes between the two modes (snapshot for semantic tree changes, screenshot for pixel differences), which sets it apart from sibling tools like snapshot and screenshot.

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

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

The description explicitly tells when to use snapshot comparisons vs screenshot comparisons, giving context for selecting the right mode. However, it does not mention when to avoid this tool or recommend alternative sibling tools, though the internal mode distinction is helpful.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses a notable background side effect (XCTest cache warming on iOS simulators), a 90-second timeout, and the output shape ('compact evidence'). This goes beyond a generic 'diagnose' and gives the agent actionable expectations, though it could go further on potential state changes beyond cache warming.

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

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

Three sentences with the purpose front-loaded, followed by return evidence and then the critical side-effect warning and timeout. Every sentence contributes new information, and nothing is redundant with the schema or output schema.

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

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

For a broad diagnostic tool with an output schema and fully documented optional parameters, the description provides everything needed to decide when and how to invoke it: what it checks, what it returns, the cache-warming side effect, and the 90s timeout. Even with 17 parameters, the schema fills the remaining detail, so the description is complete.

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

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

Schema description coverage is 100%, so the structured schema already documents all 17 optional parameters. The tool description adds no parameter-specific semantics—it only discusses overall behavior and output—so the baseline 3 is appropriate.

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

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

The description states a specific action ('Diagnose') and a concrete resource scope: device, app, development-server, and React Native or Expo readiness issues. It also enumerates the returned evidence (local inventory, sessions, app discovery, toolchains, server reachability), which clearly differentiates it from single-purpose sibling commands like screenshot or gesture.

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

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

The description explicitly tells the agent to run this before the first Apple snapshot or interaction of a session to warm the XCTest runner cache, which is a clear, concrete use-case. It stops short of naming alternatives or stating when not to use it, so it does not fully satisfy the 'explicit when/when-not/alternatives' level.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does reveal that the operation is read-only, returns paged JSON-friendly entries, and times out after 90 seconds. However, it does not explain pagination mechanics, the entry shape, or what happens on timeout, leaving some 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 very brief and front-loaded, with the core verb and resource stated first and the timeout note as the only extra detail. It is economical, though the missing punctuation and run-on feel ('entries Times out') make it slightly less polished than ideal.

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?

There is no output schema and no annotations, and the description does not explain the event entry structure, pagination behavior, required selectors, or response format beyond 'JSON-friendly entries.' For a tool with 17 parameters and several sibling tools, this is a significant contextual gap.

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

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

Schema description coverage is 88%, so the schema already documents almost all parameters. The description adds little parameter-specific meaning beyond implying the relevance of paging through limit and cursor, and it does not clarify the two undocumented parameters (limit, cursor). The baseline of 3 is appropriate given the strong 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 a specific verb ('Read'), a clear resource ('daemon-owned session event timeline'), and the output form ('paged JSON-friendly entries'). It is clear about what the tool does, though it does not explicitly differentiate it from similar sibling tools like logs, trace, or session.

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

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

No guidance is given for when to use this tool versus alternatives. The sibling set includes related tools such as logs, trace, session, and replay, but the description provides no selection criteria, exclusions, or context that would help an agent choose correctly.

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

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

With no annotations, the description carries the transparency burden. It discloses clear-on-empty behavior, recordAs secret handling, and the 90s timeout. It does not mention response shape, side effects beyond replacing text, prerequisites such as focus, or which parameter represents the 'caller-supplied budget' that extends the timeout.

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 only three sentences, front-loads the core action, and every sentence earns its place. It avoids repeating schema field details and stays focused on high-value behavioral 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 complex 26-parameter tool with an output schema, the description covers the essential operational points: what it acts on, how to target it, how to clear it, how to handle secrets, and timeout behavior. The main gap is the lack of an explicit contrast with `type`, but that is a minor omission given the rich schema and sibling context.

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

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

The input schema already documents all 26 parameters at 100% coverage, so the baseline is 3. The description adds useful semantics for target selection modes, empty text meaning, recordAs for sensitive data, and timeout behavior, going beyond what the schema literally states.

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 opens with a specific verb and resource: 'Replace text in a UI input' and names three targeting modes: snapshot ref, selector, and coordinates. It clearly separates filling from a generic click/hover, but it does not explicitly distinguish this tool from the sibling `type`, so differentiation is left mostly to inference.

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

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

It provides real guidance: prefer refs or selectors after a snapshot, use recordAs for sensitive text, and note the 90s timeout. However, it never states when to prefer `fill` over the sibling `type` or another alternative, so the when-to-use guidance is useful but not explicit about 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 present, so the description carries the full burden. It discloses a 90-second timeout, which is useful, but does not describe side effects (e.g., destructive actions), behavior when no element is found, or whether the action is read-only or mutating. This is a significant gap for a tool that can run click, fill, and type actions.

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

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

The description is a single sentence, which is concise and front-loaded with the main purpose. However, it lacks any structure or breakdown of the action and locator options, and the timeout note is appended without context.

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

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

Given the tool's complexity (26 parameters, no annotations, output schema present but not described), the description is grossly inadequate. It does not explain the action list, locator semantics, device targeting, or any of the boolean flags. An agent would have to rely almost entirely on the schema, which itself is incomplete at 65% coverage. This is far from a minimum viable description for such a feature-rich tool.

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

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

Schema coverage is 65%, so many parameters are described in the schema. The description adds meaning for the locator concept (text/label/value/role/id), but does not explain the action enum, flags like raw/last/first, or device selection parameters. It adds only marginal value beyond the schema for a tool with 26 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 states a clear purpose: find by text/label/value/role/id and run an action. This distinguishes it from siblings like click or get, which are single-purpose. It does not explicitly name an alternative, but the core action is 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?

No guidance is given on when to use this tool versus alternatives such as click, fill, or get. It does not mention prerequisites, exclusions, or scenarios where a simpler tool would be more appropriate.

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

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

No annotations are provided, so the description carries the full burden. It discloses the 90-second timeout and the no-text-entry behavior, which is useful. However, it doesn't disclose potential failure modes, prerequisites (e.g., visible target), or what the response contains, leaving meaningful gaps for a UI-mutating operation 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?

Three sentences with the core purpose front-loaded first. Every sentence earns its place: purpose, usage guidance, and timeout. No filler or redundant wording.

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

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

For a coordinate-based focus tool with no output schema, the description covers purpose, usage routing, and timeout. It could mention response shape or failure behavior, but the tool's simplicity and the fact that most of the 18 parameters are shared selectors (udid, device, platform) mean the description is reasonably complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's 'explicit screen coordinates' maps to x/y, but that context is already implicit in the schema's 'X coordinate' and 'Y coordinate' entries. The description adds no parameter details beyond what the schema provides.

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

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

The description states a specific verb and resource: 'Move input focus to explicit screen coordinates without entering text.' This is clear and the 'without entering text' clause differentiates it from type/fill siblings. However, it doesn't explicitly distinguish focus from other coordinate-based siblings like click or hover, so it falls just short of 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?

'Prefer semantic interactions when a snapshot ref or selector is available; use type or fill after focus' gives explicit when-to-use guidance and names the complementary tools (type/fill). It doesn't enumerate exclusions relative to click/hover, but the coordination guidance is genuinely useful and clear.

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

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

With no annotations, the description carries full behavioral burden and does so thoroughly: it explains the underlying HID event, post-command coordinate staleness requiring re-snapshot, simulator prerequisites, specific error behavior (UNSUPPORTED_OPERATION with unsupported-device-scope), and the 255s timeout.

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 dense but every sentence earns its place: core action, side-effect warning, compatibility constraints, error condition, and timeout. It front-loads the command's purpose and consequences.

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 complex tool with 18 parameters and no annotations, the description covers prerequisites, side effects, failure modes, and timeout behavior. An output schema exists, so omitting return-value details is acceptable.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description adds some context around pose and keyframes but does not provide additional parameter-level semantics beyond what the schema 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 opens with a specific verb and resource: it folds or unfolds the foldable iPhone simulator into a pose or follows keyframes. It also clearly distinguishes the mechanism (HID hinge event, CoreDevice confirmation) and is not a tautology.

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

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

It clearly states simulator-only usage, required SDK, and that Device Hub/Accessibility permissions are not required. It also warns against non-default simulator sets and instructs to run against the default set, but it does not explicitly name alternative tools.

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

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

No annotations are provided, so the description must carry full burden. It discloses a 90s timeout, which is a useful behavioral trait. However, it does not mention side effects, whether it is read-only or destructive, or any other behaviors. The term 'structured' is vague and does not clarify what the tool does beyond performing the gesture. It does not mention recording or device targeting. Given the lack of 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 sentence that states the purpose and a usage rule, plus a timeout. It is concise and front-loads the purpose. However, it could be structured to list the kinds more clearly. Still, it is appropriately sized.

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 31 parameters and 7 gesture kinds, the description is extremely sparse. It does not explain which parameters apply to which gesture kind, nor does it describe the output. With no output schema, the description should clarify what the tool returns, but it does not. The schema has parameter descriptions, but they are not enough to understand the gesture-specific requirements. The description is far from complete for such a complex tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the rule to provide only inputs that apply to the selected kind, which gives a generic guideline. It does not add specific parameter details beyond what the schema provides. It adds minimal 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 it performs a structured gesture of various types (pan, fling, swipe, pinch, rotate, transform, drag). However, it does not differentiate from sibling tools like the dedicated 'swipe' tool, which could confuse an agent about which tool to use. The purpose is explicit but sibling differentiation is weak.

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

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

The description says to select the gesture kind and provide only applicable inputs, but it does not specify when to use this tool versus alternatives like swipe or scroll. No exclusions or context about scenarios are given. It offers minimal guidance on usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the operation is non-mutating ('without changing the app') and adds a specific timeout ('Times out after 90s'), which goes beyond the schema. It does not cover every error or edge case, but the key safety and timing traits are present.

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

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

The description is two sentences with no filler. The primary purpose and read-only nature are front-loaded, followed by format usage and the timeout. Every sentence earns its place and the structure is optimal for quick agent scanning.

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 21 parameters and no output schema, the description covers the essential invocation semantics: what to read, how to specify the format, that the operation is safe, and the timeout. Many optional parameters are left to the schema, but the core context an agent needs to select and call this tool correctly is present.

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

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

Schema description coverage is 95%, so the baseline is 3. The description adds meaningful semantics for the core parameters: it explains what 'format' values produce ('text for visible content', 'attrs for the element attribute map') and clarifies the target as 'snapshot ref or selector'. This is valuable beyond the bare schema enumerations.

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

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

The description states a specific verb ('Read') and resource ('text or accessibility attributes') from a 'snapshot ref or selector', and explicitly notes it does so 'without changing the app'. This makes it clearly distinguishable from siblings like snapshot or find, and the purpose is immediately apparent.

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

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

The description provides clear context for when to use the tool: when you need visible content or an element attribute map from a ref or selector. It also gives format-selection guidance ('Use format text for visible content or attrs for the element attribute map'), though it does not explicitly contrast with alternative 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, the description carries the full burden. It discloses the core behavior: omitting topic returns the full workflow card, a listed topic returns its guide, and a tool name returns its complete flag reference. It does not detail output formatting or invalid-topic behavior, but the behavioral surface of a help tool is well covered.

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

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

Two sentences carry all essential information and are front-loaded with the core purpose. The long second sentence is dense but each clause adds a distinct rule, and the guidance is structured logically from current behavior to exclusions.

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?

Even without an output schema, the description explains return types for all invocation forms: workflow card, guide, or flag reference. The single parameter's usage and omission behavior are fully covered, and the usage caveats complete the picture for an agent deciding when to call this 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 schema already covers topic with 'Guide topic or tool name; omit for the card,' but the description adds significant meaning by enumerating all valid guide topics and clarifying the tool-name path. This goes beyond the schema's brief description and helps the agent form correct invocations.

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

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

The description clearly identifies the tool as a usage guide dispatcher: 'Usage guides' plus a precise mapping of topic values to guides, the workflow card, or a tool's flag reference. It is immediately distinguishable from the sibling command tools because it is the meta/help tool, not an operational command.

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

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

The description gives explicit when-to-use and when-not-to-use guidance: 'For specialized work or an unclear command shape only; not a startup step, not needed after an error that carries a hint.' It also explains the no-topic case and the alternate form for tool-name flag references, leaving no ambiguity about 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 the full burden. It discloses that the app session remains open and that the tool times out after 90 seconds, which are key behaviors. It does not detail side effects like whether the home button is pressed or what happens on timeout, but the provided details are useful.

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

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

Two concise sentences, with the core action front-loaded and the critical behavioral nuance in the second sentence. No redundant information.

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

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

The tool is simple in purpose and the output schema is present, so the description covers the essential facts (action, session behavior, timeout). It does not mention platform-specific behavior (mobile/tv/desktop) despite the target parameters, but the schema and output schema fill most gaps. Adequate for a straightforward navigation tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning to any of the 16 parameters; all semantics are already captured in the schema.

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

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

The description states a specific verb and resource: 'Send the selected device to its home screen.' It clearly distinguishes the action from navigation tools like 'back' by explicitly noting it leaves the app session open, which is a defining behavioral difference.

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

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

The description gives some implied usage context (e.g., it moves foreground away from the app) but does not explicitly state when to use this tool versus alternatives like 'back' or 'app-switcher'. No exclusions or alternatives are named.

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 present, the description carries a heavy burden and does a solid job: it discloses that the action does not press, that it is web-only, that it times out after 90 seconds, and that a caller-supplied budget can extend it. It also ties 'settle' to observing what hover revealed, adding behavioral context beyond the raw schema. It does not explain the response contents, but an output schema exists.

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

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

Three sentences, each earning its place: action/purpose, platform restriction, and behavioral notes about settle and timeout. The most important information is front-loaded, and there is no filler or repetition.

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

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

The schema is rich with 22 parameters and an output schema, so the description can focus on behavior, which it does. It covers core semantics, platform applicability, timeout, and the settle flow. The one gap is the ambiguous 'caller-supplied budget' – no parameter in the schema directly corresponds to it, which makes it unclear how an agent would extend the timeout.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds little beyond what the schema already documents: 'by snapshot ref, selector, or coordinates' mirrors the target oneOf, and the 'Use settle' note adds purpose to that parameter but no new syntax. The cryptic 'caller-supplied budget' is not mapped to a schema property, which slightly dilutes the 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 opens with a specific verb and resource: 'Move the pointer over a UI target' and enumerates the three targeting modes: snapshot ref, selector, or coordinates. It explicitly says 'without pressing', which distinguishes it from sibling press/click/longpress tools, and it states the intended purpose: revealing hover-gated UI like row toolbars or menus.

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

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

The description gives clear context: use hover to reveal hover-gated UI, and gives an explicit when-not: 'Web only; touch platforms have no hover state.' It does not name an alternative tool like click or press, but 'without pressing' implies the boundary, so the guidance is clear though not exhaustive.

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 discloses a 180s timeout, which is a behavioral detail. However, it does not state whether the install overwrites an existing app, what happens on failure, or any required permissions. The mutation nature is implicit, but there's limited additional transparency beyond the timeout.

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

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

The description is two sentences with no wasted words. It front-loads the purpose, then provides usage guidance and a timeout note. Every sentence earns its place, making it 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 absence of an output schema and the full schema coverage of parameters, the description covers the core operation, directs to reinstall for replacement, and notes the timeout. It does not specify behavior when the app is already installed, but that is handled by the reinstall reference. The description is sufficiently complete for an install command, though it could mention failure handling or overwrite 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?

Schema description coverage is 100%, so the baseline is 3. The description adds meaning to two parameters: it clarifies that 'app' is an identifier (via 'Provide an app identifier') and that 'appPath' is a local path (via 'from a local path'). This provides additional context beyond the schema, though it doesn't elaborate on the other 16 parameters. Given the high schema coverage, the description compensates adequately.

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

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

The description clearly states the tool's purpose: 'Install an app binary from a local path.' It uses a specific verb ('Install'), resource ('app binary'), and source ('local path'). It differentiates from the sibling 'reinstall' by explicitly stating 'use reinstall to replace an already installed app,' which helps an agent distinguish between the two.

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

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

The description gives explicit usage guidance: it tells the agent to provide an app identifier when explicit app selection is needed, and directs to 'reinstall' when replacing an already installed app. This clearly indicates when to use this tool versus the alternative. It also mentions the 180s timeout, which is useful 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?

The description discloses a 90-second timeout and remote daemon resolution, which are useful behavioral details. However, with no annotations, it omits prerequisites, side effects on the device, reversibility, or failure behavior. For a mutation tool, this is partial 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?

A single sentence states the purpose and a key constraint (timeout) upfront. No filler, front-loaded, and to the point.

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 (19 parameters, a nested source object, no output schema, no annotations), the description is far too brief. It lacks details on how to specify sources, what the response contains, error handling, or how to use the device selectors. An agent would need more context to invoke it correctly.

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

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

Schema coverage is high (89%), so the baseline is 3. The description adds no parameter-specific meaning beyond the schema; it doesn't clarify the structure of the 'source' object or how to combine the many device selectors. It neither enhances nor detracts 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 clearly states the action (install) and the resource (app builds) along with the source types (URLs, remote source specs, CI artifacts) and a remote daemon. It differentiates from the generic sibling 'install' by implying a source-based install, though it doesn't explicitly contrast with it.

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

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

No guidance on when to use this tool versus the siblings 'install' or 'reinstall'. The description states what it does but doesn't provide context for selection, exclusions, or alternatives. An agent must infer that this is for source-based installs.

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. It discloses an important edge case ('absent passes only when one readable, complete, settled, unscoped, full-depth accessibility capture has zero matches') and a timeout ('Times out after 90s'). These are real behavioral details beyond the schema.

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

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

Three sentences, all high-signal: the core operation, the subtle absent behavior, and the async alternative plus timeout. No filler or repetition of schema fields.

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 predicate-check tool with no output schema and no annotations, the description covers the main call semantics, the trickiest predicate, async handling, and timeout behavior. It does not describe the return value shape, but 'check whether' strongly implies a boolean result, and the 90s timeout bounds expectations.

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 87%, so the baseline is 3. The description adds meaningful semantics beyond the enum by explaining the special meaning of 'absent' and framing the predicate as a UI state check. It does not explain selector or value, but those are largely covered by schema context and the core predicate behavior is enriched.

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 opens with a specific verb and resource: 'Check whether a selector satisfies a UI predicate,' then enumerates the exact predicate values it supports. This clearly distinguishes it from nearby tools like snapshot (which captures UI state) or find (which locates elements).

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

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

It explicitly says 'Use wait when the condition may appear asynchronously,' giving the agent a direct alternative for a common ambiguity. It does not exhaustively contrast with every sibling tool, but the guidance is concrete and actionable.

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