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 useful behavior: the report is 'read and tallied by the team that builds it' and that one call suffices with any subset of fields. However it omits whether the submission persists, whether a response is returned, or whether a session is required.

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?

Core purpose and the field semantics are front-loaded, but the motivational framing ('you are one of the few who actually use it', 'the wishes of working agents are the roadmap') is rhetorical padding that doesn't help an agent invoke the tool correctly.

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 6-param, optional-all feedback tool with no output schema or annotations, the description is largely sufficient: it covers purpose, most fields, and timing. Gaps are the unexplained 'device' parameter and the absence of any return/confirmation 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 coverage is only 17% (just the rating field), so the description must compensate. It does: it defines broke, worked, wish and workaround with concrete meanings, covering 4 of the 6 parameters. Only 'device' is left unexplained, and rating is covered by 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?

States a specific verb+resource ('File a field report about THIS tool') and enumerates the report's dimensions (broke/worked/wish/workaround). It is clearly distinct from the device-control siblings like previewapk_tap or previewapk_screenshot. Minor ambiguity in 'THIS tool' (the feedback tool vs. the whole previewapk server), but the intent is recoverable.

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?

Explicitly says when to file ('before you stop the session, while the details are fresh') and clarifies the calling pattern ('One call, any subset of fields'). No alternatives exist among siblings, so no exclusion is needed, but it doesn't state any condition under which you should NOT file.

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 add real context: the link is view-only, minted at session start, and invalidated when the session ends, and driver_note signals whether the user took control. It omits permissions/auth needs, rate limits, and whether calling it has 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?

A single sentence with the primary return value front-loaded and parenthetical qualifiers doing useful work. It is dense but every clause (view-only, minted at start, dies at end, driver_note meaning) adds information.

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

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

There is no output schema, so the description must convey the return payload; it names the share link and driver state but not the shape or other fields beyond driver_note. Combined with the unexplained 'device' parameter, an agent has enough to call it but not a full picture.

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 parameter 'device' has 0% schema description coverage and is never mentioned in the description, so its meaning (device id? name? optional targeting?) is entirely undocumented. With one undocumented parameter, the description fails to compensate for the coverage gap.

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 the resource returned — the live session's share link plus driver state — which is specific and clearly distinct from siblings like previewapk_get_logs, previewapk_status, or previewapk_screenshot. The retrieval verb is only implied by the tool name rather than stated, but an agent can still tell what this tool yields.

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 when-to-use guidance or alternative named. The description notes the link is view-only and session-scoped, which hints at lifecycle, but it never says when to call this versus previewapk_status, which also exposes driver/session state.

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 that logs remain readable after session end via a saved tail of the last session, which is real added context. However, it says nothing about defaults (e.g., 100 lines), retention limits, or whether the log is cumulative across relaunches.

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

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

Three sentences, front-loaded with what the tool returns, then usage, then the session-end caveat. Every sentence contributes, though the phrasing is slightly conversational rather than maximally tight.

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 read-only log tool with no annotations and no output schema, the description covers what is returned and the post-session availability, which is the essential context. It leaves gaps on the filter parameters and default behavior that an agent would need to invoke it well.

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 only 40% (lines, device and errors_only are undocumented), and the description mentions no parameters at all — it never explains filtering by line count, device, or errors-only mode. With 5 parameters and low schema coverage, the description fails to compensate for the gaps.

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

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

States a specific verb (Read) and resource (the attached app's debug log / logcat) and enumerates the content it surfaces: prints, warnings, errors and crash traces. An agent can immediately tell this apart from siblings like previewapk_hierarchy, previewapk_screenshot or previewapk_status, which cover different artifacts.

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?

Explicitly says when to reach for it: 'Check it after actions and whenever something misbehaves: a crash's exact reason is here.' It also clarifies a non-obvious edge case (works after the session ends via the saved tail). No when-not guidance or named alternatives, but no sibling duplicates this capability, so the routing gap is minor.

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 core behavioral trait — that control is transferred between agent and human — but says nothing about whether the call blocks, what happens to the session while the user drives, or how the agent should behave afterward.

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 compact sentence with a parenthetical example; the core handoff concept is front-loaded and no sentence is wasted. Slightly dense due to the metaphor, but structurally sound.

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 and no output schema, the description should say more about what happens after handoff — whether the call returns immediately, how the agent regains control, and what 'device' selects. The core behavior is covered but surrounding context is thin.

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 explains both values of the required 'to' parameter meaningfully, but the optional 'device' parameter is entirely unaddressed, leaving half the parameters 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?

The description states a specific action ('pass the wheel mid-session') and clarifies the two directions of control transfer. It is distinguishable from sibling device-control tools, though the resource being handed off (session control) is conveyed through metaphor rather than named directly.

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 concrete when-to-use example ('after you've verified a feature') and explains what each enum direction achieves. It stops short of naming when not to use it or pointing at alternative siblings, so it lands below full marks.

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

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

With no annotations, the description carries the burden and does disclose the key behavioral trait: this returns a structured tree rather than pixels and is 'much faster and cheaper' than a screenshot. It does not state that the operation is non-mutating, nor any error/default behavior, but the cost model and return nature are substantive context beyond a bare purpose statement.

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 tightly packed sentences with zero waste: the resource and return shape come first, the performance rationale second, and the alternative routing last. Nothing is redundant or 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?

There is no output schema, so the description correctly takes on the job of enumerating return fields, which it does thoroughly. The only meaningful hole is the unexplained 'device' parameter, which is the sole input.

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% and there is one parameter ('device') that is never mentioned or explained in the description. The description must compensate for the coverage gap and does not, so the agent gets no guidance on what device identifier to supply or what the default is.

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?

Names a specific verb and resource ('Get the current screen as a UI element tree') and enumerates the returned fields (class, text, content-desc, resource id, bounds, center coordinates, state flags). It explicitly contrasts itself with previewapk_screenshot ('instead of pixels'), so an agent can tell the two apart 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?

Gives explicit when-to-use conditions ('find elements, read values, check state' for navigation and assertions) and names the alternative with its own use case ('Use previewapk_screenshot for visual checks (layout, overlap, images)'). The routing decision is fully specified.

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 discloses the return contents, which is the key behavioral fact for a zero-argument discovery tool. It does not discuss auth requirements, rate limits, or whether the list is paginated, but for a simple read-only enumeration the disclosed output shape covers most of what an agent needs.

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 tight sentences with no waste: the first declares the resource and its returned fields, the second front-loads the ordering instruction before the chaining detail. Every clause earns its place.

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

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

With no output schema and no annotations, the description compensates by listing the returned fields and explaining the role of the result in the wider tool chain. An agent has everything needed to call it correctly and use the output.

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 baseline is 4. The description adds genuine cross-tool semantics by explaining that the chosen device's name or id becomes the 'device' argument on the other tools, which is information no schema field conveys.

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 the devices on this account') and enumerates the fields returned (name, id, profile, Android version, status, attached app). It does not name the nearby sibling previewapk_use_device, which also deals with device selection, so sibling differentiation is only implied 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?

Gives a clear trigger condition ('when the account may have more than one device') and tells the agent to call it FIRST, plus how to chain the result into other tools. It never states a when-not case or names an alternative (e.g. previewapk_use_device) for when a device is already known.

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 it is silent on whether the keypress targets the active device or the `device` param, what the call returns, or any side effects (navigation, focus loss, app changes). Only the keycode values are disclosed.

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

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

A single front-loaded sentence with the verb first and the keycode mapping immediately after. Every token earns its place; there is no filler.

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

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

With no annotations, no output schema, 2 parameters at 0% schema coverage, and no description of the `device` parameter or post-keypress behavior, an agent lacks the context to call this tool confidently in a multi-device session.

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 document meaningful `keycode` values (4=Back, 3=Home, 187=Recents, 66=Enter, 67=Delete), which is genuinely useful, but it never states that the field takes a raw Android keycode integer or explains the `device` parameter at all.

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 ('Send') and resource ('Android keycode') with the accepted values enumerated, which clearly separates it from siblings like previewapk_tap, previewapk_swipe and previewapk_type_text. It does not explicitly name those siblings, so it stops 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?

The description says what the tool does but gives no guidance on when to use it versus tapping or typing text, no prerequisites, and no indication of which device it targets. Usage must be inferred entirely from the tool 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 does a fair job: it discloses that the APK is installed and relaunched with no reboot when hot-swapping, and that the response contains parsed app info with swapped=true. It omits failure modes (invalid/mismatched APK), what happens to existing app state on a hot-swap, and any permission or device-precondition detail beyond 'hold the wheel'.

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 tight sentences, front-loaded with the action, then the two conditional behaviors, then the return signal. Every clause carries information and nothing is repeated from the name or schema.

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

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

For a mutating tool with no annotations and no output schema, the description covers the important branch-dependent behavior and even names the return field (swapped), which is genuinely useful. It is slightly short on error/precondition handling and leaves the device parameter unexplained, but the core picture is complete.

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

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

Schema coverage is only 50%: 'path' is documented as a local .apk path and the description's 'from this machine' reinforces that, but 'device' has no schema description. The description only refers to 'the device' and 'hold the wheel', which hints at a currently-attached device but never explains how the device argument is identified or supplied.

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 first sentence gives a specific verb and resource — upload an APK from this machine to the device — which no sibling tool does. The follow-on sentences further disambiguate it by describing the two device states under which the upload behaves differently, so an agent can place it precisely among the previewapk_* tools.

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

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

It states two concrete conditions for use: device OFF makes the APK the attached app (then call previewapk_start), and device RUNNING with the wheel held triggers a live hot-swap. That is real routing guidance including a follow-up call, but it stops short of stating exclusions or contrasting this with alternatives such as previewapk_relaunch.

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

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

No annotations are provided, so the description carries full burden. It discloses useful traits beyond the schema: the ~2 second latency and that no reboot is required, which tells the agent the session survives. It omits what happens if no session/app exists and whether state is preserved, leaving real gaps for a state-changing tool.

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

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

Two tight sentences, front-loaded with the core action and followed by the conditions and cost. Zero filler, every clause earns its place.

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

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

For a single-param, no-output-schema tool the description covers purpose, triggers, and timing adequately. It leaves the device parameter unexplained and gives no error behavior (e.g., no active session), which are the remaining 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?

There is one parameter (device) with 0% schema description coverage, so the description must compensate and does not — the device argument is never mentioned. With low coverage and no explanatory text, the agent gets no syntax or scoping guidance for the 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 names a specific action (bring the session's app back to the foreground) and its outcome, with concrete triggering scenarios. It distinguishes the operation from cold-start siblings by framing it as a return to foreground, but never names an alternative like start or use_device 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?

It gives clear when-to-use context: after Back exits to the launcher, or the app crashed or was closed. This is more than implied usage. It offers no exclusions or explicit routing against siblings, which keeps it short of a 5.

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 add real behavioral context: the image is the actual framebuffer, not a synthesized view; the download auto-resumes if the connection drops; and scale should be lowered on weak networks. It still doesn't say whether the call blocks until capture completes, whether a device must be selected first, or what format the image is returned in.

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 tight sentences with the core purpose front-loaded and no filler. The parenthetical parenthetical about the framebuffer is slightly dense, but it carries genuine disambiguating information against the hierarchy sibling.

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 parameterless-required, no-output-schema capture tool, this covers what the return is, when to use it, and network caveats. The main gap is the undocumented 'device' parameter — an agent can't tell whether it must call previewapk_use_device first or whether omission targets the current device.

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 50%: 'scale' is already documented in the schema, and the description's 'pass scale=0.5 on weak networks for a quarter-size transfer' adds usage context for it. But the 'device' parameter is undocumented in both schema and description, and the 'quarter-size' wording sits awkwardly against the schema's 'half-size frame'.

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 (capture the device's current screen as an image) and pins down *which* screen representation it returns ('the real framebuffer — it agrees with the hierarchy'), which cleanly separates it from the previewapk_hierarchy sibling.

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?

'Use it to verify your changes look right' gives a clear use context, and the hierarchy reference implies the sibling relationship. However, it never explicitly states when to prefer the hierarchy sibling or when a screenshot is the wrong tool, so it stops short of full 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?

With no annotations, the description carries the full burden. It usefully discloses that in driver='user' mode the agent's input is refused and points to where session links come from, but it omits preconditions, what state a start creates or overwrites, permission requirements, and what happens if a session already exists.

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

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

Three front-loaded sentences with little waste: purpose first, then the driver semantics, then the return/next-step guidance. All earn their place, though the final sentence about session_url is slightly tangential to the start action itself.

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 or annotations exist, so the description must stand alone. It covers the action, the key parameter's semantics, and the high-level return flow (links info), which is enough for correct invocation, though the 'device' parameter and the exact return shape remain unspecified.

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 an excellent job on the driver enum (clearly defining agent vs user behavior), but the required 'device' parameter is never explained — no format, ID source, or relationship to previewapk_list_devices — leaving half the parameters semantically 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?

"Start a preview session for the device's attached app" is a specific verb+resource that clearly distinguishes it from previewapk_stop and the action siblings (tap/swipe/type). However it never explicitly clarifies its boundary against previewapk_relaunch or previewapk_use_device, both of which also relate to getting an app running, so differentiation from those siblings 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?

The description explains the agent vs user driving modes well, but that is parameter selection guidance rather than when-to-call-this-tool guidance. There is no statement of preconditions (e.g. does a device need to be selected first via previewapk_use_device) or when to prefer this over relaunch, so usage is only implied.

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 list the fields surfaced (app, session status, driver, links), which is useful, but it never states that this is a non-mutating read, whether it has side effects, whether a device must be active, or how results are scoped. For a zero-annotation tool this leaves the safety and behavior profile largely 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?

A single compact sentence that front-loads the subject (owner's device state) and then enumerates the returned fields. Nothing is redundant, though the terse enumeration style borders on under-specification rather than deliberate brevity.

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 fully documented parameter and no output schema, the description partially compensates by listing the fields returned. It still omits whether the call is read-only, what happens with zero devices attached, and how this relates to previewapk_list_devices or previewapk_use_device. Adequate but with clear gaps for a device-status tool.

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

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

Schema coverage is 100%, so the single 'device' parameter is already documented, giving a baseline of 3. The description adds real meaning beyond the schema: the plural 'device(s)' combined with an optional filter implies that omitting the parameter returns state for all of the owner's devices rather than failing. That is a genuine semantic contribution.

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 phrase 'State of the owner's PreviewAPK device(s)' identifies a status/read concept and enumerates what it surfaces (attached app, session status, driver, links), which sets it apart from action siblings like previewapk_tap or previewapk_screenshot. However, it is a noun fragment with no verb, so the actual operation is only implied rather than stated. Purpose is inferable but not crisply defined.

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

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

There is no statement of when to call this tool, when not to, or which sibling to prefer. An agent must guess that this is the 'check current state' entry point versus previewapk_list_devices or previewapk_use_device. No prerequisites (e.g., whether a device must be selected first) 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?

With no annotations, the description carries full behavioral burden. It does disclose one important consequence — "The session link dies with it" — signaling a destructive, session-terminating effect. It says nothing about idempotency, what happens without an active session, or the effect on connected devices, leaving meaningful gaps.

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

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

The core action is correctly front-loaded, but the second sentence is a lengthy, partly redundant pitch for a different tool ("It takes one call and it directly shapes what gets fixed and built next" restates the prior clause) and occupies more space than the actual tool behavior.

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 no-annotation, no-output-schema tool, the description covers the destructive consequence but omits the undocumented parameter, preconditions, and post-conditions. It is roughly minimum viable rather than complete.

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

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

The single `device` parameter has 0% schema description coverage, and the description never mentions it or explains whether it is required or how it scopes the stop. The description therefore fails to compensate for the schema gap.

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 first sentence states a specific verb and resource ("Stop the session"), which clearly contrasts with the sibling previewapk_start by implication. It stops short of naming what a "session" is or differentiating from other lifecycle tools like previewapk_handoff or previewapk_relaunch, so an agent must infer 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?

It gives an explicit pre-condition routing instruction — call previewapk_feedback before stopping — which is genuine sequencing guidance. However, it never states the conditions under which stopping is or isn't appropriate (e.g., after handoff, with active devices), so its own usage context is only implied.

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 the duration default (300ms), but says nothing about device targeting (a real concern given sibling tools previewapk_use_device/list_devices), whether the gesture is synchronous, or what happens on failure.

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 compact sentences, front-loaded with the coordinate semantics and the optional/default duration. No filler; every clause carries information the schema lacks.

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 and no output schema, the description covers coordinate semantics adequately but omits device selection and execution behavior. It is minimally sufficient rather than 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 0%, so the description must compensate. It does well for five of six parameters by defining x1/y1/x2/y2 as normalized 0..1 fractions and giving duration_ms an optional flag plus default, but the 'device' parameter is left completely undocumented in both schema and 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 (swipe) and resource (screen gesture) with the exact coordinate convention '0..1 fractions', which is the crucial detail for this tool. It is clearly distinct from the tap/press_key/type_text siblings by the gesture name, though it never explicitly differentiates itself from 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?

There is no statement of when to use a swipe versus alternatives like previewapk_tap or previewapk_tap_text, nor any prerequisite (e.g. an active device). Usage must be inferred entirely from the tool 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 the coordinate model (0..1 resolution-independent fractions) and the session precondition, but says nothing about what a tap does on failure, whether it blocks, timing/rate behavior, or the effect of omitting 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?

Three short sentences, front-loaded with the action before the coordinate convention and the precondition. No filler, though the third sentence is terse enough to be slightly ambiguous about what 'agent-driven session' means.

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 tap tool with no output schema, the definition covers the action, coordinate system, and one prerequisite. It is still incomplete on the 'device' parameter and on failure/timing behavior, which an agent invoking it repeatedly would need.

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 explain the semantics of x and y (fractions of screen, resolution-independent), which is the most error-prone part, but the third parameter 'device' is undocumented in both schema and 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 ('Tap the screen') that an agent can immediately act on. It does not, however, distinguish itself from the closely named sibling previewapk_tap_text or contrast with previewapk_swipe, 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?

The description supplies one real precondition ('Requires an agent-driven session'), which tells the agent when the tool is callable. It gives no guidance on choosing tap over tap_text or swipe, and no exclusions or alternatives are named.

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

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

With no annotations, the description carries the full burden, and it does disclose useful behavior: exact-then-substring matching precedence and that the tap point is derived from the element's center in the UI hierarchy rather than supplied coordinates. It omits what happens when nothing matches (error? timeout?), whether it waits for the element to appear, and whether permissions or an active session are required.

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 tightly packed sentences with no filler; the matching rule and the index caveat come first, then the routing preference. Every clause carries information an agent needs.

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

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

For a mutation tool with no annotations, no output schema, and 0% schema coverage, the description covers selection but not outcome. An agent knows how the element is chosen but not what a failure looks like, whether a retry is needed, or what 'device' controls.

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 clarifies the 'text' parameter's matching semantics and the role of 'index' when multiple elements match, which is genuinely additive. However, the 'device' parameter is never mentioned, leaving a third of the parameters undocumented anywhere.

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 a precise resource selector (the element whose visible text matches), including the matching rule (exact preferred, else substring). It also explicitly distinguishes itself from the coordinate-based sibling previewapk_tap, so an agent can route without opening either 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?

Gives an explicit routing rule: prefer this over coordinate taps whenever the target has text, which names the alternative tool and the condition that selects it. It also explains the disambiguation path when several elements match, via index.

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 does disclose a genuine behavioral trait: the call fails when nothing is focused rather than typing into the void. That said, it says nothing about default device selection, whether text appends or replaces, or how the failure surfaces to the caller.

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 action and the precondition. The phrase 'instead of typing into the void' is colorful but it earns its place by explaining the fail-fast behavior, so there is little waste.

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

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

For an interaction tool with no annotations and no output schema, the description covers the action and one failure mode but omits device targeting, expected return, and behavior on unfocused fields beyond the failure note. Adequate but with 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 0% for two parameters, so the description must compensate — but it never mentions the optional `device` parameter at all, leaving its meaning and default entirely undocumented. Only `text` is implicitly covered.

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 (type) and resource (text into the currently focused field on the device), and the focus requirement cleanly separates it from siblings like previewapk_tap_text and previewapk_press_key.

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

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

Gives an explicit precondition — the field must be focused first (tap it) — which implicitly routes the agent to previewapk_tap before calling this. It does not name alternatives or state when not to use it, so it falls short of a 5.

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 disclose the crucial stateful behavior: the selection persists across all other tools until changed or until a device is started. It does not say what happens if the device name is invalid or whether a confirmation is returned, so it stops short of full behavioral coverage.

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

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

Three short sentences, front-loaded with the core purpose and analogy, then the stateful consequence, then the parameter source. No filler.

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

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

For a one-parameter session-state tool with no annotations or output schema, the description covers purpose, persistence semantics, the competing 'start' path, and where to get the argument. Only failure/validation behavior 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?

Schema coverage is 100% (the single param is documented as 'device name or id'), so the baseline is 3; the description adds real value by giving the accepted format example ('Device 1') and the authoritative source for the value, previewapk_list_devices.

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 ('Select your working device') and pins down its role with the 'cd of PreviewAPK' analogy, which cleanly separates it from the action siblings (tap, swipe, screenshot) that merely consume the selection.

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?

Explicitly frames the tool as a prerequisite ('After selecting, every other tool talks to this device'), names the alternatives that also set state ('or start one — starting also selects'), and routes the agent to previewapk_list_devices for valid values.

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