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

Annotations already flag destructive, non-idempotent, open-world behavior, and the description adds substantial context beyond them: execution stops at the first error, the clipboard is restored after non-ASCII typing, result symbols ✓ ~ ✗ ? define what 'success' means, and routines persist across agents with guardrails reapplied on replay (confirm/accord never saved). This is unusually rich disclosure of side effects, failure modes and persistence semantics.

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

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

Content is dense and earns much of its length, but it is delivered as one run-on block with heavy parenthetical nesting and symbols, so key points like the error-stops-batch rule are buried. Front-loading is partial: the first clause is good, then the text degrades into an unstructured enumeration.

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

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

For a complex multi-step mutating tool with no output schema, this covers most of what an agent needs: step vocabulary, result reporting, screen-output modes, and routine persistence. It assumes familiarity with `look` ('shown as #id and (description) by look') and omits permission/prerequisite details, but nothing essential to a correct call is absent.

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

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

With 0% schema description coverage on the top-level parameters, the description carries the load and mostly succeeds: it explains every `then` mode including the subtle `changes` semantics and [N] validity, the remember/routine/params lifecycle, target formats ('[N]', bare text, 'x,y', id:/desc:), and direction/amount meaning. Only minor gaps remain (e.g. interaction between `routine` and `steps`, timeout behavior).

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 ('Gestures on the phone, in order') and enumerates every gesture type, so an agent knows exactly what class of action this performs. It does not explicitly name the sibling `look` as the observe-only counterpart, so differentiation is inferred from the enumerated steps rather than stated.

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 context is implied by the step list and by the confirm/accord guardrail notes ('Only on the user's explicit order for THIS gesture'), which is real guidance. However, the description never says when to call `act` versus `look` or how to sequence observation before interaction, leaving the main routing decision to inference.

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

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

Annotations already flag destructiveHint=true and non-idempotent, and the description goes well beyond them: stop loses no data and the app restarts when opened, clear deletes all data, uninstall of a system app only hides it for the user, restore needs the full package name, and install from PC refuses sensitive folders and preserves data as an update. Sensitive-folder refusal and system-app hiding are non-obvious behaviors that a schema could never convey.

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?

Written as tight action:meaning fragments with zero filler, and the destructive-action confirmation rule is stated where it matters. The telegraphic run-on style ('Phone apps. info: ... stop: ...') is efficient but slightly harder to parse than a short bulleted form.

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

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

There is no output schema, and the description compensates by saying what info reports (version, install/update dates, source, enabled). Combined with the safety exclusions and the destructive-action rules, an agent has enough to call it correctly, though nothing is said about failure modes beyond refused folders.

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 carries the full burden and does: app is 'package or part of its name', path is an .apk from the PC with sensitive folders refused, and confirm=true is required for clear/uninstall/install. Every one of the four parameters gains meaning beyond its schema entry.

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?

Each action is given a specific meaning (info/stop/clear/uninstall/install), so the agent knows exactly what the tool does per action. It is weaker on sibling differentiation: it references 'launch' for the app selector but never distinguishes itself from nearby tools like act or settings, which also touch device state.

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

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

It states explicit preconditions ('confirm=true, only on the user's explicit order') and hard exclusions: never for system parts (phone, interface, Settings, store, keyboard, Google services) and never clear/uninstall of banking, payment and identity apps. This is exactly the when/when-not guidance an agent needs before a destructive call.

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?

Goes far beyond the annotations: never overwrites, default destination folder, masking behavior per mode (screenshots masked, videos never masked), FLAG_SECURE screens come out black, videos are discarded if a banking/payment/identity app foregrounds, only one video at a time, and fixed encoding (MP4, 720p, 4 Mbit/s, no sound). The description is consistent with the structured hints (write operation, non-destructive because it never overwrites).

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?

Dense but front-loaded: the core purpose and default destination come first, then per-action semantics, then safety preconditions. A few clauses are run-on (the parenthetical seconds rules for record vs start repeat similar numbers), costing a little clarity, but almost every sentence carries operational 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?

Covers everything an agent needs for a 6-parameter, zero-required-parameter tool with no output schema: all parameter meanings, the four modes, masking and privacy edge cases, and even the return value ('the response gives the path'). No significant gap remains.

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 carry all parameter meaning, and it does: dest (default ~\Downloads\Telephone plus folder rules), name (optional file name, no folder), all four action enum values with their semantics, seconds (default 30/max 180 for record, default and max 180 for start), confirm and unmasked with their exact preconditions. This fully compensates for the empty schema descriptions.

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

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

Opens with a specific verb and resource ('Save the phone screen as a file on the PC') and then defines each of the four action modes (screenshot, record, start, stop) distinctly. It also implicitly separates itself from siblings by referencing 'the same folder rules as files pull' and 'as on look images', so an agent knows this writes a file rather than viewing the screen.

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 concrete usage context ('to show a problem to a support service') and explicit gating conditions for the risky flags: confirm=true only on the user's explicit order for unusual folders or banking/identity screenshots, unmasked=true only when the user accepts unmasked codes and the UI tree is unreadable. It stops short of naming an alternative tool to use instead when capture is inappropriate (e.g. look for on-screen inspection), so no true when-not guidance.

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

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

The annotations already declare that the tool is not read-only and is destructive, and the description usefully clarifies the destructive behavior: clean=true clears app caches with no data loss. It still does not cover auth requirements, runtime behavior, or whether settings outside caches are modified.

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: it names the tool, lists the checked areas, then explains the only parameter's side effect. Every clause earns its place without redundant or repetitive text.

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 checkup tool with strong annotations, the description covers what is inspected and what clean=true changes. It could say more about what the checkup returns or whether it requires an active device connection, but the core calling information is present.

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

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

There is one parameter, clean, and the schema provides no description for it. The description compensates fully by explaining that clean=true clears app caches and that this causes no data loss, which is exactly the semantic detail an agent needs.

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

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

The description identifies a phone checkup and enumerates the specific areas checked: system, security patch, battery, storage, memory, unofficial apps, wireless debugging, and accessibility. That makes the resource and action clear, though it does not explicitly differentiate this tool from siblings such as info, logs, or apps.

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 this is a diagnostic checkup but gives no explicit guidance on when to use it versus alternatives like info, logs, apps, or settings. It also does not state prerequisites such as device connectivity or permissions.

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 annotations only covering readOnly=false/idempotent=true/destructive=false, the description carries the interesting behavior itself: security codes are masked, a lone code/password/token is never shown, read may report empty or non-text, and write has a 256 KB cap and overwrites the user's existing clipboard. That overwrite disclosure is a side effect the annotations do not convey and materially affects how an agent should call 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?

Compact and front-loaded, with 'read:'/'write:' labels that let an agent scan straight to the relevant mode. The clause 'or says it is empty or not text' is slightly awkward, but no sentence is 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 two-parameter, no-output-schema tool, the description covers both directions of behavior, content limits, redaction rules, and the overwrite side effect. Only the return value of write (confirmation vs. nothing) 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 description coverage is 0%, so the description must compensate, and it largely does: it explains what `text` accepts (accents, emoji, 256 KB max) and defines both meanings of `action`. It does not mention that `action` defaults to 'read' or that `text` may be null, leaving a small gap the schema alone does not explain.

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 the resource ('the phone's clipboard') and splits it into two explicit modes with specific verbs: read returns its text (or reports empty/non-text), write places `text` into it. The phrase 'without pasting it anywhere' implicitly separates it from the sibling `act`/paste path, so an agent can tell what it does and does not do.

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 read/write framing gives clear operational context for each action, and 'without pasting it anywhere; it replaces what the user had copied' is a real caveat that steers the agent away from treating write as a paste. It stops short of naming an alternative tool or stating explicit when-not conditions, so it sits just below the top band.

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?

Annotations already cover mutation/safety hints, but the description adds important behavior: the draft is prepared without sending, the token is tied to the exact draft and voided by any change, and sending requires confirm=true plus a look check. These details go well beyond the annotations.

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 purpose is front-loaded, followed by compact parameter guidance and then the send gate. The formatting is dense but every clause carries operational value, including the exact act invocation needed to send safely.

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, but the description explains the returned token and how to validate sending. Combined with the annotations, it gives an agent enough context to draft safely and avoid accidental sends.

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?

With 0% schema description coverage, the description compensates for all three parameters: it explains acceptable `to` formats (address book name, phone number, bracketed conversation number), the `app` choices (sms/RCS or whatsapp), and that `text` may include accents. This adds substantial meaning 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 names a specific action ('Prepare a reply without sending it') and resource ('the conversation') and clearly scopes it as a non-send draft. This distinguishes it from the act/send workflow it references later.

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 gate for sending: only when the user explicitly says 'send' for THIS draft, then use act with the returned token and verify with look. This is clear when-to-use and when-not-to-use guidance, including the alternative sending workflow.

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?

Adds substantial behavior beyond the annotations: 'Nothing is ever deleted' and 'never overwrites' corroborate destructiveHint=false, while the PC-side allowlist, the confirm=true authorization requirement, and the hard exclusions (.ssh, .env, Windows startup) are safety semantics the annotations do not convey. No contradiction with readOnlyHint=false/idempotentHint=false, since these are file writes.

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 resource and action menu, and nearly every clause carries actionable constraint. The final PC-side line is telegraphic to the point of near-ungrammaticality ('keys, secrets (.ssh, .env…) and Windows startup never'), which costs a little clarity for its density.

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?

Covers scope, defaults, refusals, and safety boundaries well for a 4-parameter mutation tool with no output schema. It does not describe what list returns (formats, entry metadata) or how pull reports success, so an agent has modest remaining uncertainty about results.

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?

With 0% schema description coverage the description must carry all four parameters, and it mostly does: dest and path are explained per action, including the role swap (path = PC file and dest = phone folder for push; the reverse intent for pull), plus confirm's meaning as the user's explicit order. The path/dest distinction is slightly compressed and easy to misread.

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 the resource (phone shared storage, with concrete paths like /sdcard/DCIM/Camera) and enumerates the three operations with a specific verb each: list, pull (phone→PC), push (PC→phone). This is unambiguous and clearly distinct from siblings such as clipboard, capture, or look.

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 concrete defaults per action (/sdcard/Download, ~\Downloads\Telephone) and states refusal conditions ('refused if it already exists', confirm=true required outside the free PC folders). It stops short of explicitly contrasting the three actions against alternatives, but the per-action routing is clear enough to select correctly.

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

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

Beyond the annotations, the description discloses important behavior: it works while the phone is locked, reading is free, creating/updating changes user data, destructive actions require confirm=true, calls require confirm plus an exact accord, missing fields produce app errors naming the field, and outputs are data with sensitive tokens masked.

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 dense but front-loaded: it states the purpose first, then list/run behavior, then safety/confirmation rules. Most clauses earn their place, though the long semicolon-heavy paragraph could be more structured for scanning.

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

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

For a complex, open-world dispatcher with no output schema, it covers the key call patterns, confirmation requirements, error behavior, and output masking. Return shape remains vague beyond 'Answer = data', and sibling differentiation is absent, but the agent has enough to invoke list and run correctly in most 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?

With 0% schema description coverage, the description does compensate for app, function, params, confirm, and accord usage, including an example params object. But accord is only vaguely described as 'the accord for this exact call' without saying where it comes from or its format, and the action parameter is only implied through list/run 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?

The description clearly defines the tool as a dispatcher for Android AppFunctions, with explicit list and run modes and concrete app-domain examples. However, it does not contrast itself with sibling tools such as launch, messages, phone, or apps, leaving the agent to infer when this general dispatcher is preferable.

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 operational guidance: use list to discover apps/functions, use run with app/function/params, and set confirm=true for destructive actions and calls plus an accord for calls. It does not explicitly say when to avoid this tool or which sibling tool to use instead.

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

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

The annotations already declare read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful context about what each kind returns, such as location accuracy/age/Maps link and calendar events over `days`, but it omits defaults, limits, permissions, and query-matching behavior.

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

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

The description is compact and front-loads the read-only nature before listing each kind. It is appropriately sized, though the opening 'Read-only' largely duplicates the annotation rather than adding new behavioral detail.

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

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

An output schema exists, so return-value explanation is not required. However, for a four-parameter tool with 0% schema description coverage, the description leaves `limit` undocumented and does not specify how `query` is interpreted or whether multiple kinds are possible.

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 the four `kind` values and maps `query` to contacts and `days` to calendar, but `limit` is never mentioned and the `query` matching rules remain unspecified.

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 makes clear that the tool retrieves four kinds of local information: location, calls, contacts, and calendar. It is more specific than the vague name 'info', but it does not distinguish this tool from siblings like map or phone and lacks an explicit verb such as 'retrieve'.

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

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

The description provides no guidance on when to use this tool versus alternatives such as map, phone, or messages. It only lists what each `kind` returns, leaving routing decisions entirely to inference.

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

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

Beyond the annotations, the description discloses how targets are resolved, that the new foreground is reported, and that direct calling/sending/paying requires explicit user confirmation plus a matching accord token. It also states the banking/payment/identity restriction and explains display behavior after launch.

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 front-loaded with the core action, but it becomes a dense run-on covering several unrelated concerns without bullets or clear separation. The content is useful, but the structure makes it harder to scan than necessary.

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 seven-parameter, no-output-schema tool, the description covers most operational behavior, safety constraints, and parameter meanings. It is not fully complete because it does not fully document return values or all then enum options.

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?

With 0% schema description coverage, the description compensates well by explaining app, data, action, extras, confirm, accord, and most of the then enum. It still leaves the changes and none values of then unexplained, so parameter semantics are strong but not complete.

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 clear verb and resource: open an app by package name or fragment, then show it. It also describes precise-screen launching via action/data/extras. It only partially distinguishes itself from siblings such as act or apps, 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 description gives important conditional guidance for sensitive actions: confirm=true and accord are required for calling, sending or paying directly, and banking/payment/identity apps must not be opened by intent. However, it does not clearly state when to use launch versus siblings like act, look, apps, or web for ordinary navigation.

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?

Adds substantial behavior beyond the annotations: newest-last ordering, a ~30,000 character cap, crash/ANR grouping and retention details, masking of secrets and personal data, and special restrictions for sensitive app categories. The annotations already cover safety, and the description enriches them without contradiction.

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?

Despite being dense, every sentence adds operational meaning: purpose, output shape by kind, parameter semantics, and privacy constraints. The purpose is front-loaded, and the kind-specific labels make the longer description scannable.

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?

Complete for a read-only log retrieval tool with no output schema. It explains what each mode returns, the ordering and size limits, filtering behavior, masking, and sensitive-app restrictions, leaving no major ambiguity for correct invocation.

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

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

Schema description coverage is 0%, so the description carries the full parameter burden and does so well. It defines the meaning of app, all three kind values, since with concrete formats, query filtering after masking, and lines defaults/maximums.

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 resource (Android logcat logs) and a clear diagnostic purpose: understanding why an app crashed or misbehaved. It distinguishes the log kinds and their outputs, so an agent can identify the tool 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?

Gives clear usage context for each kind: crash for grouped crashes, anr for non-responsive events, and recent for raw log lines. It also states important exclusions for banking/payment/identity apps, but it does not explicitly compare this tool with sibling diagnostic tools such as look, apps, info, or checkup.

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?

Annotations cover the safe-read profile (readOnly, idempotent, non-destructive), so the description's added value is the privacy behavior: 'Unreadable UI tree: the image is not sent (codes not masked), unless confirm=true, set only with the user's agreement.' That is a non-obvious side effect an agent must know. It doesn't state cost/latency of image capture or how large element lists are returned.

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?

Dense but front-loaded: the core action comes first, then mode options, then modifiers, then the exceptional case. The telegraphic phrasing ('zoom (pixels of the last full image)', 'auto = all when few, else unnamed elements only') is compact but occasionally requires re-reading, which keeps it from a 5.

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, the description does describe the return shape (numbered element list, image, marks drawn on the image), which is what an agent needs to plan a call. It is missing only edge detail on the 'none' mode and on how very large element lists are returned.

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 carries the full load and largely does: every enum value of show is explained, marks is described including the outline behavior and what 'auto' means, query is defined as a text filter, region is given as [x1,y1,x2,y2] in pixels of the last full image, and confirm's precondition is stated. Minor gaps remain (coordinate origin, behavior for out-of-range regions, show=none semantics).

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

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

The opening clause gives a concrete verb and resource: 'See the phone screen', then specifies the return format as numbered elements [N] with role, text, states and center coordinates plus an optional image. That is far more specific than the bare name 'look'. It does not name or contrast any sibling (e.g. capture, act), 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?

Mode selection is explicitly guided: 'auto (default, text first: the list alone; the image is joined when the screen has no readable element)', plus the explicit alternatives both/image/elements/none and 'query: list only the elements containing this text'. The conditional for confirm ('set only with the user's agreement') is a real usage rule. It still lacks explicit when-not-to-use-this-tool vs siblings guidance.

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

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

It discloses behavior beyond the annotations: nothing on the phone is changed except open, snapshots mask identifiers/tokens/numbers, the map is self-rebuilt after updates, and titles are in the phone's language with accents optional. That directly clarifies why readOnlyHint is false while destructiveHint is false.

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 leads with the default action and scope, which is good, but the rest is a dense run-on of semicolons and parentheticals that makes individual actions hard to scan. The content earns its place, yet the formatting could be much tighter.

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 8-parameter tool with no output schema, it describes what each action returns (path from Settings, current value, highlight, changed items). It only omits the meaning of 'limit' and how results are paginated or truncated.

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 carry all 8 parameters, and it explains action values, query (with a concrete example and accent note), key, target, path, append, and since formats (2h, 3d, a date). Only 'limit' 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?

The description names the resource (a map of the whole phone's settings screens) and enumerates five distinct actions (find/open/snapshot/diff/note) with what each returns. It is clearly distinguishable from siblings like settings, launch, and look.

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 context for each action: find is the default for locating a setting from the user's words, open is for jumping to a screen found by find, and it references launch(action=…) as an alternate way to open things. It never explicitly says when NOT to use this tool versus settings/look, but the routing is largely implied by the per-action descriptions.

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?

Annotations already declare readOnly, idempotent, non-destructive, and the description adds substantial context beyond them: a ~60,000 character response cap cut between two messages, a 500-message ceiling on limit, the fact that videos and files are only mentioned while photos are attached, and the exact pagination mechanism via the "older: …" token. That is the kind of disclosure an agent needs to plan calls and handle truncation.

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?

Dense but front-loaded: the resource is named first, then each argument mode in sequence, ending with the response-size caveat. Slightly run-on in phrasing, but nearly every clause carries actionable 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?

With no output schema, the description compensates by describing the return shape for each mode (conversations with contact, date, unread count; messages with attached images) and the truncation/pagination behavior. An agent can call this correctly and know how to continue reading.

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 carries the full burden and does: limit is bounded at 500 messages, images sets how many recent photos are attached (0 for none), before is an ISO date taken from the prior response, and contact vs conversation are two addressing modes for the same target. Only the defaults (limit=15, images=4) are left unstated.

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 the resource precisely ("The phone's SMS and RCS messages") and enumerates the three operating modes: no argument for recent conversations, conversation/contact for message threads. It is clearly distinct from siblings like notifications or phone, though it never explicitly names those siblings to route against.

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 concrete when-to-use guidance at the argument level: omit arguments for a conversation list, pass conversation=N or contact="Alice" for a thread, and use `before` with the ISO date at the end of a response to page older. It does not, however, say when to prefer this tool over siblings such as notifications or look.

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?

Annotations already establish that this is a safe, read-only, idempotent operation. The description adds meaningful behavioral context beyond annotations: newest-first ordering, masking of security codes, inclusion of ongoing notifications when all=true, and the Android limitation that dismissed notifications retain only the app name. It does not cover pagination or limit behavior, so it stops short of full transparency.

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

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

The description is compact and front-loaded, presenting the core resource and return fields first, then the all=true behavior and dismissed-notification caveat. Every sentence adds useful information with no redundancy.

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

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

For a simple read-only notification tool with rich annotations and no output schema, the description covers the returned fields, ordering, masking, and important Android limitations. The main gap is the unexplained limit parameter and its interaction with result ordering.

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 carry parameter meaning. It explains the important all=true behavior well, but the limit parameter is never mentioned, leaving one of two parameters 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?

The description clearly identifies the resource as phone notifications and lists the returned fields (app, time, title, text), ordering, and masking behavior. It does not explicitly state a retrieval verb or differentiate itself from sibling tools such as messages or logs, so it is clear but lacks sibling-level disambiguation.

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 'Notifications shown on the phone' and the note that all=true includes ongoing notifications. However, there is no explicit guidance on when to use this tool versus alternatives like messages or logs, and no exclusions or prerequisites are provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without the description. The description's only added signal is the transport distinction (USB or Wi-Fi) and the fact that device/app state is observed, which is modest extra context.

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

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

A single short fragment with no padding and the key concept ('Link status') front-loaded. It is arguably over-compressed into a field list rather than a sentence, but nothing is wasteful.

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

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

An output schema exists, so enumerating return values in the description is largely redundant and the description does not spend that space on what it uniquely should: when this status check is appropriate and what a failure/offline result means. For a zero-param read-only tool this is close to sufficient, but not quite.

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, which is the baseline-4 case; no parameter explanation is required. The description also implies the scope of reported state, though that overlaps with the output 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 is a noun-phrase list of return fields ('Link status: phone reached (USB or Wi-Fi), model, screen, foreground app') rather than a verb+resource statement. An agent can infer it reports the phone link/connection status, but the framing is ambiguous and it never distinguishes itself from siblings like info, checkup, or look.

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

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

There is no guidance on when to call this versus alternatives, nor any precondition such as requiring the phone link to be active. The agent must infer usage entirely from the tool name and one fragment of prose.

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?

Annotations already cover idempotency, non-destructiveness and non-read-only status, and the description adds real value on top: changes are reversible, the state is read back after mutation, and turning Wi-Fi off is conditionally refused. It stops short of noting permission requirements or what happens on an invalid value/capability that doesn't exist on the 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?

Four short lines, front-loaded with the read/write rule, then per-setting grammars grouped by kind, then the single edge case as a parenthetical. Every clause carries information; nothing is repeated from the schema or annotations.

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

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

With an output schema present, the description needn't detail return values, and stating the state is read back after a change is enough. Minor gaps remain around failure modes (invalid value, missing hardware, persistence timing), but nothing that would cause a wrong call.

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 carries the full burden, and it does: it enumerates the accepted value grammar for each enum member (on|off for radios, on|off|priority|alarms for dnd, 1-100 or auto for brightness, 0-100 media for volume). Without this the free-form string 'value' would be guesswork.

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 pairing ('Reversible phone settings') and immediately disambiguates the dual mode: without value it reads, with value it writes then reads back. That is far more precise than the bare name 'settings' and distinguishes it from siblings like info or look.

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 the tool reads vs writes ('without value, reads the state; otherwise changes it'), and calls out the one refusal condition (turning Wi-Fi off when the link goes through it). It does not name an alternative tool or state prerequisites, 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?

Annotations already declare readOnly/idempotent/non-destructive, and the description adds substantial context beyond them: field values including passwords are never read, codes/tokens/emails/numbers are masked, banking/payment/identity apps are never read, and background Chrome is frozen. This materially changes how an agent interprets results.

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 purpose is front-loaded, but the body is a dense run-on paragraph mixing semantics, privacy, and platform caveats without structure. Information is mostly load-bearing, yet the wall-of-text format makes it harder to scan than it needs to be.

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, the description does explain what read returns (page text, title, address, links) and the privacy masking applied. It is short of describing the exact shape/ordering of the returned data, but it is sufficient to call the tool correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden and does: tab maps to 'tab=N from tabs', query is line filtering, action selects read vs tabs with read as the default. That fully compensates for the undocumented 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 concrete verb and resource ('read web pages... text of the page, title, address and links') and enumerates the two actions (read, tabs), so an agent can distinguish it from siblings like capture or look. It stops short of naming those siblings or drawing an explicit 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?

Gives clear usage context: default target is the foreground app's page, alternate is 'tab=N from tabs', and 'query: keep only the lines containing this text'. It also flags the operational constraint that Chrome only answers in the foreground. No explicit when-not-to-use relative to siblings.

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