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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the action. It does not say which button is pressed, what happens if no alert is present, whether the call blocks or errors, or whether the dialog is discarded.

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, front-loaded sentence with no padding or redundancy. It is efficient, though its brevity contributes to the missing behavioral and routing detail.

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 values need not be explained, and the single parameter is fully documented. Still missing are the precondition (an alert must be showing) and the accept-vs-dismiss distinction, which matter for a dialog-interaction 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% and the single device_id parameter is documented as the 'Simulator UDID' in the schema. The description adds no further parameter meaning, so the baseline of 3 applies.

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

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

States a specific verb ('accept') and resource ('the current alert dialog'), which is clear on its own. However, it never distinguishes itself from the sibling dismiss_alert, so an agent must infer that 'accept' means confirming (OK/Accept) versus dismissing (Cancel).

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 instead of dismiss_alert or get_alert_text, and no precondition stated (e.g., an alert must currently be present). The reader is left to infer the usage context entirely.

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

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

With no annotations, the description carries the full behavioral burden for a state-mutating operation. It does not disclose whether booting is idempotent when already booted, whether the call blocks until boot completes, or that it changes device state — an agent has no safety or timing 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?

A single front-loaded sentence with zero filler. It is efficiently sized, though its brevity is partly a symptom of the missing usage context rather than pure economy.

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 values need not be explained, and the single param is schema-documented. Still, for a state-changing lifecycle tool with no annotations, the absence of prerequisite (obtain UDID first) and already-booted behavior leaves a meaningful 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?

One parameter at 100% schema description coverage ('Simulator UDID'), so the schema fully documents it. The description adds nothing beyond that, making the baseline 3 correct.

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

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

States a specific verb ('Boot') and resource ('iOS simulator'), which is enough to distinguish it from the sibling shutdown_simulator at a glance. However, it does not explicitly name or route against that sibling, so it falls 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?

No when-to-use guidance: it does not mention that a UDID typically comes from list_devices/get_device, nor what happens if the device is already booted. The only implied usage is the obvious boot-before-interact flow.

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 usefully discloses the scope of the change (all overrides are removed, state returns to normal), but says nothing about session requirements, whether a device must be booted, or operational caveats.

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 front-loaded sentence with zero filler; the action and its effect are stated immediately.

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

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

An output schema exists, so return values need no explanation, and the tool has only one well-documented parameter. It is nearly complete for a simple state-reset tool, with only sibling routing left unstated.

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

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

Schema description coverage is 100% and device_id is documented as a Simulator UDID there. The description adds no parameter detail, so the baseline 3 is appropriate when the schema does the 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?

States a specific verb (clear) and resource (status bar overrides) with the effect spelled out ('return to normal'). An agent can distinguish it from set_status_bar via the shared resource, though the description never names that sibling explicitly.

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?

Usage is only implied: the 'clear all overrides' phrasing signals this is the inverse of set_status_bar. There is no explicit when-to-use, when-not-to-use, or named alternative, leaving the agent to infer the routing.

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. 'Discover running' implies a non-mutating probe, but it doesn't disclose that the tool scans ports (the timeout parameter hints at this), how long it may take, or that it can find zero daemons. It conveys the operation's nature but not its cost or failure 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 short sentences, purpose front-loaded, with the second sentence supplying useful downstream context. No padding, though the downstream detail is more helpful to a human than to an agent deciding whether to invoke.

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 explanation is not needed, and a one-parameter read tool has few remaining gaps. The description covers what it does and where the results go; only invocation triggers and empty-result handling are absent.

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

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

Schema description coverage is 100% and the single timeout parameter is fully documented in the schema, so the baseline of 3 applies. The description adds no syntax, units, or tuning advice beyond what the schema already says.

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

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

States a specific verb and resource: 'Discover running Dart Tooling Daemon (DTD) URIs'. The domain (Flutter debugging) is explicit and unambiguous, and it is trivially distinguishable from every sibling, all of which are mobile UI-automation tools.

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

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

The description gives downstream context (the URIs feed connect_dart_tooling_daemon for hot reload and widget inspection), which implies when the tool is useful, but it never states a trigger condition or any when-not guidance, nor what to do if discovery returns nothing.

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

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

With no annotations, the description carries the full behavioral burden and does not meet it. It does not say what happens when no alert exists (error vs no-op), whether this dismisses via a cancel/negative button, or whether it affects device or app state beyond closing the dialog.

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 front-loaded sentence with no wasted words and the action stated first. It is arguably under-specified rather than over-long, but structurally it is clean and easy to scan.

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 values need not be explained, and the single required parameter is fully covered. Still, for a state-changing device interaction with zero annotations, the definition omits preconditions and the accept_alert distinction that an agent needs 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 device_id ('Simulator UDID') is already fully documented in the schema. The description adds no meaning about the parameter, so the baseline 3 applies.

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

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

States a specific verb (dismiss) and resource (the current alert dialog), which an agent can distinguish from a generic tap. However, it never contrasts with the sibling accept_alert, so the agent must infer whether 'dismiss' cancels the alert versus confirming 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?

Usage is only implied by the word 'current', which suggests an alert must already be on screen. There is no explicit when-to-use, no mention of accept_alert or get_alert_text as alternatives, and no note about what to do if no alert is present.

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

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

With no annotations, the description carries the full burden. It does disclose the conditional no-op semantics ('if visible'), which tells the agent it won't error on a keyboard-free screen, but says nothing about state side effects, blocking behavior, or failure modes.

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

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

A single short sentence with the action and the condition front-loaded, and zero wasted words.

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

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

An output schema exists, so return values need not be explained, and the single parameter is fully covered by the schema. For a trivial one-argument UI action the description is nearly sufficient; only explicit no-op/error behavior is missing.

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

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

One parameter at 100% schema coverage, so the schema already explains device_id as a Simulator UDID. The description adds no extra meaning about the parameter, so the baseline of 3 applies.

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

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

States a specific verb (dismiss) and resource (on-screen keyboard) that clearly distinguishes it from the alert-related siblings (dismiss_alert, accept_alert) and the generic input siblings. It stops short of naming or contrasting any alternative tool, so it lands at 4 rather than 5.

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

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

The qualifier 'if visible' implies the tool is safe to call unconditionally and is only meaningful when a keyboard is on screen, which is useful implied usage. There is no explicit guidance on when to prefer this over other recovery actions or what to do if it fails.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers almost nothing: it does not say the target must be a booted simulator, whether it requires an active session, what happens if coordinates are outside the screen, or what the interaction does to app state. For a UI-mutating gesture tool with zero annotation coverage this is a substantial 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?

A single short sentence with zero filler, and the key action is front-loaded. It is efficient, though the brevity edges toward under-specification rather than optimal economy.

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 values need no explanation, and parameters are fully documented in the schema. However, with no annotations and no output/behavioral context, the description omits the operational prerequisites (device must be booted, session state) that an agent needs before invoking a gesture on a simulator.

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

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

Schema description coverage is 100% (x, y, device_id all documented), so the schema already does the work and the baseline is 3. The description adds no coordinate-space detail (e.g., points vs pixels, origin corner) beyond what the schema states.

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

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

States a specific gesture verb ('double tap') and its target ('at coordinates'), which cleanly separates it from the sibling gestures 'tap' and 'long_press'. It does not explicitly name those siblings, but the distinct gesture name makes the resource 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 on when to use this versus 'tap' or 'long_press', no prerequisites (e.g., simulator must be booted, session active), and no exclusions. The agent must infer usage entirely from the name.

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

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

With no annotations, the description carries the full burden, and it discloses only the core behavior (retrieving alert text). It is silent on what happens when no alert is present (error vs. empty result) and whether it returns only text or also button labels. It does correctly convey a non-destructive read intent, which is the minimum for a simple reader.

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?

One sentence, front-loaded with the verb and scope, with zero filler. Nothing could be trimmed without losing meaning.

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 single-parameter reader with full schema coverage and an output schema covering return values, the description is nearly sufficient. The one real gap is the absence of any statement about behavior when no alert dialog is active.

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% for the single device_id parameter (documented as 'Simulator UDID'), so the schema already does the work. The description adds no additional meaning about the parameter, making the baseline 3 appropriate.

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

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

The description states a specific verb and resource ('Get the text of the current alert dialog'), which is far more precise than the tautological name alone. It does not explicitly differentiate itself from siblings like get_ui_tree, which could also surface alert text, so it falls 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?

Usage is only implied: the phrase 'current alert dialog' signals the precondition that an alert must be present, but the description never says when to reach for this over get_ui_tree or what to do if no alert is showing. No explicit when/when-not or alternatives are given.

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 supplied, so the description carries the burden, and it does disclose the value domain (dark/light mode). It says nothing about permission requirements, whether the device must be booted, or error behavior, but the presence of an output schema means the return shape does not need to be restated here.

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?

One short sentence, front-loaded with the verb and resource, with zero filler. Nothing can be trimmed without losing meaning.

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 single-parameter read tool with a fully documented schema and an output schema, the description is sufficient to call it correctly. Only a minor gap remains: no note that the target simulator must be booted or that this pairs with set_appearance.

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

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

Schema description coverage is 100% and the single parameter (device_id) is documented in the schema as a Simulator UDID, so the description adds no parameter detail. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description states a specific verb ('Get') plus resource ('current device appearance') and even enumerates the returned values (dark/light mode). It implicitly contrasts with the sibling set_appearance through the get/set split, but never names that sibling explicitly.

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 when-to-use guidance, no prerequisite (e.g. simulator must be booted), and no mention of the alternative set_appearance. The usage is inferable only because the tool is a trivial getter.

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

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

No annotations provided, so the description carries the full burden. It does not mention that it operates on a simulator device, whether an empty clipboard returns an error or null, permissions, or what the returned content looks like. 'Get' implies a safe read but this is not stated.

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

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

One short, front-loaded sentence with no waste. However, it is arguably too terse for a tool with no annotations and no usage guidance, so it's conciseness at the expense of 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?

An output schema exists, so return-value explanation is not needed. But with no annotations, no usage guidance, and no behavioral context (error handling on empty clipboard, device scoping), the description is minimal-viable rather than complete for a simulator 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% (device_id fully documented as Simulator UDID), so baseline 3 applies. The description adds no parameter-level detail 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?

States a specific verb (get) and resource (clipboard/pasteboard content), clearly distinguishing it from set_clipboard. The only gap is the lack of explicit statement that this reads from a simulator device, though the device_id param implies 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 explicit when-to-use guidance or alternatives named. Given the sibling set includes set_clipboard as the obvious counterpart, the description could have said 'reads clipboard content; to write, use set_clipboard'. Implied usage only.

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

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

No annotations are provided, so the description carries the full behavioral burden. It doesn't state that this is a read-only operation, what happens with an unknown/invalid UDID, or whether the device must be booted first — all relevant given siblings like boot_simulator and shutdown_simulator.

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 front-loaded sentence with zero filler. It is efficient, though so terse that it verges on under-specification rather than optimal conciseness.

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

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

An output schema exists, so return values needn't be explained, and with only one well-documented parameter the description is close to sufficient. However, with no annotations it omits the read-only nature and any prerequisite (e.g., booted simulator), leaving gaps an agent might hit.

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

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

Schema description coverage is 100%, and the schema documents device_id as 'Simulator UDID', so the baseline of 3 applies. The description adds no format or sourcing detail (e.g., where to obtain the UDID) 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?

Clear verb+resource: 'Get information about a specific simulator' tells the agent exactly what it retrieves. It implicitly contrasts with the sibling list_devices (single vs. list), but never names or explicitly distinguishes that alternative.

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 when-to-use guidance and no mention of alternatives such as list_devices to discover a device_id before calling this. The agent must infer usage entirely from the tool name and the required device_id parameter.

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

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

With no annotations, the description carries the full behavioral burden yet only restates 'resizing and format options,' which the schema already contains. It does not disclose prerequisites (e.g., simulator booted), whether capture is safe/non-destructive, or any timing/rate 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?

A single front-loaded sentence with no filler. It is efficiently sized, though the terseness comes at the cost of the guidance and behavioral detail noted elsewhere.

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 plus 100% parameter coverage mean params and return values need no explanation here. However, for a capture tool with no annotations, the description omits the prerequisite state (booted simulator) and any note on what is produced, leaving it only minimally 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 every parameter (scale, format, quality, device_id) is already documented in the schema. The description adds only a vague gesture at 'resizing and format,' yielding the baseline 3 with no extra semantic 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?

States a specific verb (capture) and resource (screenshot from the simulator) along with the capability area (resizing, format). It is clearly distinguishable from video-oriented siblings like start_recording/stop_recording, though the description never names a sibling to sharpen the boundary.

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 when-to-use guidance: nothing says the device must already be booted, nor when to prefer this over start_recording for video capture. Usage context is left entirely to inference.

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 does disclose useful behavior: the tree lists visible elements and attaches tap indices, which tells the agent the output is actionable. However, it omits read-only/rate-limit characteristics and does not mention that visibility filtering is configurable, leaving meaningful gaps 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?

A single front-loaded sentence with no filler, stating purpose and output utility immediately. It is arguably too terse given the tool's 4 parameters and output schema, but nothing in it is wasted.

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 explanation is not required, and the description correctly signals the actionable index output. It is still incomplete for a tool with this much sibling overlap, since it gives no routing context against get_screenshot or the tap/long_press tools whose indices it feeds.

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

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

Schema description coverage is 100% and all four parameters carry descriptions, so the baseline is 3. The phrase 'visible elements' loosely maps to only_visible, but the description adds no format or verbosity 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 states a specific verb and resource ('Get the UI accessibility tree') and adds what the result is for ('indices for tapping'), which distinguishes it reasonably well from screenshot-based siblings. It does not explicitly contrast itself with get_screenshot or get_window_size, so it stops short of full sibling differentiation.

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

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

There is no guidance on when to use this tool versus alternatives such as get_screenshot (visual) or get_window_size (dimensions), nor any prerequisites stated. The agent must infer the use case from the phrase 'indices for tapping'.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, and it says nothing beyond the resource name. It does not confirm this is a non-destructive read, does not state whether the target simulator must be booted, and does not describe error behavior for an unknown or shut-down device.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity borders on under-specification rather than optimal conciseness.

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

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

An output schema exists, so return values need not be explained, and the single parameter is fully documented. For a trivial getter this is close to adequate, but with zero annotations the missing note about device state prerequisites and read-only safety leaves a 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 100%: the single device_id parameter is documented as 'Simulator UDID'. The description adds no parameter meaning of its own, which is the expected baseline when the schema already does the work.

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

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

States a specific verb ('Get') and resource ('simulator window/screen size'), which is unambiguous about what the call returns. No sibling tool overlaps with this function, so there is no real ambiguity to resolve, but the description also does no explicit sibling differentiation.

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

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

There is no when-to-use guidance, no prerequisite (e.g. device must be booted), and no mention of alternatives. The only usage signal is implicit — an agent can infer this is for coordinate math or layout checks — but nothing is 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?

With no annotations, the description carries the full behavioral burden, yet it says nothing about side effects: whether the app is terminated or backgrounded, whether it fails without an active session, or whether it is idempotent. A single navigation sentence is thin for a state-changing UI 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?

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity is the same brevity that leaves behavioral gaps.

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 values need not be described, and the single parameter is documented. But with zero annotations, the missing session/precondition and side-effect context leaves the definition only minimally complete for a state-touching 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?

There is one parameter with 100% schema description coverage ('Simulator UDID'), so the schema already documents it. The description adds no meaning beyond that, which is the baseline case for full 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?

States a concrete verb and destination ('Navigate to home screen'), which is specific enough to distinguish a navigation action from alert/tap/text siblings. However, it does not differentiate from press_button, which could plausibly also return to the home screen, so a sibling-aware reader gets no routing help.

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 contains no when-to-use guidance, no prerequisites (e.g. an active session), and no mention of alternatives such as press_button. Usage is left entirely to inference.

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 does not disclose whether the app must be installed, whether launching fails if already running, whether it waits for launch completion, or any side effects or return behavior. For a mutation/action tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, front-loaded sentence with zero waste. It is appropriately sized for a simple two-parameter action 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?

While an output schema exists, the description lacks essential context for an action tool with no annotations: prerequisites (device must be booted), failure modes (app not installed), and interaction with similar tools like open_url. The description is too sparse to fully inform correct invocation in a simulator environment.

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 both parameters are fully documented in the schema, including an example bundle ID. The description adds no parameter details beyond what the schema provides, which is acceptable but not value-adding. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description states a specific verb (Launch) and resource (application), making the tool's primary action clear. It is distinguishable from terminate_app, list_apps, and other siblings by its focus on starting an app by bundle ID. However, it does not explicitly differentiate from open_url, which could also start apps via URL schemes.

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: use this to launch an app when you have its bundle ID. It does not state when NOT to use it, prerequisites (e.g., simulator must be booted), or alternatives like open_url or list_apps. This is the minimum viable guidance for an agent to infer the tool's purpose.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention that the simulator must be booted, whether system apps are included, or any side-effect-free read-only guarantee, leaving key operational context unstated.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to specifying the action and target.

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 one-parameter read tool with an output schema, the description covers the core operation and does not need to explain return values. However, given the absence of annotations, it is incomplete regarding prerequisites and scope, which an agent would need to invoke it reliably.

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 single device_id parameter is fully documented in the schema. The description adds no extra meaning or format details beyond that, matching the baseline of 3 when schema carries 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 states a specific verb ('List') and resource ('installed applications on the simulator'), making it immediately distinguishable from siblings like list_devices. An agent can identify the operation without opening the schema.

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

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

There is no guidance on when to use this tool versus related siblings such as list_devices, launch_app, or terminate_app. The description only states what it does, not when it is appropriate or what prerequisites exist.

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

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

With no annotations provided, the description must carry the behavioral burden. 'List' strongly implies a non-mutating read, and the mention of 'booted and available' adds useful state context, but there is no explicit statement of safety, side effects, or ordering. Adequate for an obviously read-only enumeration, but not rich.

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 efficient sentence with the resource front-loaded after the verb; no wasted clauses. The parenthetical is mildly redundant rather than wasteful.

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 explanation is rightly absent, and a zero-required, single-parameter read tool needs little more. Only the missing routing guidance against siblings keeps it from being complete.

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

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

Schema description coverage is 100%, so the only_booted parameter is already fully documented in the schema; the description adds no filtering syntax or semantics beyond it. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb ('List') and resource ('iOS simulators') with a scope qualifier ('booted and available'), which cleanly separates it from device-manipulation siblings like boot_simulator, shutdown_simulator and get_device. It loses a point only because the parenthetical scope phrasing partially overlaps awkwardly with the only_booted parameter, making the default scope slightly ambiguous.

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 call this versus get_device (single-device lookup) or list_apps, and no statement of prerequisites. The implied use case — enumerating simulators before boot/shutdown — is left entirely to inference.

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, and it says nothing about what a long press does at the OS level (context menu, drag start, selection) or any side effects. It also omits that duration defaults to 1 second and is tunable, which materially changes the gesture.

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 front-loaded sentence with zero filler, which is structurally clean. It is arguably terse to the point of under-specification rather than optimally concise, but nothing in it is wasted.

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?

Although the schema fully documents all four parameters and an output schema exists, the description does not address how this gesture differs from its many touch siblings, which is the main thing an agent needs to select it correctly. For a UI automation tool in this dense sibling set, that gap is significant.

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

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

Schema description coverage is 100%, with x, y, duration, and device_id all documented in the schema, so the baseline is 3. The description adds no additional meaning, such as coordinate origin or units, beyond what the schema already states.

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

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

States a specific action (long press) on a specific target (coordinates), so the agent knows the operation is a sustained touch at an x/y point. However, it offers no differentiation from the very similar siblings tap and double_tap, so the agent must infer the distinction from the name alone.

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

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

There is no guidance on when to use long_press versus tap, double_tap, swipe, or pinch. In a sibling set full of overlapping touch gestures, the absence of any selection criteria leaves the agent to guess.

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 usefully states that the URL opens in Safari or an associated app, but it omits side effects, whether the simulator must already be booted, and how the action interacts with the current session.

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

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

The description is a single front-loaded sentence with no redundant or wasted wording. It efficiently communicates the action and the resulting app 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?

The tool is simple and the schema fully documents both required parameters, with an output schema also present. Still, because there are no annotations, the description should ideally mention prerequisites or behavioral details such as boot state or session requirements.

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 both url and device_id are already documented in the input schema. The description adds no extra parameter semantics beyond what the schema provides, making the baseline score appropriate.

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

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

The description states a specific verb and resource: 'Open a URL in the simulator.' It also clarifies the likely target environment, Safari or an associated app, which distinguishes it from sibling tools such as launch_app.

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

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

The usage is implied by the action itself: use this when you need to open a URL on the simulator. However, it does not explicitly state when to use this instead of launch_app or other navigation tools, nor does it mention prerequisites such as needing a booted simulator.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose gesture duration, whether the call blocks until the gesture completes, how velocity interacts with the gesture, or any failure/retry behavior, leaving the agent with only the bare action semantics.

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 front-loaded sentence with the action verb first and zero filler. It is efficient, though there is so little content that nothing beyond the core action is anchored for the reader.

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 values need not be described, and all five parameters are documented in the schema. However, for an unannotated device-interaction tool with a timing-sensitive velocity parameter, the description omits any gesture-timing or completion behavior, leaving it only minimally 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% and the schema already explains x/y as the pinch center, scale as the zoom direction, velocity as scale-per-second, and device_id as the simulator UDID. The description adds nothing beyond 'at coordinates' mapping loosely to x/y, so baseline 3 applies.

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 ('Perform a pinch gesture') and the resource/effect (zoom in/out) plus where it happens (at coordinates), which is unambiguous against siblings like tap, swipe, double_tap, and long_press. It stops short of explicitly differentiating from those siblings, so a 4 rather than 5.

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

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

The parenthetical '(zoom in/out)' implies the intent of the gesture, but there is no guidance on when to choose pinch over swipe, double_tap, or other gestures, nor any preconditions. Like the update_drive calibration case, this lacks any when-to-use or alternative routing.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only restates the operation. It does not disclose side effects (e.g. home backgrounding the app), press duration, or whether the target simulator must already be booted, all of which matter for a device-control mutation.

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 short sentence with the action front-loaded and the valid options inline; efficient, though extremely terse and lacking any qualifying 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?

An output schema exists so return values need not be explained, and the buttons are covered. However, for a device-mutating tool with no annotations, prerequisites (booted simulator, session) and the home-vs-go_home choice are unaddressed, leaving it only minimally complete.

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

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

Schema coverage is 100% with both parameters documented and the button enum self-explanatory, so the schema does the heavy lifting. The description merely repeats the enum values and adds no format or semantic detail beyond it, so the baseline 3 applies.

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

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

States a specific verb (press) and resource (hardware button) and enumerates the three supported buttons, so the agent knows exactly what the tool does. It does not, however, distinguish itself from siblings like go_home (which may also press home) or long_press, leaving ambiguity about which action to pick for the home button.

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 explicit guidance on when to use this tool versus alternatives: it never clarifies press_button 'home' vs go_home, or the distinction from long_press. Usage can only be inferred from the button enumeration.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says it resets the session; it does not state whether this destroys state, requires specific permissions, is reversible, or what side effects occur. Behavioral detail is minimal.

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

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

Single sentence with no wasted words, front-loaded with the action and a parenthetical rationale. Appropriate length and structure.

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 a simple one-parameter tool with an output schema, the description covers purpose and a usage hint. However, with no annotations, it omits key behavioral context such as side effects or safety profile, leaving the agent to infer whether resetting is destructive.

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

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

Schema coverage is 100% and there is only one parameter (device_id). The description does not add any parameter semantics, but the schema already fully documents it, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Reset the WDA session') and adds a parenthetical condition ('useful if session expires or has errors'). It does not explicitly name sibling alternatives, but the operation is clearly distinct from UI actions like tap or swipe.

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

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

Provides a clear usage condition ('useful if session expires or has errors'), telling the agent when to invoke it. It does not state when not to use it or mention alternative tools, so it falls short of full when/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?

With no annotations, the description carries the full behavioral burden, but it only restates the two modes. It does not disclose whether a simulator must be booted, whether the change persists across sessions, or any side effects of switching appearance.

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 front-loaded sentence with no filler; the resource and valid modes are stated immediately. Nothing is wasted or buried.

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 values need no explanation, and both parameters are fully documented in the schema. The only shortfall is the absence of behavioral prerequisites (e.g., requiring a booted device) for a mutation tool with no annotations.

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

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

Schema description coverage is 100% and the enum already enumerates dark/light, so the schema fully documents both parameters. The description adds no format or meaning beyond what the schema provides, making baseline 3 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 gives a specific verb ('Set') and resource ('device appearance') and enumerates the two accepted modes. It implicitly contrasts with the sibling get_appearance via the set/get verb pair, though it never names that sibling explicitly.

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

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

There is no guidance on when to use this tool versus alternatives such as get_appearance or set_status_bar. Usage is only inferable from the verb+resource in the name, so an agent gets no explicit context or exclusions.

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

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

No annotations are provided, so the description carries the full burden. 'Set' implies a write/overwrite operation, but the description doesn't say that it overwrites existing clipboard content, whether it requires a booted simulator, or how it interacts with device state. Some value is implied by the verb, but significant behavioral context is missing.

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, front-loaded sentence with no waste. It's appropriately sized and easy to parse, though it borders on under-specified rather than merely concise.

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

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

An output schema exists, so return values needn't be explained, and schema coverage is full for parameters. However, with no annotations and a terse description, the agent lacks behavioral context such as permissions, device state requirements, and overwrite semantics. Adequate but gapped for a state-mutating 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 both parameters (content, device_id) are already fully documented in the schema. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (set) and resource (clipboard/pasteboard). It is distinguishable from its sibling get_clipboard by the verb, though the paired naming already makes the distinction obvious. Slightly terse but clear.

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

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

No guidance on when to use this versus alternatives, nor prerequisites. An agent can infer it replaces clipboard contents on a device, but nothing about intent, sequencing, or when not to use it is provided.

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

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

No annotations are provided, so the description carries the full burden. It doesn't disclose whether the simulator must be booted, whether the location change is persistent or temporary, what happens on invalid coordinates, or any side effects. Only the basic action is stated.

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

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

A single, clear sentence that is front-loaded and contains no unnecessary words. It efficiently conveys the core purpose.

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

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

With an output schema present, the description needn't explain return values. However, for a tool that mutates simulator state with no annotations, the description is minimal and lacks prerequisites or behavioral context. It is adequate but has clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (latitude, longitude, device_id). The description adds no extra meaning beyond what the schema provides. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (set) and resource (simulator's GPS location), clearly distinguishing it from siblings like set_status_bar, set_appearance, and set_clipboard. An agent can immediately understand what this 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?

No guidance on when to use this tool versus alternatives. It doesn't specify prerequisites such as needing a booted simulator, nor does it mention any conditions or exclusions. The description is purely a restatement of the action.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'Override' but does not disclose that the change persists until cleared (via clear_status_bar), that it only applies to simulators, or what permissions/requirements exist. This is a mutation tool with a significant gap in behavioral disclosure.

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

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

A single, front-loaded sentence with no wasted words. It communicates the action and the reason efficiently.

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

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

An output schema exists, so return values need not be described, and parameter documentation is complete. However, for a tool that overrides persistent simulator state, the description omits the restoration path (clear_status_bar) and the simulator-only constraint, leaving a gap in operational completeness.

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

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

Schema description coverage is 100%, so all parameters are fully documented in the schema. The description adds no additional parameter meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Override status bar appearance'. It clarifies the motivation ('for consistent screenshots'), but does not distinguish this tool from its counterpart clear_status_bar or set_appearance. An agent can understand the action but must infer sibling boundaries.

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 'for consistent screenshots' implies the primary use case, so usage is suggested. However, there is no explicit when-to-use vs when-not, and the alternative tools (clear_status_bar, set_appearance) are not referenced. Guidance is implied but incomplete.

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

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

No annotations are provided, so the description carries the full behavioral burden and does not meet it. It never says what shutdown entails (running apps are killed, in-memory state is lost), whether it requires the device to be booted first, whether it errors on an already-shutdown device, or whether the operation is reversible.

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?

One front-loaded sentence with zero padding, which is appropriate for a simple single-parameter action. It is efficient but so terse that it omits context rather than trimming 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?

An output schema exists, so return values need not be explained, but for a state-mutating device operation with no annotations and no usage guidance, the definition leaves out consequences and preconditions an agent needs to invoke it safely.

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 single device_id parameter has 100% schema description coverage ('Simulator UDID'), so the schema already documents it. The description adds no format hints or sourcing guidance, which is the expected baseline when the schema does the work.

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

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

States a specific verb (Shutdown) and resource (iOS simulator), so the action is unambiguous. However it does nothing to differentiate itself from the obvious sibling boot_simulator or note its role in a device lifecycle alongside list_devices/get_device.

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

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

No guidance on when to shut down a simulator versus booting, resetting (reset_session), or terminating an app. There is no mention of prerequisites, exclusions, or the alternative tool an agent should pick instead.

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

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

No annotations are provided, so the description carries the full burden. It discloses the two possible outcomes (success or failure) via the match parameter, but doesn't describe whether this blocks, requires an active app, or any side effects. For a simulation tool with an output schema, the description adds some value but leaves 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?

A single, front-loaded sentence that states the action and the controlled outcome. No wasted words.

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

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

Given the presence of an output schema, the description needn't explain return values, and it covers the core action and the outcome parameter. However, without annotations, it could be improved by noting prerequisites (e.g., simulator must be booted) or typical use case, but it is largely complete for a simple simulation 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 already fully documents both parameters (match and device_id). The description mentions success or failure but doesn't add syntax or format details beyond what the schema provides. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (simulate) and resource (Touch ID or Face ID authentication), and clarifies scope with success/failure. It clearly distinguishes itself from other simulator controls like tap or press_button.

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 simulate biometric authentication during testing) but gives no explicit when-to-use conditions, prerequisites, or alternatives. With many sibling tools, some guidance on when biometric simulation is relevant would help, but it's not strictly required for this focused utility.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one important trait: the external dependency on a separately started WebDriverAgent process. It says nothing about timeout behavior, failure modes, or whether a connection is cached/reused, and the return format is covered by the output schema.

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

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

A single front-loaded sentence with no filler, and the critical prerequisite is placed immediately after the purpose. It is arguably too terse for a connection tool, but nothing is wasted.

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 and full schema coverage mean return values and parameters need not be explained. Still, for a tool whose whole job is verifying an external connection, the description omits what a successful versus failed check means and whether the bridge must be re-established, leaving a meaningful 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 100%, so host, port, and device_id are already documented in the schema. The description adds no parameter-level detail beyond what the schema provides, which is the expected baseline when the schema does the heavy lifting.

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

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

The description states a concrete verb and resource ("Check WebDriverAgent connection"), which is specific enough to be understood. However, it conflicts with the tool name start_bridge, which implies establishing a bridge rather than verifying one, leaving the agent unsure whether this tool connects or merely probes. It also does not distinguish itself from sibling session/lifecycle tools like reset_session or list_devices.

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 parenthetical prerequisite ("WDA must be running separately via xcodebuild") gives useful context about when this call can succeed, implying it is a pre-flight check. But there is no explicit statement of when to call it versus alternatives, and no indication of what to do when the check fails.

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 burden. It usefully discloses that the output is only persisted via stop_recording and that the artifact is a .mov file, but omits whether an in-progress recording is overwritten, whether permissions are required, or what the call returns immediately.

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

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

Two short sentences, zero filler, with the core action front-loaded and the dependency on stop_recording stated second. Nothing redundant.

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 values need not be explained, and the description covers the essential start/stop relationship. It is nearly complete for a two-parameter tool, though it could note error/duplicate-recording 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 both device_id (Simulator UDID) and codec (enum hevc/h264) are already documented in the schema. The description adds no further meaning about parameter behavior or defaults, making the baseline 3 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 precise verb+resource ('Start screen recording') and explicitly names the paired sibling 'stop_recording', so an agent can distinguish the two without opening either schema. No ambiguity about what the tool initiates.

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 supplies a clear next-step context: recording is only saved by calling stop_recording, which tells the agent this is one half of an ordered workflow. It does not discuss preconditions (e.g., what happens if a recording is already active) or alternatives, but there are no true alternatives among siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose that the recording is saved to a file, which is useful beyond the name, but says nothing about error behavior when no recording is active, where the file lands, or permissions. An output schema exists, so return values are partly covered.

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

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

A single front-loaded sentence with zero filler; the action and its outcome are stated immediately.

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

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

For a one-parameter tool with an output schema, the description covers the core action and its save side effect. It is slightly under-specified on lifecycle prerequisites and failure modes, but nothing critical to invocation is missing.

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

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

One parameter with 100% schema description coverage; the schema already documents device_id as the Simulator UDID. The description adds no parameter meaning, which matches the baseline 3 when the schema does the heavy lifting.

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

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

States a specific verb (stop) and resource (screen recording) plus a side effect (save the video file). It contrasts implicitly with the sibling start_recording by name, but never names that pairing, so sibling 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?

Usage is only implied: an agent can infer this should be called when a recording is in progress, and that start_recording is the counterpart. There is no explicit when/when-not statement or prerequisite (e.g. must follow start_recording), so guidance is adequate but thin.

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 does not mention that coordinates can be specified directly or via direction, nor does it describe side effects. With zero annotation coverage, this is a significant gap.

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

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

The description is a single, short sentence with no wasted words, but it is arguably too terse for a tool with 7 parameters and no annotations. Still, it is front-loaded and efficient.

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

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

Given there are no annotations, an output schema exists, and 7 parameters, the description is insufficiently complete. It fails to explain coordinate vs. direction usage, required parameters beyond device_id, or behavioral aspects like default duration.

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

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

Schema coverage is 100%, so the schema already documents all 7 parameters with descriptions. The description adds no additional meaning or syntax beyond what the schema provides, meeting the baseline for high 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+resource ('Perform a swipe gesture'), so the basic purpose is clear. However, it does not distinguish this tool from siblings like 'long_press', 'pinch', or 'double_tap', leaving the agent to infer the distinction from names alone.

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

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

There is no explicit guidance on when to use this tool versus alternatives like 'tap' or 'long_press', nor any prerequisites or exclusions. The agent must infer usage from the tool name and siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about whether the tap blocks until completion, what happens on a missing element, whether coordinates are in device or screen space, or what the return value is. For a UI-interaction mutation, this is a significant gap.

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

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

A single front-loaded sentence with no waste. Slightly terse given the three targeting modes that could warrant a clarifying clause.

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 values need not be explained. However, with no annotations for a mutating interaction tool and no guidance on mode selection or failure behavior, the description is only minimally 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 all five parameters are already documented. The description adds only that index comes 'from UI tree' and predicate identifies an element, which is marginal beyond the schema. Baseline 3 is correct.

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

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

States a specific verb ('Tap') and resource ('an element'), and enumerates the three targeting modes (index, predicate, coordinates). This distinguishes it from siblings like double_tap and long_press.

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

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

The three modes imply when each applies (index from UI tree, predicate match, raw coordinates), but there is no explicit guidance on which to prefer, no prerequisites, and no exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It conveys only the bare effect (a running app is stopped) and says nothing about whether termination is graceful or forced, whether unsaved state is lost, what happens if the app is not running, or what errors can occur.

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

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

A single short sentence that is front-loaded and wastes no words. It is appropriately terse, though the brevity edges toward under-specification rather than optimal conciseness.

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

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

The output schema means return values need not be explained, and both parameters are fully documented, so the core call mechanics are covered. However, for a state-changing action tool with many siblings and zero annotations, the absence of any usage or behavioral context leaves the definition only minimally 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 both required parameters (bundle_id, device_id) are already documented in the schema. The description adds no extra meaning about parameter format or constraints, which is the expected baseline when the schema does the heavy lifting.

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

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

The description names a specific verb ('Terminate') and resource ('application'), making the action unambiguous. It does not, however, differentiate itself from sibling tools such as launch_app or list_apps, so the agent must infer the contrast from the name alone.

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

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

There is no guidance on when to use this tool versus alternatives like launch_app, nor any stated preconditions (e.g., the app must already be running, the simulator must be booted). The agent gets no routing or exclusion information.

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

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

No annotations are present, so the description carries the full behavioral burden. It omits whether typed text replaces or appends to existing content, what happens if no field is focused, failure modes, or permission/setup requirements for the simulator.

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 front-loaded sentence with a parenthetical qualifier, no filler. It is efficient, though the parenthetical slightly muddles what predicate does relative to the preceding tap instruction.

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 values need no explanation, and all three params are documented. Still, for a UI input mutation with zero annotations, the behavioral gaps (append vs replace, focus failure) leave it only minimally 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 schema already documents text, device_id, and predicate. The description only adds a marginal gloss on predicate ('tap element first'), which is already conveyed by the schema's own description.

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

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

States a specific verb+resource ('Type text') that is clearly distinct from the tap/swipe/press siblings. It does not, however, explicitly contrast itself against keyboard-adjacent siblings like dismiss_keyboard, so it stops short of full differentiation.

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

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

The parenthetical gives a procedural precondition ('tap input field first to focus, or provide predicate') which implies when the tool works, but never states alternatives or exclusions against sibling input tools. Usage context is implied rather than spelled out.

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