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?

The description discloses one valuable behavioral trait: 'Times out after 90s.' However, with no annotations provided, it does not explicitly confirm that the command is read-only/side-effect-free, nor does it explain what happens on timeout or when no foreground app/activity 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?

At only seven words, there is no filler and the purpose is front-loaded. The awkward lack of punctuation between 'app/activity' and 'Times out' makes the sentence slightly harder to parse, but overall it is efficient.

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

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

For a simple query command with an output schema, this is minimally sufficient, but it does not explain when to use it, how the 90s timeout affects expected results, or which selectors/leases are needed in practice. Given 15 parameters and no annotations, a bit more operational context would be valuable.

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 input schema already documents all 15 parameters, and the description does not need to compensate much. The description adds no parameter-specific meaning, such as which device selector to prefer or how target/platform relate.

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 read action and resource: 'Show foreground app/activity.' This is clear and reasonably distinct from broader siblings like apps or snapshot, but it never names or contrasts a sibling, so differentiation is left 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?

There is no guidance about when to use appstate instead of apps, app-switcher, snapshot, or other read commands, and no exclusions or alternatives are mentioned. The verb 'Show' implies a query, but the description leaves the selection context entirely implicit.

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 behavioral disclosure burden. It does disclose a 90-second timeout and that a caller-supplied budget can extend it, which is useful operational context. However, it doesn't mention potential side effects such as system back exiting the app, or any state-changing consequences beyond the obvious navigation action.

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 purpose, mode guidance, and timeout behavior with no filler. The first sentence front-loads the core operation, the second gives selection rules and a timeout caveat. Nothing extra is included.

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 20-parameter schema, high schema coverage, and a provided output schema, the description is reasonably complete: purpose, mode usage, and timeout are covered. The main gap is the lack of any note about default mode behavior or the system back potentially leaving the app, but the schema and output schema fill most of the remaining 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 schema already describes nearly all 20 parameters (95% coverage), so the baseline is 3. The description goes beyond the schema by clarifying the meaning of the 'mode' enum: 'in-app' means the app navigation stack and 'system' means platform back behavior. This adds genuine semantic value for the most important parameter.

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 'Navigate back' and distinguishes the two modes: in-app navigation stack and system/platform back behavior. This is more specific than the tool name alone and separates it from sibling tools like home/click. It doesn't reach a 5 because 'navigate back' is close to a restatement of the name, but the mode distinction adds real meaning.

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

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

The description explicitly says when to use each mode: 'Use in-app for the app navigation stack and system when the platform back behavior is required.' This gives clear context for mode selection. It doesn't name alternative sibling tools, but no other sibling directly provides back behavior, so the guidance is sufficient.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add one useful behavioral fact, the 90-second timeout, but says nothing about failure handling, partial execution, response shape, side effects, or how nested commands behave. For a complex execution tool this is a significant transparency gap.

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

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

The description is one efficiently worded sentence with no redundant content. It front-loads the core purpose and appends a critical operational constraint, the timeout. It is appropriately compact, though arguably too terse given the tool's complexity.

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

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

This tool has 19 parameters, no annotations, and no output schema, yet the description only covers purpose and timeout. It does not describe return behavior, error semantics, or how batch execution relates to the individual command schemas referenced in the steps parameter. An agent would need to infer too much to invoke this tool confidently.

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

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

Schema description coverage is 100%, so the schema already documents all 19 parameters in detail. The description adds no parameter-level meaning beyond 'multiple commands,' which maps to the required 'steps' parameter. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states a clear verb and resource: 'Execute multiple commands in one daemon request.' This distinguishes it from the many single-command sibling tools by emphasizing batch execution. It could more explicitly connect to the sibling command set, but the core purpose 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?

The phrase 'multiple commands in one daemon request' implies the tool is for batching several commands, but there is no explicit guidance on when to prefer it over individual sibling tools, nor any exclusions or conditions. Usage context is only implied rather than directly 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 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?

No annotations are provided, so the description bears the full behavioral burden. It explicitly discloses that the action can change app state and recommends settle or verify for confirmation, plus it states the 90-second timeout and budget extension behavior. This is meaningful behavioral context beyond what the schema alone reveals.

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

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

Three concise sentences front-load the core action and then add targeting preference, side-effect guidance, and timeout behavior. There is no filler or repetition of schema content.

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

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

For a 29-parameter tool with no annotations, the description covers the essential call semantics: how to choose a target, the mutating nature of the action, and the recommended ways to verify results. The output schema and 100% schema coverage handle return-value and parameter details. It could explicitly name sibling alternatives like press or gesture, but that omission does not block 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 is 3. The description adds useful context around target-mode selection and settle/verify behavior, but it does not add much beyond the already-complete parameter descriptions. For a tool with 29 parameters, this is acceptable because the schema handles parameter semantics.

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

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

The description uses a specific verb, 'Activate', and a resource, 'UI target', with three explicit targeting modes: snapshot ref, selector, or coordinates. This clearly distinguishes click from sibling input tools like press, gesture, or swipe by describing its semantic targeting approach.

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 guidance on when to use coordinates versus ref/selector: prefer ref or selector after a snapshot, and use coordinates only when semantic targeting is unavailable. It also advises using settle or verify to confirm state-changing results without a follow-up snapshot, which is clear and actionable context.

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

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

With no annotations, the description carries the burden. It discloses the 90-second timeout, a useful behavioral detail. However, it does not mention side effects, error behavior, or whether the operation is synchronous, leaving some gaps for a simple 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?

Two sentences with zero redundancy. The core purpose is front-loaded, and the timeout is the only extra detail, earning its place.

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

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

Given the output schema exists and most parameters have descriptions, the description covers the essential function and timeout. It does not elaborate on device selection, but that is handled in parameter descriptions. Complete enough for an agent to call 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 89%, so most parameters are described. The description adds meaning to the 'text' parameter (the replacement content) and the 'action' parameter (read vs write). Beyond that, it adds little, so baseline 3 is appropriate.

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

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

The description clearly states the tool reads or writes device clipboard text, a specific verb-resource pair. No sibling tool overlaps with clipboard operations, so it is unambiguously distinct.

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: to read or replace clipboard content. No alternative clipboard tool exists among siblings, so exclusions are unnecessary. It provides clear context without explicit when-not guidance.

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

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

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 provided, the description carries the burden of behavioral disclosure. It discloses the empty-text-clears-field behavior, the 90s timeout and budget extension, and the recordAs security behavior, which are meaningful beyond the schema. It does not mention possible side effects or prerequisites, but the behavior is sufficiently transparent for this kind of action.

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 no filler: the first states action and target options, the second covers clearing behavior, and the third covers security and timeout. 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?

For a complex 26-parameter tool, the description covers the key decisions an agent must make: how to target, when to use recordAs, and timeout behavior. The output schema and fully documented parameter descriptions supply the rest. It is slightly incomplete in not routing between fill and the sibling 'type' tool, but overall it is complete enough to invoke correctly.

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

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

Schema description coverage is 100%, so the schema already documents all 26 parameters. The description adds useful semantic color around target preference, clearing, recordAs, and timeout, but doesn't need to compensate for missing schema documentation. 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 a specific action ('Replace text in a UI input') and the three targeting mechanisms (snapshot ref, selector, coordinates). It is clear enough to distinguish from most siblings, though it does not explicitly differentiate from the sibling 'type' text-entry tool.

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 explicit practical guidance: prefer refs or selectors after a snapshot, use recordAs to keep sensitive text out of recorded replays, and notes the 90s timeout. It does not state when to choose fill over the sibling 'type' tool, so it stops short of full usage-versus-alternative guidance.

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

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

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?

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?

No annotations are provided, so the description carries the burden. It fully discloses the behavioral modes (full card vs. specific guide, flag reference) and enumerates valid topics. It doesn't explicitly state non-mutating behavior, but that is inherent for a help tool, so it's sufficient.

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 content is dense but well-organized: it starts with a clear summary, then explains the no-topic case, then the topic list, then usage restrictions. Every phrase adds value, but it's a single long sentence that could be split for readability.

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

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

For a simple help tool with one optional parameter, the description is complete: it covers the default behavior, all valid inputs, alternative usage, and when to avoid the tool. No output schema is needed because the tool's return is self-evident.

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 significantly enriches the schema's parameter description by listing all valid topics and explaining the two usage modes (omit for card, tool name for flag reference). This goes well beyond the schema's 'Guide topic or tool name; omit for the card.'

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 provides usage guides and distinguishes between the full workflow card (no topic) and specific guides/flag references (with topic). It is specific and stands apart from sibling tools.

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

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

Explicit when-to-use guidance is given: 'For specialized work or an unclear command shape only; not a startup step, not needed after an error that carries a hint.' However, it does not name alternative tools for these cases, so I deduct one point.

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, the description carries the full burden and provides several useful behavioral facts: the action does not press, it is Web-only, it times out after 90 seconds, and a caller budget can extend it. It does not cover failure modes or side effects in depth, but the main operational traits are disclosed.

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

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

Three dense sentences, front-loaded with the action and purpose, followed by platform limitation and timeout. No filler or redundant restating of the 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?

The tool is complex with 22 parameters, but schema coverage is complete and an output schema exists, so the description can focus on behavior. It covers the core action, platform constraint, settle behavior, and timeout. It is not exhaustive about edge cases, but it is complete enough for an agent 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 description coverage is 100%, so the baseline is 3. The description's reference to 'snapshot ref, selector, or coordinates' summarizes the target variants and the settle advice adds a little context, but it does not add meaning beyond what the schema already provides for the 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 names a specific verb ('Move the pointer'), a resource ('a UI target'), three addressing modes (snapshot ref, selector, coordinates), and the purpose ('reveal hover-gated UI'). The 'without pressing' and 'Web only' clauses distinguish it from click/press and from touch-only interactions, so an agent can differentiate it from sibling tools.

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

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

It gives a clear use case (hover-gated UI) and an explicit platform exclusion ('Web only; touch platforms have no hover state'). It also tells the agent to use settle to observe results. It does not explicitly name an alternative sibling such as click/press for the 'without pressing' case, so the guidance is clear 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 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, the description carries the behavioral burden. It discloses the 90s timeout and precisely defines the tricky absent semantics: 'one readable, complete, unscoped, full-depth accessibility capture has zero matches.' It does not explicitly state that the tool returns a boolean or that it is read-only, but these are strongly implied.

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 efficient sentences, front-loaded with the core purpose, followed by the special-case semantics and async guidance. Every sentence earns its place with no repetition.

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

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

For a predicate-check tool with no output schema, the description covers the core operation, the tricky absent behavior, timeout, and routing to wait. It does not spell out the return value or selector syntax, but these are largely inferable and not severe gaps.

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

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

Schema coverage is high at 87%, so the baseline is 3. The description adds meaningful semantics for the required predicate parameter, especially the absent edge case, beyond what the enum alone provides. Selector itself remains undefined, but this is a common concept across sibling tools.

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

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

The description uses a specific verb and resource: 'Check whether a selector satisfies a UI predicate', and enumerates all predicate values. It clearly differentiates itself from the sibling wait tool, and the predicate list makes its scope concrete.

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 instructs when to use an alternative: 'Use wait when the condition may appear asynchronously.' This gives the agent a clear decision rule between is and wait.

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 key behaviors for dismiss: taps the dismiss key, verifies closure, reports UNSUPPORTED_OPERATION when no dismiss key exists, never attempts background taps, and times out after 90s. This is strong for one action, but other actions (status, enter, return) are not behaviorally disclosed, so it's not complete.

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 compact three-sentence block that front-loads the purpose and then details the dismiss behavior. There is no fluff, and every sentence contributes something. The structure is logical: purpose, usage hint, behavioral specifics.

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 output schema exists, so return values are presumably covered. However, the tool has 17 parameters and 6 enums, and the description only explains the dismiss action in detail. It doesn't cover the status, enter, or return actions, nor does it mention platform nuances (e.g., whether it works on iOS despite saying Android). This leaves gaps for an agent to call it correctly across all actions.

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

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

Schema coverage is 94%, so the schema already documents most parameters. The description adds value by explaining the 'dismiss' action's semantics (taps dismiss key, verifies, etc.), which the schema's enum values don't describe. However, it doesn't clarify the meaning of 'status', 'enter', or 'return', so it only partially compensates for the undocumented enum semantics.

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

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

The description states a clear verb-resource relationship: inspect or press/dismiss the keyboard. It is specific about the Android platform and distinguishes itself from generic tools like 'type' or 'click'. However, it doesn't fully disambiguate between the 'status' and 'enter' actions, so it's not perfect.

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 'To hide the keyboard, use keyboard dismiss', giving a concrete when-to-use for one action. But it doesn't provide guidance for when to use 'status', 'enter', or 'return', nor does it contrast with alternative tools like 'type' or 'keyboard' siblings. This is partial guidance at best.

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 for behavioral transparency. It does disclose one useful behavior ('Times out after 90s'), but it does not mention side effects of start/stop/clear, whether operations mutate session state, what diagnostics and markers produce, or any permissions or environmental requirements.

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

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

The description is short and front-loads the core purpose, with the timeout disclosure placed at the end. The telegraphic phrasing 'Session app log info, start/stop streaming, diagnostics, and markers' is slightly fragmented but contains no filler.

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

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

For an 18-parameter tool with no annotations and no output schema, this description is far too thin. It does not explain how actions like start, stop, mark, or clear behave, what output format is expected, or how the many optional parameters should be used together. The schema helps with parameter names but not with overall invocation strategy.

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 (83%), so the baseline is 3 even without additional parameter details. The description's action terms (start/stop streaming, diagnostics, markers) loosely map to the action enum, but it does not meaningfully clarify parameter relationships or add semantics beyond the schema.

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

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

The description identifies the resource ('session app log') and lists the main operations (log info, start/stop streaming, diagnostics, markers), which is enough to understand the tool's general purpose. It falls short of a crisp verb+resource phrasing like 'Manage session app logs' and does not explicitly distinguish itself from siblings such as events or record.

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