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

With no annotations, the description carries the load and does disclose a real behavioral trait: the app is brought to the foreground, not merely started. It says nothing about failure behavior (app not installed, ambiguous name match), permission requirements, or whether launching an already-running app restarts it or just focuses it.

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, no waste, with the action stated first and the parameter format immediately after. Perfectly front-loaded for a single-parameter 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?

For a one-parameter tool with no output schema and no annotations, the description covers the essential action and the accepted input formats. The remaining gap is edge-case behavior (not-installed, ambiguous names), which is minor but would help an agent recover from failures.

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 0%, so the description must compensate, and it does: the single `app` parameter is documented as accepting either a Bundle ID or a display name, with concrete examples ("Settings", "WeChat"). This resolves the main ambiguity an agent would face, though it doesn't say which form is preferred or how to disambiguate duplicate display names.

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: launch an app and bring it to the foreground. That scope distinguishes it from iphone_terminate_app and iphone_list_apps, though it never names those siblings 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 implied by the action itself (call this to get an app running in front), but there is no explicit guidance on when to prefer it over iphone_open_url or iphone_list_apps, and no statement about what happens if the app is already running. The agent must 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 must carry the burden, and it does establish this as a non-destructive listing that returns app names and bundle IDs. It says nothing about permissions, device-connection requirements, or whether the list is truncated, which matters for a device-bridge 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?

Two short sentences with the resource and return content front-loaded and the flag behavior second. Nothing is wasted and nothing essential is 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?

For a one-parameter read-only listing this is nearly sufficient: the return shape is described in prose despite no output schema, and the only parameter is explained. Missing device-state prerequisites or output ordering, which is a minor gap for such a simple tool.

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

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

Schema description coverage is 0% for the single parameter, so the description must compensate — and it does, explaining that include_system=True adds system apps, implicitly defining the default false case as user apps only. It could have stated the default explicitly, but the meaning is recoverable.

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 (list installed apps) and even specifies the returned fields (name and Bundle ID), which lets an agent distinguish it from mutating siblings like iphone_launch_app or iphone_terminate_app. It stops short of explicitly naming those siblings, so it is clear but not fully differentiated.

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 use case is implied — enumerate apps so an agent can pick one to launch or terminate — but the description never says when to call it versus iphone_status or iphone_launch_app, nor any prerequisites. The only explicit conditional guidance concerns the include_system flag.

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 zero annotations the description carries the full burden, and it discloses non-obvious traits: on-screen determination is coordinate-based, and elements obscured by popups may still be listed. It also notes case-insensitive matching. It does not cover ordering, truncation via limit, or performance cost.

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

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

Three short lines: what is returned first, then the filter semantic, then the caveat. Every sentence adds information an agent would otherwise have to guess.

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?

No output schema and no annotations, so the description correctly spells out the return shape and the key reliability caveat. The only real gap is the undocumented `limit` behavior, a minor omission for a two-parameter read tool.

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

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

Schema coverage is 0%, so the description must compensate. It does so fully for `filter` (case-insensitive substring over label/name/value, which is more specific than the schema's bare 'string'), but `limit` (default 150) is never mentioned — what it caps and what happens on truncation is left unexplained.

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 (列出屏幕上带文字的界面元素) and enumerates the returned fields (类型、标签、中心点坐标、尺寸), which distinguishes it from iphone_screenshot (pixels) and iphone_tap_element (action on an element). An agent knows exactly what it gets back without opening a 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?

Implies the use case (inspecting text-bearing elements to locate one before tapping) and explicitly routes to iphone_screenshot when the listing is ambiguous (不确定时截图核对). No explicit 'when not to use' or guidance on when iphone_tap_element suffices on its own.

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 describing behavior, yet it says nothing about hold duration, side effects (such as a context menu or drag), device-state requirements, or failure modes. The only behavioral information is that the action is coordinate-based rather than element-based, which is already obvious from the name.

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 consists of a single short sentence that is front-loaded and contains no filler. This brevity, however, crosses into under-specification: nothing is wasted, but nothing useful beyond the bare action is conveyed.

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

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

For a 3-parameter mutation-style UI tool with no annotations and no output schema, one sentence is far from sufficient. The undeclared seconds default and the unspecified coordinate format are gaps an agent would hit immediately when calling it.

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 0%, so the schema names only the fields x, y, and seconds with no units, coordinate space, or ranges. The description adds nothing: it never mentions the seconds parameter or its default of 1, and it does not clarify whether coordinates are absolute pixels, points, or normalized values.

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 plus resource: long-press at a screen coordinate. That is enough to separate it from iphone_tap and iphone_tap_element, since it implies a press-and-hold. It never names those siblings, so the distinction is left implicit rather than explicit.

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

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

The description gives no indication of when to use long press instead of iphone_tap or iphone_tap_element, nor any precondition such as the target app being foregrounded or the element being identified. The agent must guess the use case from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the useful trait that web pages go through Safari, but says nothing about what happens when a custom scheme has no registered handler, whether the call blocks until the app opens, whether it returns anything, or what errors to expect from a device-side 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?

The description is a single compact sentence that front-loads the action and adds the Safari behavior in parentheses. Nothing wasted, nothing 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?

With one required parameter, no output schema, and no annotations, the definition is minimal but workable. It omits return behavior and failure modes for unsupported schemes, which matters for a tool that causes a real device-side side effect.

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 0%, so the schema adds no meaning to `url`. The description partially compensates by stating that the parameter accepts both ordinary links and URL Schemes, which is genuinely beyond the schema, but it still gives no format examples, scheme syntax, or encoding requirements.

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 pairs the specific verb "打开" (open) with the resource "链接或 URL Scheme", and notes the concrete outcome that web pages open in Safari. This distinguishes it implicitly from siblings like iphone_launch_app, but does not say so explicitly by name.

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

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

The description gives no explicit when-to-use guidance, no when-not-to-use guidance, and does not name alternatives. It does not say when to prefer iphone_open_url, which opens a URL or URL scheme, over iphone_launch_app, which launches an app, even though an agent could plausibly confuse the two.

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

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

With no annotations provided, the description carries the full behavioral burden. It usefully discloses that lock locks the screen and that subsequent operations auto-unlock when a password is configured, but it does not describe return values, error conditions, or whether volume presses have side effects.

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

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

The definition is a single front-loaded sentence that lists the supported buttons and their effects without any wasted text. It is appropriately sized for a simple one-parameter hardware-key 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?

For a simple one-parameter tool with no output schema and no annotations, the description gives the essential button values and effects. It is nearly complete, though it could mention success/failure behavior or any device-state prerequisites.

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 0%, so the description must compensate. It does so by enumerating the accepted button values (home, volume_up, volume_down, lock) and explaining what each does, though it does not specify case sensitivity or whether other values are rejected.

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: pressing a hardware button on the iPhone. It also enumerates the supported button values and their meanings, making it clearly distinguishable from sibling tools like iphone_tap or iphone_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 description implies usage by listing hardware buttons, but it does not explicitly say when to use this tool versus alternatives such as iphone_tap or iphone_lock. No exclusions or prerequisites are stated beyond the note about password auto-unlock.

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 does substantial work: it discloses that the image is scaled to point dimensions so pixel coordinates map directly to tap/swipe, that cropping comes from a higher-resolution original, and that the returned text carries a magnification factor with a conversion formula. What's missing is any statement of the return shape (image vs text payload) or limits on capture frequency.

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?

Front-loaded with the core action and tightly structured into base behavior then zoom behavior. The second paragraph is dense with coordinate math but each clause carries necessary information; only minor tightening is possible.

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?

No output schema and no annotations exist, but the description supplies the key behavioral contract: point-space coordinates, zoom-crop behavior, and how to convert returned-image coordinates back to screen points. It stops short of describing the actual return payload (screenshot image plus text) which an agent would benefit from knowing up front.

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 0%, so the description must compensate, and it does define the meaning of x/y/width/height as a point-space crop region with extra magnification for small areas. However, it never clarifies the four parameters' interaction — whether all four must be supplied together, or what happens if only some are given — leaving optionality semantics ambiguous.

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

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

The description opens with a specific verb and resource ("截取当前屏幕" – capture current screen) and explicitly links the output to the coordinate-consuming siblings (tap/swipe). An agent can distinguish it from iphone_list_elements, iphone_status, and iphone_tap 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?

It gives a clear conditional rule for the region parameters: "看不清小图标、小字时" pass x/y/width/height to zoom. That covers when to invoke the optional path, but it never states an explicit alternative tool (e.g. list_elements for reading UI structure) or when not to screenshot.

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 add real value by disclosing the four pieces of state returned, which matters for deciding whether the device is usable. It does not say whether the call is side-effect free, what happens when WDA is unavailable (error vs. degraded result), or how costly/latent the probe is.

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

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

A single sentence with the purpose front-loaded and the returned fields listed after the colon. Every element earns its place; nothing is 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?

For a zero-parameter, no-output-schema tool, the enumerated fields effectively substitute for a return-value description, which is the main thing an agent needs. Only the failure mode when WDA is not ready is 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?

The tool takes zero parameters, so the schema has nothing to explain and the baseline is 4. The description correctly implies a parameterless status probe, and no parameter detail is missing.

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+resource ('查看连接状态') and enumerates exactly what is reported: WDA readiness, lock state, foreground app, and screen size. This clearly separates it from the action siblings (tap, swipe, launch_app, screenshot), though it never explicitly labels itself as the read-only inspection tool among them.

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

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

Usage is only implied — an agent can infer this is a pre-flight check before tapping or typing, but the description never says when to call it, that it should precede other iphone_* actions, or what to do if WDA is not ready. No alternatives or exclusions are named.

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

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

No annotations exist, so the description carries the full disclosure burden. It doesn't state that the swipe mutates UI state (scrolling, drag-and-drop, dismissing sheets), nor mention the 'seconds' duration parameter's effect on gesture speed or flick vs. drag behavior. The only behavioral hint is the direction example.

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, front-loaded with the core action and followed by the most practically useful example. No filler, though the parenthetical "(点坐标)" is slightly redundant given the parameter names.

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 gesture tool with no annotations, no output schema, and 0% parameter documentation, the description leaves critical gaps: coordinate units/resolution assumptions, what 'seconds' controls, and whether swipes can trigger destructive side effects. An agent could easily call this with wrong-scale coordinates.

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 0%, so the description must compensate for 5 bare parameters. It does add real meaning for from_y/to_y by explaining the directional convention (large from_y, small to_y = swipe up), which is not in the schema. But it says nothing about the coordinate system (pixels vs. normalized), from_x/to_x semantics, or the 'seconds' parameter.

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

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

The description gives a specific verb+resource pair ("从一点滑到另一点", swipe between two points) that clearly separates it from siblings like iphone_tap and iphone_long_press. It doesn't name those siblings explicitly, but the gesture semantics are 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?

It provides one concrete usage scenario (swipe up to reveal content below, with the from_y/to_y relationship spelled out), which is genuinely helpful. However, it never says when to prefer swipe over other gestures, nor any preconditions such as requiring an app in the foreground.

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, and it discloses nothing: no coordinate system (pixels vs points), no device/emulator targeting, no sync or wait behavior, no error modes for out-of-bounds taps. The parenthetical '(点)' is too ambiguous to count as a unit 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?

It is short and front-loaded, but the brevity is under-specification rather than economy; a single fragment cannot carry a tool's critical call semantics.

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

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

With no annotations, no output schema, and 0% parameter coverage, the description is the only source of behavioral detail for a mutation action on a device — and it provides essentially none.

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 0%, so the description must compensate, and it only weakly does so by implying x/y are screen coordinates. It adds no origin convention, no range, and no units, leaving both required parameters effectively undocumented.

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: tapping a screen coordinate. An agent can tell it is a coordinate-based tap rather than an element-based one, but the description never names the closely related sibling iphone_tap_element, so the differentiation is only implicit in the word 坐标.

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 statement of when to use this tool versus iphone_tap_element, iphone_long_press, or iphone_swipe, and no preconditions such as the target app needing to be foregrounded. The agent must infer everything 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 behavioral burden. It usefully discloses exact-vs-substring matching and index ordering, but it does not explain failure behavior when no match exists, whether the tap waits/retries, or what side effects/permissions are involved.

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

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

The description is compact and front-loaded with the action, followed by matching behavior and index semantics. Every sentence contributes directly to correct invocation.

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 two-parameter UI action tool with no output schema or annotations, the description covers selection semantics well. It is still incomplete regarding no-match behavior and return/error expectations, which an agent may need in order to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must define the parameters, and it does: 'text' is the label/name to match, with a clear exact-first-then-contains rule, and 'index' selects among multiple matches starting at 0. It also links index ordering to iphone_list_elements, adding meaningful semantics beyond the bare 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 action—tap an element by text—and explains the matching rule (exact label/name first, then substring). This clearly distinguishes it from coordinate-based iphone_tap and from listing tools such as iphone_list_elements.

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

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

The matching algorithm implies when this tool is appropriate: when the caller knows the visible text of the target. However, it does not explicitly say when to prefer iphone_tap or what to do if no element is found, so usage guidance remains implied rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether termination is a forceful kill, whether unsaved state is lost, whether the app must be running, or what happens if the app isn't found — all critical for a destructive-ish operation.

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

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

Two short sentences, purpose front-loaded and the parameter hint second. Zero waste and easy to parse.

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

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

With one parameter, no output schema, and no annotations, the description covers the input adequately but leaves the behavioral side thin. It's sufficient to invoke the tool but not to predict outcomes or handle failure cases.

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 0% (the schema only says 'string, title: App'), so the description meaningfully compensates by specifying that the value accepts either a Bundle ID or a display name. That is exactly the disambiguation an agent needs, though it omits case-sensitivity or format examples.

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

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

States a specific verb (terminate) and resource (App process), which clearly separates it from the launch_app/open_url siblings. It stops short of naming a sibling or scoping when termination applies, so it's clear but not perfectly differentiated.

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, when-not-to-use, or alternative guidance. The agent must infer from the name alone that this is the counterpart to iphone_launch_app, and nothing says what to do if the app is already closed or whether a relaunch is expected afterward.

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 exist, so the description carries the full burden. It usefully discloses the focus prerequisite and the submit behavior, but says nothing about what happens if no field is focused, whether the call errors or silently no-ops, or what the tool returns.

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

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

Three short clauses, no filler, and the focus prerequisite is front-loaded ahead of the submit behavior. Every sentence earns its place.

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

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

For a simple two-parameter UI automation tool with no output schema and no annotations, the description covers the essential precondition and the optional submit flag. It falls short only on error behavior when nothing is focused.

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 0%, so the description must compensate, and it does for both parameters: `text` is described as text input with Chinese support, and `submit` is described as pressing Enter at the end. Only minor gaps remain, such as accepted text formats or length limits.

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 ('输入文字' into '当前获得焦点的输入框') and adds the scope qualifier that it targets the focused field. It is clearly distinct from sibling tools like iphone_tap and iphone_tap_element, which it explicitly says must run first.

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 states a prerequisite ('需要先点中输入框'), which routes the agent to iphone_tap/iphone_tap_element before calling this tool. It gives clear context but does not name the alternative tools explicitly or cover failure cases.

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