Robot Actions — Remote Device Control

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

With no annotations provided, the description carries full behavioral disclosure burden. It discloses the persistent nature (auto-prepended to system prompt on every chat), the 10240-byte cap with 413 over-cap behavior, and formatting expectations. Does not mention whether appends can be deleted or overwritten beyond the sibling replace tool, but covers the key side effects affecting agent decisions.

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 zero waste. Front-loaded purpose, then usage rules, then constraints. Every clause earns its place—trigger phrases, anti-pattern warning, memory behavior, cap, formatting guidance.

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 1-parameter tool with 100% schema coverage and no output schema, the description is highly complete. It covers when to use, what to store, storage behavior, and failure mode. Minor gap: doesn't describe what happens on success (return value), but for a side-effect append operation this is a low-value omission given no output schema is specified.

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

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

Schema description coverage is 100%, so the single 'block' parameter is fully documented in the schema. The description adds the value-laden guidance that markdown is encouraged and entries should be terse and factual, which is useful but the schema already defines what the parameter is. Baseline 3 is appropriate.

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

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

Clear specific verb+resource: 'Append a block to the calling user's persistent agent memory.' Distinguishes from sibling agent_memory_replace by specifying append semantics, and from the large pool of device/test tools by its explicit memory scope.

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?

Exceptionally explicit: names exact trigger phrases ('remember X', 'save this', 'note for next time'), states an explicit exclusion ('DO NOT auto-update on every interaction'), and gives content guidance (terse, factual, markdown, not verbose). This is textbook-level usage guidance.

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

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

No annotations are provided, so the description carries the burden. It does disclose the 10240-byte cap with the 413 error behavior, which is valuable. However, it doesn't disclose side effects beyond the implied whole-file overwrite, nor what happens to the existing memory content (though 'replace the entire memory file' implies full overwrite). The risk framing ('USE SPARINGLY') adds context but the description is somewhat thin on full behavioral detail.

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, all earning their place: purpose, usage guidance, and the technical cap. The 'USE SPARINGLY' emphasis is front-loaded in the first line. Efficient and readable; only minor inefficiency is the mild redundancy between 'USE SPARINGLY' and the guidance that follows.

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

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

For a single-parameter tool with no output schema and simple semantics, the description is fairly complete. It covers the purpose, the when/when-not (append as alternative), the cap behavior with error code, and the clear-option. The main gap is that it doesn't explain the return value, but for a write-only replace tool with no output schema, this is acceptable.

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

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

Schema description coverage is 100%, so the schema already documents the 'content' parameter. The description adds modest value by noting 'Pass empty string to clear,' which is useful beyond what the schema states ('Full memory content (Markdown)'). This matches the baseline-3 scenario where the schema does heavy lifting with a small description bonus.

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

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

The description clearly states the purpose: "Replace the entire memory file for the calling user." It uses a specific verb (replace) with a specific resource (memory file). It doesn't heavily distinguish from siblings beyond implying it's the 'less safe' counterpart to append, but the scope ('entire memory file') is precise.

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

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

The description explicitly guides when to use this tool: "USE SPARINGLY — append is the safer primary." It names the alternative (append) and the specific conditions for using replace: 'memory has drifted wrong, accumulated stale entries, or the user asks for a clean rewrite.' This is excellent when/when-not guidance.

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

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

With no annotations provided, the description carries full weight and exceeds expectations: it discloses that the audit covers only the foreground screen, scroll changes the screen and doesn't scroll back, deduplication after scrolling, and important limitations (tap-target results are a screening signal, only on-screen elements, ancestor touch dispatch invisibility, and contrast/text-size not checked). This is exceptional 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 long but every sentence provides necessary context, from purpose to usage to limits. It could be restructured with headers or bullet points for readability, but the density is justified given the tool's complexity. No fluff or redundancy.

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

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

This is a complex tool with no output schema, yet the description fully covers what findings look like (label, class, pixel rect), how to use them (tap rect center with device_tap), scroll behavior, locale handling, and limitations. It leaves no critical operational gap for an agent to invoke and interpret 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?

Schema coverage is 100%, but the description adds substantial meaning beyond the schema: it explains what each check detects with concrete examples (e.g., 'Submit button'), clarifies scroll behavior and side effects, and notes locale implications for the redundant-description check. It enriches parameter understanding without merely repeating schema text.

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

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

The description clearly states the tool runs an accessibility audit on the current Android screen, with a specific verb ('run'), resource ('accessibility audit'), and scope ('CURRENT screen'). It also aligns with Google's Accessibility Scanner rules and distinguishes itself from iOS equivalents, so purpose is unmistakable.

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

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

The description gives explicit sequencing guidance: navigate to the target screen first using device_tap_by_text/device_launch_app, then call this tool. It also explains when to use scroll:true and when to leave it off. However, it does not explicitly contrast with sibling tools or state when not to use the tool beyond the navigation prerequisite.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this measures cold launches specifically (via -S flag which stops the app first), that results are averaged over N runs, and that it resolves launcher activity from package. This is meaningful behavioral context for a read-only measurement tool, though it doesn't note that it terminates the app or describe the exact return format.

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

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

Two sentences, zero waste. The first sentence states the measurement and method; the second explains the activity resolution. Every word earns its place and the key purpose is front-loaded.

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

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

For a measurement tool with 100% schema coverage and simple parameters, the description is adequately complete. It explains the method, the metric, the averaging behavior, and activity resolution. It could note the output format (ms timestamp/summary) but given the tool's simplicity and full schema coverage, this is a minor gap rather than a blocking one.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters well. The description's mention of 'averaged over N runs' aligns with the `runs` parameter and adds context that runs defaults to 3, which the schema implies but the description confirms. The description doesn't add significant extra semantics beyond the schema's already-good parameter documentation.

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

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

The description clearly states a specific verb+resource (measure cold app-launch time in ms) with the method used (`am start -W -S`). It also explains it resolves the launcher activity from the package and averages over N runs. This distinguishes it from siblings like device_launch_app (which launches) and ios_app_launch_time (iOS platform).

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 when to use it (measuring cold launch performance) but does not explicitly state when NOT to use it or name alternative tools. However, the method detail ('cold' launch, -S flag, averaging runs) provides clear context about the intended use case that distinguishes it from warm-launch or simple launch tools.

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

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

No annotations are provided, so the description carries full burden. The description tells us the tool returns analytics data structured as totals/process/type/day but doesn't disclose side effects (likely none), return format, or what happens if no dropbox entries exist. For a read-only analytics tool, this is reasonably adequate but thin.

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

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

Two sentences, zero waste. Front-loaded with the core purpose and data sources, closes with the sibling pointer. Every word 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-parameter aggregate analytics tool with no output schema, the description covers the purpose, data source, aggregation dimensions, and sibling distinction. It doesn't need to explain return values in depth since there's no output schema and the value proposition is clear. Could add what 'no crashes' looks like, but not critical for a stats 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% with a single 'serial' parameter already documented as 'Android device serial (from device_list)'. The description adds context by clarifying the data source (DropBoxManager) and output granularity, which enriches the single parameter's purpose beyond the schema. With only 1 parameter and full schema coverage, baseline is 3; the DropBoxManager sourcing detail justifies a slight bump.

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

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

The description clearly states this aggregates crash/ANR/native-crash analytics with specific breakdowns (total, per-process, per-type, per-day timeline). It distinguishes itself explicitly from android_crash_detail, the sibling for individual entries. Very specific verb+resource+scope.

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 names android_crash_detail as the alternative for individual entries, giving clear 'when vs when-not' guidance. However, it doesn't describe when to prefer this over ios_crash_analytics or specify any filter or selection context beyond device serial.

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 sole burden. It discloses that this is a read operation returning 'full raw content'. It doesn't state output size, encoding, or whether the entry can be very large, but for a fetch-by-id read tool with no destructive side effects, the disclosure is reasonably adequate.

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, dense sentence that conveys the resource, scope, and parameter provenance with zero wasted words. Perfectly front-loaded and concise.

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

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

With 2 simple string parameters at 100% schema coverage and no output schema, this is a straightforward detail-fetch tool. The description is complete for its simplicity. It could mention return format but this is a low-complexity tool, so the adequacy is high. A slight ding for not describing what the raw content looks like.

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

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

Schema coverage is 100%, with both parameters described. The description adds value by explaining the id comes from android_crash_analytics and serial comes from `device_list`, which carries provenance meaning beyond the schema's standalone descriptions. This enriches parameter understanding.

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

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

States a specific verb ('get' implied) with a clear resource ('full raw content of one crash/ANR/tombstone entry') and how to address it (by id from android_crash_analytics). It distinguishes itself from android_crash_analytics (which provides the list) and from the sibling ios_crash_detail. Clear purpose.

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

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

The description implies usage context: this is the detail-fetch complement to android_crash_analytics, which produces the ids to feed here. It names the source ('by id from android_crash_analytics'), providing clear context. It doesn't explicitly state when NOT to use it, but the pairing with the analytics list tool is clear enough.

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 delivers richly. It discloses the live-window race condition, the exactly-once cleanup semantics (throttle/blockUrls/extraHeaders cleared in a finally block), return format details (records vs HAR, per-body 10000-char cap, total 200000-char cap with bodiesOmitted), the limit-based record capping behavior (total/returned when dropped), and the throttle semantics including exact latency/bandwidth figures. This is far more transparent than the typical tool.

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

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

The description is front-loaded with the core purpose and key caveat (live-window), then flows logically through return format, body handling, throttle, blocking, and limits. Every sentence adds operational value. It's a long single paragraph, so it loses a point for not breaking into scannable sections, but given the tool's complexity (13 params, multiple modes, many caps) the length is justified and there's no 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 a 13-parameter tool with no output schema and no annotations, this description is remarkably complete. It documents return record shape, all caps (per-body, total, limit), the throttle values with exact figures, blockUrls wildcard semantics, extraHeaders session-scoping rationale, and the format="har" alternative. There is no output schema so the description must convey the return shape, and it does so thoroughly. This is near the ceiling for what a description can achieve.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds genuine value beyond the schema: it explains the interplay between triggerJs and the live window (race avoidance), clarifes that includeBodies has a default of true while the schema doesn't state a default, and explains the bodiesOmitted mechanism tied to total caps. The main shortcoming is that with 13 params the description cannot deep-dive each, but the schema itself is already rich so this is acceptable.

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

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

The description opens with a specific verb+resource+scope: 'Capture network requests made by a page running on the device over a time window via CDP.' It clearly states it enables the Network domain and collects specific event types (request/response/loadingFinished/loadingFailed). This is immediately differentiated from siblings like device_network_info (device-level info) and ios_safari_capture_network (iOS targeting) via the 'device' and page-based (CDP) framing.

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?

Exceptionally explicit on when/how to use: it distinguishes the LIVE-WINDOW collector behavior and instructs to pass triggerJs inside the window rather than triggering from a separate tool call to avoid racing the attach and getting 0 records. It also names the exact default window (5000ms), maximum (30000ms), and the pageId auto-selection note. The triggerJs description even gives concrete examples like "location.reload()" and "fetch('/api/x')", which is strong operational guidance.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It discloses the return shape (`{ closed, pageId }`) and reconciles the failure case (`closed:false if no such page`). However, it doesn't mention side effects like whether closing a page terminates the browser or affects other tabs, nor does it mention any permission or session requirements. A 3 is fair since it covers outcome but not potential 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?

Three sentences, compact and front-loaded with the core action in the first sentence. The CDP implementation detail, use case, source reference, and return shape are all packed efficiently. Minor redundancy between 'close' in the first sentence and 'clean up stale tabs' — but this adds context rather than waste. Very tight and effective.

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

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

The tool is a simple close operation with 3 params, no output schema, and no nested objects. The description covers purpose, usage context, source of the key parameter, and return shape including the failure case. For a simple closure tool this is essentially complete — the only gap is side-effect disclosure (e.g., whether it crashes the browser context).

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (udid, pageId, socket). The description adds context for pageId ('from android_devtools_list_pages') which slightly augments the schema's phrasing. Baseline 3 is appropriate when the schema handles parameter documentation; the description's added value is marginal.

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 has a specific verb+resource: 'Close a debuggable tab/page on the device by pageId'. It clearly states the mechanism (CDP /json/close) and the use case ('clean up stale tabs'). It distinguishes from siblings like android_devtools_list_pages by explicitly referencing it as the source of pageId, and android_devtools_navigate is clearly a different operation.

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 clear when-to-use guidance: 'Use to clean up stale tabs that accumulate across sessions'. It also points to the prerequisite source of pageId via android_devtools_list_pages. It doesn't explicitly state when NOT to use it (e.g., which alternatives like navigate exist for closing pages), but the context is sufficiently clear.

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

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

No annotations are provided, so the description carries the full burden. It discloses the live-window attach behavior, the ~1-3s attach latency, the race condition, and the auto-selection of visible/active page when pageId is omitted. Missing would be explicit statements about what happens with zero events collected (empty array?) or any side effects, but the disclosed behavior is substantial and directly relevant to correct usage.

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?

Well-organized paragraph that front-loads the core purpose before diving into live-window caveats. The critical spatial warning is highlighted in caps ('LIVE-WINDOW collector'), and every sentence earns its place — return format, event types, defaults, pageId auto-selection. No filler or redundancy.

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

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

For a time-windowed event collector with no output schema, the description thoroughly covers the attach/race behavior, default limits, triggerJs mechanism, and page selection. The tricky live-window semantics are fully explained, which is precisely the kind of context an agent needs to use this effectively. No significant gaps remain for correct usage.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds beyond the schema: it explains the triggerJs mechanics ('runs INSIDE the collection window right after the listeners attach ... race-free') with concrete examples, and clarifies the durationMs default/max. The triggerJs semantics in particular are materially enhanced beyond the bare schema text.

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?

Specific verb+resource: 'Collect console logs, exceptions, and log entries from a page running on the device for a time window.' Clearly distinguishes from siblings like android_devtools_capture_network (network) and ios_safari_console_logs (iOS platform). States the exact protocol mechanisms (enables Runtime and Log domains, listens for specific events) and the return shape.

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 explains the live-window behavior ('only captures events fired AFTER it attaches') and warns about the race condition when triggering from a separate tool call ('silently missed'). Provides a concrete remedy (pass triggerJs to run inside the window) and documents the default/maximum window. This is model-grade usage guidance for a tool with a subtle temporal gotcha.

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 the CDP mechanism (Network.getCookies), the fallback to document.cookie with its limitation (non-httpOnly only), and the pageId auto-selection behavior. This gives the agent a solid behavioral model. It could add what the return format looks like, but given no output schema exists, this is a reasonable effort.

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, each adding distinct value: what it does + attributes returned, the use case, the fallback and parameter default. No fluff. Slight room for improvement — the CDP and fallback could be separated more clearly — but overall tight and well front-loaded with the core purpose.

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

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

No output schema exists, so the description must convey the return content, which it does by listing the cookie attributes returned. It covers the fallback, auto-selection, and the socket default. For a read-only cookie-fetch tool with 3 mostly standard params, this is reasonably complete. Could mention pagination or large cookie set handling, but not essential.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (udid, pageId, socket). The description adds meaningful context on pageId ('omit to auto-select the visible/active page') which goes beyond the schema's 'auto-picked when omitted'. But udid and socket are standard and the description adds little beyond what the schema conveys. Baseline 3 is appropriate.

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

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

The description clearly states the tool gets cookies for a page via CDP Network.getCookies, listing specific cookie attributes (httpOnly/secure/sameSite/domain/path/expiry). It distinguishes from the general ios_safari_cookies sibling by being Android-specific and explicitly noting httpOnly inclusion. However, it doesn't explicitly name sibling alternatives or contrast with cookie-setting tools, and 'Get cookies' is somewhat generic.

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 useful usage context — 'useful for debugging auth/session state' — and tells the agent that omitting pageId auto-selects the visible/active page. It also explains the fallback behavior to document.cookie. However, it doesn't explicitly state when NOT to use this vs alternatives like ios_safari_cookies, device_get_browser_url, or webpage_clear_cookies/set_cookie.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the default element selection strategy (interactive/meaningful vs all), the includeStyles opt-in behavior, page auto-selection, and the 'unique-ish' caveat on CSS selectors (honest about non-guaranteed uniqueness). It doesn't mention performance or limits beyond the schema's default 150.

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 well-organized sentences: first states core purpose and output fields, second covers the optional styles extension, third contrasts with raw HTML and explains pageId auto-selection. Every sentence adds value with zero filler or redundancy. Efficient and front-loaded.

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

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

For a 6-parameter extraction tool with no output schema, the description is quite complete: it details the output shape, selector scoping, styles opt-in, and page auto-selection. The only minor gap is lack of guidance on limit behavior or what 'interactive/meaningful' precisely includes, but the trade-off between conciseness and completeness is well balanced.

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 baseline is 3. The description adds meaningful context beyond the schema: it explains what 'selector' does when provided (scopes extraction), when includeStyles should be set (to get computed styles), and clarifies pageId's auto-select behavior. This is genuinely additive over the bare schema parameter names.

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

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

The description clearly states the purpose: extract locator-friendly element data for building Playwright/Selenium locators. It specifies the exact verb (extract), resource (element data from a device page), and enumerates the returned fields precisely. This clearly distinguishes it from siblings like android_devtools_get_dom (raw DOM), device_find_element (single element lookup), and ios_safari_elements (iOS counterpart).

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 default behavior (interactive/meaningful elements, or those matching selector) and the optional includeStyles enhancement. It notes 'Omit pageId to auto-select the visible/active page' which helps usage. It doesn't explicitly state when NOT to use it vs alternatives like device_find_element or android_devtools_get_dom, but the focus on locator-building is a strong context cue.

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?

Discloses the mechanism ('Enables Runtime, then calls Runtime.evaluate'), return behavior ('Returns the result value and any exception details'), and the auto-selection behavior. With no annotations provided, the description carries the burden and handles it reasonably well, though it doesn't mention side effects or whether the computed expression may have persistent effects on the page.

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 covering purpose, mechanism, return, and usage—zero wasted words. Front-loaded with the primary action and function.

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 evaluation tool with 100% schema coverage and no output schema, the description adequately covers purpose, mechanism, and parameter intent. The mentions of Runtime.evaluate and exception details give the agent a good mental model. Could touch on error-handling edge cases (e.g., non-serializable results), but generally complete.

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

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

Schema coverage is 100%, so all six parameters are documented with descriptions. The description adds the semantic context that pageId comes from android_devtools_list_pages and can be auto-picked when omitted, which adds value beyond the schema. However, most parameter meaning is already fully captured in the schema, so baseline 3 is appropriate.

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

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

Clear verb+resource: 'Evaluate a JavaScript expression in the context of a page running on the device via CDP.' Distinguishes from siblings—it's specific to Android/CDP, and 'Omit pageId to auto-select the visible/active page' further clarifies its behavior versus alternatives like ios_safari_evaluate on iOS or web_evaluate for web sessions.

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?

Explains it operates via CDP on a device page and auto-selects the active page when pageId is omitted. Referencing android_devtools_list_pages as the source for pageId provides context, though it doesn't explicitly state when NOT to use it vs. alternatives like web_evaluate or session_execute.

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

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

No annotations are provided, so the description carries the full burden. It discloses the 100,000 character output cap, the truncation notice appended at the limit, and the auto-page-selection behavior. For element selection it notes it returns null when no match. These are useful behavioral traits beyond the schema.

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

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

Two sentences, tightly written with zero filler. Every clause carries informative value: retrieval mechanism (CDP), element-targeting capability, output cap with truncation notice, and auto-selection behavior. Front-loaded with the core purpose.

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

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

Given there's no output schema, the description appropriately notes the output cap and truncation behavior, giving some sense of what to expect on return. The tool is moderately complex (4 params), and while no return-format specifics are given beyond cap/truncation, the behavior is adequately conveyed for an HTML-fetching 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 schema documents all four parameters. The description adds clarity on pageId auto-selection and selector returning outerHTML of first match or null, which enriches some params. However, the description largely restates what the schema already conveys for most parameters.

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

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

The description clearly states the tool gets the outer HTML of a page or CSS-selector-matched element via CDP, with a specific verb+resource. It doesn't explicitly distinguish from siblings like android_devtools_elements or device_page_source, but the scope (page or element outer HTML on device via CDP) is clear enough.

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 clear context on when to use it (via CDP for page/element HTML) and explains the pageId auto-selection behavior. However, it doesn't explicitly state when-not-to-use or name alternatives such as device_page_source or android_devtools_elements, though the distinction is reasonably 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 present, so the description carries the full burden of behavioral disclosure. The description transparently discloses several behavioral traits: the best-effort/null visibility reporting for regular tabs, the fact that stale tabs accumulate and persist across sessions, and the recommendation to use android_devtools_close_page to clean up. It also specifies exactly what the tool returns (id, type, title, url, visibility). This is solid behavioral transparency for a read-only listing operation.

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

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

The description is a compact multi-sentence block covering purpose, return fields, a known caveat (null visibility), cross-session accumulation behavior, and cross-tool integration. Every sentence earns its place with distinct value: purpose+returns, caveat, accumulation warning, and forward reference to sibling. Efficient and front-loaded with the core purpose first.

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?

Schema coverage is 100% so both parameters (udid, socket) are documented structurally. No output schema exists, and the description explicitly identifies the return fields (id, type, title, url, visibility), which compensates for the absent output schema. It also covers device-targeting semantics (udid) and the socket default. For a listing tool with two simple documented params, this 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 100%, so both parameters are already documented in the input schema (udid as device serial, socket as abstract unix socket name with default). The description adds marginal value by referencing that pageId from this list feeds other android_devtools_* tools, which clarifies downstream usage but doesn't add new parameter semantics beyond the schema.

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

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

The description uses a specific verb and resource: 'List debuggable pages/targets available on the device via CDP' and specifies the exact return fields. It distinguishes itself from the many sibling android_devtools_* tools by clarifying it's the page-listing entry point whose output (pageId) feeds other tools, clearly separating it from android_devtools_close_page and other target-specific tools.

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

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

The description provides clear usage guidance: it warns that stale tabs accumulate across sessions, directs users to use android_devtools_close_page to clean up unwanted ones, notes visibility is best-effort/null for regular tabs (managing expectations), and explicitly states to pass a pageId from this list to other android_devtools_* tools to target a page. This gives concrete when-to-use and workflow context, though it doesn't explicitly state when NOT to use it in favor of an alternative listing tool.

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 responsibility for behavioral disclosure. It states routes apply immediately and survive navigation, that only web content is intercepted, native code is never intercepted, no device-wide changes are made, and no certificate is installed. This is rich, non-obvious context beyond a simple 'add' operation.

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

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

The description is three sentences, each earning its place: it states the action and modes, explains the web-content-only scope, and names the alternative tool. It is front-loaded and free of filler or repetition.

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

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

The description thoroughly covers behavior, scope, and alternatives, and the schema richly documents parameters. However, because there is no output schema, the description does not state what the tool returns (e.g., the created route with id), which is a minor gap for an agent to understand the tool's 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?

All 14 parameters are documented in the schema (100% coverage), so the baseline is 3. The description reinforces the semantics of mode and the update-in-place behavior of id, but it does not add parameter-level information beyond what the schema already provides.

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

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

The description opens with 'Add (or update in place...) a mock/abort rule for Chrome/WebView requests on this device,' clearly specifying the action, resource, and scope. It also explains the two modes (mock and abort), and explicitly distinguishes itself from android_mitm_mock_add by noting the web-content-only scope.

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

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

The description gives explicit alternatives: 'For requests made by native app code use android_mitm_mock_add instead.' It also clarifies that this tool is for Chrome/WebView requests, and clearly states what it does NOT do (native app code), helping an agent decide when to use it.

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

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

No annotations are provided, so the description carries the burden. It discloses the destructive behavior (removes all routes) and the restorative effect (un-arms interception, normal networking). This is sufficient for a cleanup tool, though it doesn't mention edge cases like calling when no routes exist.

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, action first, no fluff. Every word adds value.

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

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

The tool is simple (one param, no output schema), and the description fully covers what it does, when to use it, and the expected outcome. No missing critical information.

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 has one parameter (udid) with full description coverage (100%). The tool description adds no extra parameter meaning, so baseline 3 is appropriate.

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

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

States a specific action: 'Remove ALL Chrome/WebView routes for this device and un-arm interception.' Clearly distinguishes from siblings like mock_remove (which likely removes a single route) by emphasizing 'ALL' and full cleanup.

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 states when to use: 'Call this when finished' and describes the outcome ('restores completely normal networking'). Does not name alternatives like mock_remove, but the context is clear enough for a teardown tool.

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 excels: it discloses that no certificate is installed, nothing device-wide is changed, and the effect is scoped to the page. It also explains ordering ('first match wins'). This provides rich behavioral context beyond what the schema offers.

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, each earning its place: the first states the purpose and ordering, the second and third define scope and side effects. No redundant or vague wording.

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

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

Given the tool's simplicity (one parameter, no output schema), the description covers all needed context: what is listed, match order, scope boundaries, and safety guarantees. It is complete for selection and invocation.

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

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

Schema description coverage is 100% (the udid parameter has a description). The tool description does not add any additional parameter semantics, but the baseline of 3 applies since the schema already documents the parameter fully.

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

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

The description clearly states the tool 'List the Chrome/WebView mock/abort routes currently registered for this device, in match order' — a specific verb and resource. It explicitly differentiates from native app interception tools by stating 'WEB CONTENT ONLY', which distinguishes it from android_mitm_mock_list and related siblings.

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

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

The description provides explicit when-not guidance: 'Requests made by native app code are NOT intercepted and never will be by this tool.' It also clarifies the scope to browser/WebView pages, implying that for native app traffic, a different tool (e.g., MITM mock list) should be used. This is strong usage direction.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key side effect: removing the last route automatically un-arms the device, preventing unnecessary traffic pausing. It does not cover error cases (e.g., non-existent id), but provides meaningful behavioral context beyond the basic action.

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

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

Two sentences, zero fluff. The first sentence states the action, and the second explains a critical side effect. Appropriate length and front-loaded with the core purpose.

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

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

For a simple two-param removal tool with no output schema, the description covers the function, the resource scope (Chrome/WebView), and the un-arm side effect. It also implicitly connects to mock_list via the id schema, making it sufficiently complete. Minor gap: no mention of what happens if the route does not exist.

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

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

Schema coverage is 100% with clear descriptions: 'id' references '*_mock_list' for provenance, and 'udid' clarifies it can be Android serial or iOS UDID, which is helpful given the 'android' prefix. The description adds no redundant parameter details, but the schema already does the heavy lifting.

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

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

The description uses a specific verb ('Remove') and resource ('one Chrome/WebView route by id'), clearly distinguishing it from sibling tools like mock_clear (which removes all) and mock_add/list/status. The singular scope ('one') emphasizes its selective role.

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 when to use this tool (removing a specific route) and adds important context about automatic un-arming when the last route is removed, warning against leaving traffic paused unnecessarily. It does not explicitly name alternatives, but the singular scope makes it obvious that clear is for bulk removal.

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 disclosure. It explains the kind of information returned (status, target, routes, counters) and adds a practical behavioral note about interpreting mocked: 0 as a sign of a non-matching route. It does not explicitly state that the operation has no side effects, but the 'report' framing implies a read-only purpose. Overall, it gives good context beyond a bare status description.

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 focused sentences. The first sentence front-loads the core purpose, and the second adds actionable guidance. No redundant words or filler, making it extremely efficient.

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

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

For a simple status tool with no output schema, the description fully covers what the user can expect: armed state, target, routes, and counters. It also explains the meaning of a zero counter, giving enough context for interpretation. The single parameter is already well-documented, so nothing essential is missing.

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

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

Schema coverage is 100% for the single udid parameter, and the schema already provides a description. The tool description adds no extra parameter semantics, which is acceptable because the schema carries the burden. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Report') and clearly identifies the resource (Chrome/WebView interception status). It enumerates the exact elements reported (armed state, page target, active routes, hit counters), which distinguishes it from sibling mock status tools (e.g., ios_safari_mock_status, webpage_mock_status) by referencing Chrome/WebView, which is Android-specific.

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

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

Provides clear context on when to use the tool: to check whether interception is armed and to confirm mocks are firing via counters. The guidance 'Check the counters to confirm a mock is actually firing' implies the use case, but it does not explicitly mention alternatives or when not to use it, so it stops 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?

No annotations are provided, so the description carries the full burden. It discloses valuable behavioral details: finalUrl is only non-null when waitMs>0, redirects become visible, pageId auto-selection, event waiting semantics. It also lists return fields (url, finalUrl, loaderId, errorText, frameStoppedLoading), which is useful given no output schema. This goes beyond a minimal description.

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

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

The description is a single, dense paragraph that front-loads the core action and then details return values and behavior. Every sentence earns its place — there is no filler or repetition of the schema. Highly efficient.

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

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

This is a navigation tool with 5 parameters, no output schema, and no annotations. The description covers the return value shape, the async/wait semantics, the auto-selection nuance, and caller-relevant caveats (finalUrl behavior). Given the tool's complexity and the absence of structured output/annotations, the description is complete 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 coverage is 100%, giving the description a baseline of 3. The description adds value on top: it explains the behavioral implication of waitMs (waiting for Page.frameStoppedLoading) and clarifies pageId's auto-selection behavior. It doesn't fully describe every parameter's format but the schema already documents them, so the description enriches meaning effectively.

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?

Description states a specific verb (navigate) plus the resource (a page on the device) and mechanism (CDP Page.navigate). It clearly distinguishes from siblings like device_navigate_url, ios_navigate_url, and web_navigate by being the android DevTools/CDP-specific variant. The scope is precise.

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 when to use it (navigate a device page via CDP) and clarifies the waitMs behavior and pageId auto-selection. However, it does not explicitly contrast against sibling tools like device_navigate_url or web_navigate, nor state when NOT to use it. The context is clear but lacks explicit exclusions/alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly states this is a read operation that extracts FPS/jank data via dumpsys gfxinfo and lists the metrics returned (total/janky frames, jank %, frame-time percentiles, missed vsyncs). However, it doesn't disclose whether metrics are cumulative or session-based, whether a running app is required, or if the app needs to be foregrounded. For a no-annotation tool, the description gives a reasonable but imperfect behavioral profile.

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

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

Single sentence, dense but clear, listing the data source and all metric categories. Every element earns its place with 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?

The tool has only 2 parameters fully documented in the schema (100% coverage), no output schema, and no annotations. The description tells the agent what stats it produces from a specific command, which is sufficient for a query tool. It could mention prerequisites (e.g., app must be installed/running) but overall covers the essential context for a metrics-read tool.

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

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

Schema description coverage is 100% — both serial and pkg come with descriptions referencing device_list for serial and giving an example package name. The description adds the metric details but doesn't expand parameter semantics further. Baseline 3 is appropriate given full schema coverage.

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

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

The description states a specific verb+resource ('FPS / jank stats for a package via dumpsys gfxinfo') and enumerates the exact metrics produced. It differentiates from siblings like android_app_launch_time and ios_fps by naming the command source and metric set. Clear purpose that distinguishes it effectively.

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

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

No explicit guidance on when to use this tool vs android_performance_snapshot, android_performance_record_start/stop, or ios_fps. It implicitly conveys it's for FPS/jank measurement, which suggests use cases, but it doesn't name alternatives or exclusion criteria. Adequate but not explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that bodies are truncated (each capped at 32000 chars), that includeBodies defaults to false, and that flows are decrypted HTTPS - useful context. It does not state whether reading flows is destructive or requires auth, but the read-only nature is strongly implied by 'Snapshot', which is reasonable.

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

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

Three sentences with zero wasted words. The description packs the flow fields, optional behaviors, and filtering options into a compact, immediately-parsable format. Every sentence serves a distinct purpose: what it returns, what includeBodies does, and what filters/limit exist.

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/snapshot tool with 5 documented params and 100% schema coverage, the description is largely complete. It explains the flow data structure, truncation, and filters. Minor gaps: it doesn't explicitly note this is the counterpart of android_mitm_mock_* for verification purposes, and no output schema exists to document exact return shape, slightly undermining completeness relative to its read-heavy use case.

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

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

Schema coverage is 100%, so the schema documents all 5 parameters. The description adds value by explaining the truncation behavior (bodies capped at 32000 chars), the default for limit (100), and clarifying what 'onlyErrors' means (5xx / connection-error). These augment rather than repeat the schema definitions, exceeding the baseline 3.

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

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

The description clearly states the verb+resource ('Snapshot recent DECRYPTED HTTPS flows') and enumerates the exact fields each flow contains. It distinguishes from siblings like android_mitm_start/stop/status by being the retrieval/read operation for captured traffic, and notably shares a parallel android_mitm_start reference tying it to the capture lifecycle.

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 implicitly ties usage to having started capture ('captured since android_mitm_start'), establishing the prerequisite context. It names filtering options (urlSubstring, onlyErrors, includeBodies) and the limit cap, though it does not explicitly exclude alternatives or state when NOT to use it versus related devtools/mock tools.

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

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

With no annotations provided, the description carries the full burden and does admirably. It discloses that the request never reaches the real server, that abort mode kills the connection so the app sees a network failure, that routes are stored per-device, take effect live with no restart needed, and the critical limitation that certificate-pinned apps cannot be intercepted at all (so a route targeting pinned traffic will never match). This sets accurate expectations around mutation scope and failure cases. Slightly more detail on the in-place update semantics could push this higher.

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

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

The description is a single dense paragraph that front-loads the core behavior before diving into modes and prerequisites. Every sentence contributes technical value—no filler. It's on the longer side but justified given the number of important behavioral caveats (per-device storage, live effect, pinned-app limitation). Could be slightly restructured into scannable sentences, but it's appropriately compact for the complexity.

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

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

This is a 12-parameter tool with nested objects, enums, and potential mutation consequences, yet the description covers the critical behavior (mock vs abort, matching semantics, per-device routing, live application, TLS capture prerequisite, pinned-app limitation). The schema already documents each parameter thoroughly at 100% coverage, and the description adds the behavioral layer on top. For a complex tool with no output schema and no annotations, this is as complete as one could expect.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds value by explaining the two modes ('mock' returns given status/headers/body; 'abort' kills the connection) and the match semantics ('URL pattern to match against the request's full URL'). It also clarifies the 'id' param behavior ('update in place, if id matches an existing route'). This is helpful context beyond what the schema provides for the mode and id semantics.

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

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

The description clearly states the tool adds/updates a mock/abort rule that short-circuits HTTPS requests inside mitmproxy, distinguishing mode 'mock' from mode 'abort' with specific behaviors. It differentiates from siblings like android_mitm_mock_list and android_mitm_mock_remove by explicitly naming the operation ('Add or update in place'). The verb+resource+scope ('Add mock/abort rule for mitmproxy on a device') is specific and unambiguous.

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

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

The description gives explicit prerequisites ('Requires TLS capture to already be running on this device (android_mitm_start)') and states that routes take effect live without restart. It explains when routes apply ('short-circuits future matching HTTPS requests') and names the alternative tool for capture startup. However, it doesn't explicitly contrast with mock_list/mock_remove or explain when to prefer one mode over another beyond the inherent semantics, so it's strong but not fully exhaustive.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation, which is reasonably clear. The description doesn't detail return format, whether it needs an active MITM session first, or whether abort routes are distinct from mock routes in output. It's adequate for a list operation but doesn't add rich behavioral context.

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

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

A single concise sentence that states the purpose and cross-references the companion tool. Zero wasted words, no redundant information. Excellent conciseness.

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

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

For a simple list operation with one well-documented parameter, this is nearly complete. However, given the sibling tool android_mitm_mock_add exists and MITM lifecycle tools (start/stop/status) are present, the description could clarify whether MITM must be active first and what an empty result looks like. It's adequate for the tool's simplicity but leaves minor workflow ambiguity.

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 has 100% coverage documenting 'serial' as the Android device adb serial. The description adds no additional parameter semantics beyond what the schema already documents. Per guidelines, baseline 3 applies when schema coverage is high and description doesn't need to compensate.

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

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

The description clearly states the tool lists mock/abort routes currently configured for a device. The verb 'List' is specific, and 'mock/abort routes' identifies the resource. It distinguishes from siblings like android_mitm_mock_add/remove, though its purpose is implied by naming convention rather than explicit contrast with all siblings.

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 'currently configured for this device' which implies the tool reflects current mock state on the device. It cross-references android_mitm_mock_add, giving some context on the related workflow. However, it doesn't explicitly state when to use this vs alternatives, when mock routes would be empty, or that it requires an active MITM session (a likely prerequisite given sibling android_mitm_start/stop tools).

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

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

No annotations are provided, so the description carries some burden. It discloses that removal is by id or all, and that it returns the resulting route list. However, it doesn't disclose whether removing all is destructive/irreversible, whether there are dependencies with android_mitm_start/stop, or handle unclear cases like passing both id and all simultaneously.

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

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

Two sentences, front-loaded with the primary action, then clarifies the dual modes and the return value. Every sentence earns its place. Slightly more could be added about the id source (already covered in the schema), so the description is appropriately minimal.

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

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

The description covers the core behavior (remove one or all routes) and the return value. However, there's no output schema and no annotations, so it could add more context about edge cases (e.g., what happens if id doesn't exist, whether all and id conflict, whether removal affects the running mitm session). For a tool with minimal structured metadata, the description is adequate but leaves some ambiguity.

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

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

Schema description coverage is 100%, so all three parameters already have descriptions in the schema. The description itself references the id coming from android_mitm_mock_add or android_mitm_mock_list, which adds useful provenance context beyond the schema's generic description. This slightly elevates above baseline, but no additional detail on parameter format or validation is provided.

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

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

The description uses a specific verb+resource combination: 'Remove one mock/abort route by id, or every route on this device when all is true.' It clearly distinguishes between the two modes of operation and identifies the resource affected. It differentiates from sibling tools (android_mitm_mock_add, android_mitm_mock_list) by focusing on removal.

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 when to use it (when you want to remove a mock/abort route) but doesn't explicitly name alternatives or provide exclusions. There's no guidance on when to use this vs android_mitm_stop, which could be confused as a way to tear down mock infrastructure. The 'Returns the resulting route list' hint gives some usage context but no explicit when/when-not guidance.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden and does so well. It discloses the two install modes (dpc vs manual), the silent vs interactive behavior, and the critical limitation that certificate-pinned apps won't decrypt. It doesn't mention whether the proxy/CA changes are reversible or cleanup behavior, and doesn't describe rate limits or duration, leaving a small gap.

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

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

The description is dense and information-rich with no wasted words, but it runs long (multiple sentences with parentheticals and conditional logic). It's front-loaded with the core purpose and then layers on conditional behavior and caveats. The technical density is justified given the tool's complexity, though the parenthetical-heavy style is slightly harder to parse quickly.

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

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

For a tool with one param, no output schema, no annotations, and moderate complexity, the description covers the purpose, the conditional modes, the prerequisites, the limitation (pinning), and the follow-up tool to read flows. It's missing cleanup/reversibility notes and doesn't explain what 'start' returns (though no output schema exists), but given the tool's complexity this is reasonably complete.

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

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

Schema coverage is 100% with a single 'serial' parameter clearly documented as 'Android device serial (adb serial)'. The description adds the context that serial targets the specific device for a per-device mitmproxy, but doesn't add deep semantic value beyond what the schema provides since there's only the one self-evident parameter. Baseline 3 is appropriate.

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

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

The description clearly states the purpose: 'Start TLS inspection on an Android device' with specific verb+resource. It distinguishes from sibling tools by contrasting with Chrome DevTools ('works for native apps too, unlike Chrome DevTools') and referencing the related android_mitm_flows for reading captured traffic. It also distinguishes from ios_mitm_start siblings clearly.

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

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

The description provides explicit conditional guidance: it explains that when com.robotactions.dpc is Device Owner, the proxy AND CA are set silently (installMode 'dpc'), while otherwise it falls back to adb global proxy (installMode 'manual') requiring user cert trust. It also explicitly states the prerequisite that the app must trust user certificates and that certificate-pinned apps will not decrypt, and references the follow-up tool android_mitm_flows.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The description reveals it reports three pieces of status information (running state, proxy mode, buffered flow count), which gives useful behavioral context. However, it doesn't address whether this is read-only, whether it requires MITM to be started, or what the response format is. For a presumably read-only status query, the lack of richer context is a gap but the description does convey the core 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 a single, well-formed sentence that front-loads the purpose and enumerates the three reported data points concisely. Zero waste, every element 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 a single documented parameter, no output schema, and no annotations, the description covers the basic query intent. However, it doesn't specify the output format/structure of the report, whether the tool works only when MITM is active, or how to interpret the proxy mode values. For a moderately simple status-read tool, this is adequate but leaves some gaps for an agent deciding how to consume the result.

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

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

Schema description coverage is 100% (the single 'serial' parameter is documented as 'Android device serial (adb serial)'). The description doesn't add parameter detail beyond the schema, but with only one fully-documented parameter, the baseline of 3 is appropriate. The description conveys the tool's context (per-device status) but adds no extra parameter semantics.

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

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

The description clearly states what the tool reports: TLS inspection running status, proxy mode (dpc/manual), and buffered flow count. It distinguishes from siblings like android_mitm_start/stop which control the feature, while android_mitm_flows handles the actual flows. The verb 'Report' plus the specific data points makes the purpose clear.

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

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

The description implies this is a status/read operation useful when MITM is active, and its sibling ecosystem (android_mitm_start, android_mitm_stop, android_mitm_flows) provides context. However, no explicit when-to-use guidance or exclusion of alternatives is given, leaving the agent to infer based on the sibling names.

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

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

With no annotations provided, the description carries the full transparency burden, and it delivers strongly. It explains the multi-consumer reference counting behavior, specifies exactly what happens when all consumers stop (proxy killed, device proxy/CA cleared, buffered flows discarded), and what happens when others remain (left running, stillRunning: true). The conditional destructive behavior is fully disclosed without any annotation support.

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

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

The description is two sentences that pack the essential behavioral contract: consumer scoping, conditional keep-alive behavior, stillRunning flag, and full teardown semantics. Every clause earns its place — no filler, no redundancy with schema, and information-dense without being bloated.

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

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

The tool has only one parameter (fully covered by schema), no output schema, and no annotations — so the description carries full explanatory weight, which it does excellently. It fully covers the stateful multi-consumer semantics, the teardown effects, and the stillRunning flag in the response. For a tool of this complexity, the description is complete.

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

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

The single 'serial' parameter has 100% schema coverage with a clear description ('Android device serial (adb serial)'). The tool description doesn't add much beyond the schema, but with only one well-documented parameter and full coverage, the schema does the heavy lifting — matching the baseline 3. No additional format or validation info is provided in the description, but none is critically needed.

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

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

The description clearly states the tool stops TLS inspection for an Android device, with the critical scoping detail 'from THIS (AI) consumer only.' This distinguishes it from a global teardown and clearly identifies the verb (stop), resource (TLS inspection on Android), and scope. It differentiates from siblings like android_mitm_start and ios_mitm_stop by being Android-specific and consumer-scoped.

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 implicitly communicates when to use it (to stop this agent's TLS capture), and it clarifies the conditional behavior when other consumers have capture open (stillRunning: true). However, it doesn't explicitly name the sibling alternative tools or state when NOT to use it vs. something like android_mitm_status to check state first. The multi-consumer behavior is clearly explained but exclusions/alternatives aren't enumerated.

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?

Discloses key behavioral traits beyond schema: it reuses an already-running scrcpy session (no fresh adb screencap), captures at physical device resolution with maxSize:0, returns image-only without page-source bundling. With no annotations provided, the description carries the full burden and covers mutation-safe, performance, and resolution semantics well. Doesn't mention failure modes or auth, but is strong for a screenshot 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?

Well-organized and front-loaded with the core purpose first, then usage guidance, then technical caveats. Slightly long (multiple sentences) but every sentence earns its place — each adds distinct operational value (performance, coordinate invariant, when-not-to-use).

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

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

For a single-parameter screenshot tool with no output schema and no annotations, the description is remarkably complete: it explains the mechanism, performance benefit, coordinate-matching invariant, and clear boundary with the sibling tool. Nothing material is left unexplained.

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% (single udid param fully described in schema). The description adds the resolution invariant ('pixel positions match device_tap coords 1:1') which is valuable context beyond the schema, but doesn't explain the udid format any further. Baseline 3 with modest added value is appropriate.

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

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

Description states a specific verb+resource: 'fast screenshot of an Android device via the ALREADY-RUNNING shared scrcpy session' returning a single JPEG frame. It clearly distinguishes from device_screenshot by highlighting the scrcpy session mechanism and naming the sibling explicitly.

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

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

Explicitly tells when to use this ('routine per-action screen checks', 'default for iterating on a flow') AND when not to ('Reserve device_screenshot for when you need the bundled labeled-elements list or a full-fidelity image'), naming the alternative tool directly.

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

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

No annotations are provided, so the description carries the full burden. It describes the start function but doesn't disclose details like how long recording runs, what happens when device disconnects, whether recordings accumulate if not stopped, data volume implications, or what the output/metrics look like. For a stateful start/stop pair with zero annotation coverage, this is a notable gap.

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

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

One well-structured sentence with a parenthetical analogy and a clear pairing reference to the stop counterpart. Efficient and front-loaded, though the analogy placement is slightly awkward mid-sentence.

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 stateful paired tool with no annotations and no output schema, the description should explain what happens after starting (where does data go?), how to retrieve results, and implications of the intervalMs parameter. The reference to the stop sibling helps but leaves the recording lifecycle and result retrieval unexplained. The sibling stop tool name gives some closure but more is needed.

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

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

Schema description coverage is 100%, covering pkg, serial, and intervalMs. The description adds context via the analogy and clarifies pkg focuses process filtering ('Focus processes containing this package'). The description doesn't repeat schema details but complements them modestly. Baseline 3 with slight bonus for the pkg clarification.

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

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

The description clearly states the verb (Start) and resource (recording per-process CPU/memory over time), with a helpful screen-recording analogy. It distinguishes from android_performance_snapshot by emphasizing time-based recording. However, it doesn't explicitly distinguish from the ios_performance_record_start or android_performance_record_stop, though the name largely encapsulates this.

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 indicates this is for time-series metrics (like screen recording for metrics) and explicitly references stopping with android_performance_record_stop. The pkg parameter hints at focusing on specific processes. However, it doesn't specify when to prefer this over android_performance_snapshot or when recording would be inappropriate.

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 of behavioral disclosure. The description discloses the output shape (time-series, per-process avg/peak) but doesn't state what happens if called without an active session, whether stopping is destructive (loses recording), or how it interacts with sessionId validity. For a stateful stop operation with zero annotation coverage, this is a significant gap.

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

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

The description is a single, focused sentence that conveys the action and the output shape. It is efficient with no filler or redundant text. Could slightly expand on behavioral details, but as far as conciseness, it's well-structured and front-loaded.

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

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

This is a stateful mutation tool (stops an ongoing recording) with no annotations and no output schema. The description tells what it returns but not the pre-conditions (active session required), failure behavior, or whether this terminates and frees resources. Given the stateful nature and lack of annotation support, the description should do more to be complete.

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

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

Schema coverage is 100% and the single parameter sessionId is fully described ('Session id from android_performance_record_start') in the schema itself. The description adds dependency context by implying the session must come from a prior start call, which aligns with the schema's own description. Baseline 3 is appropriate since schema does the heavy lifting.

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

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

The description states a clear verb+resource ('Stop a performance recording') and describes the return value (full time-series + per-process summary). It clearly distinguishes from android_performance_record_start and android_performance_snapshot. However, it doesn't explicitly disambiguate from sibling android_performance_record_stop (there's no such sibling, but the pairing with start is implicit).

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 it must be called after android_performance_record_start by referencing 'Stop a performance recording,' but it does not explicitly state the prerequisite relationship or explain when to use it vs android_performance_snapshot (which could be an alternative for point-in-time metrics). Context implies usage but no explicit 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?

No annotations are provided, so the description carries full burden of behavioral disclosure. It reveals the source tool (`top`), which is useful as it implies sampling at the moment of call (snapshot, not continuous). However, it does not disclose what the output format looks like, whether this is a passive read, typical latency, or behavior on multiple matching processes for pkg filter. For a read-only performance snapshot with no annotations, more detail would be valuable.

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, dense sentence that packs substantial information: the tool's purpose, the underlying mechanism (top), metrics captured (CPU%, MB), and both operational modes. Zero filler, every clause earns its place. Front-loaded with the primary action.

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

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

For a 3-param tool with no output schema and no annotations, the description covers the essentials: what it does, how it does it, and the two modes. However, it doesn't document the output shape (agent doesn't know what result format to expect), doesn't address edge cases (e.g., no pkg match, topN behavior), and lacks detail on when this is preferable to the record_start/record_stop siblings for time-series measurement. Adequate but with clear gaps given zero annotation coverage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by clarifying the DEFAULT of topN (implied 15 is in the schema) and how pkg behaves ('filter to processes whose name contains this package' — substring matching, not exact match). The description's mention of 'Top-N by CPU, or one app via pkg' ties the parameters to the tool's two operational modes, adding context beyond the schema fields.

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?

Description states a specific verb+resource ('Snapshot' CPU%/memory via 'top') with two clear modes (Top-N by CPU or one app via pkg), distinguishing it from related siblings like android_fps and android_performance_record_start/stop which cover different metrics/durations. It clearly identifies the mechanism (top) and units (%, MB). Slight deduction for not explicitly differentiating from ios_performance_snapshot, though the 'Android device' qualifier handles this.

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 two usage scenarios (top-N aggregate snapshot vs filter to a single package) but doesn't explicitly state when to prefer this over alternatives like android_performance_record_start for continuous measurement. The parameter `serial` reference to `device_list` hints at a prerequisite but it's implied rather than explicit. No exclusions or when-not-to-use guidance given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It covers key behavioral aspects: returns a short-lived, single-device URL, requires a human to open it in a browser, live transcoding to MJPEG. It doesn't mention how long 'short-lived' actually is or any auth/access constraints on the URL, but covers the essential delivery mechanism and purpose.

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 sentences, each adding distinct value: purpose, output details, mechanism, and use case. It's slightly verbose with the transcoding sentence being a nice-technical detail rather than essential action guidance, but overall efficient and well-structured.

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

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

For a single-parameter tool with no output schema and no annotations, the description covers the main things an agent needs: what it returns (a live URL), who consumes it (a human), how it differs (real-time vs screenshot), and when to use it (supervise agent actions on device). It could mention the URL's exact lifetime, but the description is quite complete for this simple tool.

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

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

Schema description coverage is 100%, so the schema already documents the udid parameter. The description doesn't add parameter-specific detail beyond what the schema provides, but there's only one parameter and its purpose (device identifier) is self-evident. Baseline 3 is appropriate and slightly above due to the clarity of the single parameter context.

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

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

The description uses a specific verb+resource: 'Get a LIVE video-stream link for an Android device that a human can open in a browser to watch the screen in real time.' It clearly distinguishes from device_screenshot (one frame) and android_mjpeg_screenshot siblings, and communicates the live, human-viewable nature of the output.

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

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

The description states when to use this tool ('Use this to let a person supervise what the agent is doing on the device') and contrasts with device_screenshot for single-frame needs. It lacks explicit exclusion guidance for other streaming alternatives like android_mjpeg_screenshot or device_record_start, but the context of use is clearer than most sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The word 'delete' implies a destructive irreversible action, but the description doesn't confirm irreversibility, whether it affects installed apps on devices, or whether permissions are required. For a destructive operation with zero annotation coverage, more disclosure is warranted.

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

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

Two sentences, zero waste. Every word serves a purpose: what it does, what it deletes, and how to get the ID needed to invoke it. Nothing extraneous.

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

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

For a simple single-parameter destructive tool, the description is adequately aligned with the schema. However, given that it's a destructive operation with no annotations and no output schema, the description could enhance completeness by noting whether deletion is permanent or whether the file must be re-uploaded. The missing output schema means the agent doesn't know what the response looks like, and the description doesn't bridge that gap.

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

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

Schema coverage is 100% and the appId parameter is described as 'File ID from app_list,' which matches the description's guidance. The description adds the same information as the schema (use app_list), so it provides modest complementary value. With a single parameter fully documented in the schema, baseline 3 is appropriate.

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

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

The description clearly states the verb+resource: 'Delete an uploaded app file from the server.' This distinguishes it from siblings like app_upload, app_install, and app_list, which are clearly different operations. However, it doesn't mention the destructive nature beyond the word 'delete,' which is somewhat implied.

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 a clear pointer to obtain the required ID: 'Use app_list to get the file ID.' This gives useful usage context. However, it doesn't explicitly state when NOT to use this tool or mention alternatives (e.g., device_uninstall_app for installed apps vs uploaded files).

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 behavioral disclosure burden. It discloses the install mechanism (APK via Android transport, IPA for iOS) but doesn't describe what happens on failure, whether prior uninstall is needed, permission requirements, or behavior when an app is already installed. For a mutating tool with zero annotation coverage, this is minimally adequate but not rich.

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

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

The description is compact (three sentences) and front-loaded with the core purpose. It efficiently covers platform differences and the dependency on app_list without unnecessary fluff. The format of each sentence earns its place.

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

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

The tool is a mutating operation with no annotations, no output schema, and complete schema coverage. The description covers the core install action, platform differences, and the required prerequisite step. However, it doesn't address failure modes, result/response expectations, or whether the device must be in a specific state. Adequate for a straightforward install tool but with gaps.

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

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

Schema description coverage is 100%, so both parameters (udid, appId) are already documented in the schema. The description adds the semantic link that appId is the file ID from app_list, which reinforces the schema. This is baseline-3 territory where the schema does the heavy lifting with a small description bonus.

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

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

The description states a specific verb+resource ('Install an uploaded app on a device') and differentiates between Android (APK) and iOS (IPA) transports. It clearly distinguishes from siblings like app_list, app_upload, and app_delete, and even references app_list for obtaining the file ID.

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 mentions getting the file ID via app_list first, which is useful usage context. However, it doesn't explicitly state when NOT to use this versus alternatives like ios_install_app, device_launch_app, or device_uninstall_app. The platform-specific note (Android vs iOS) implies some context but doesn't enumerate exclusions.

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

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

No annotations are provided, so the description must carry the full disclosure burden. It clearly indicates a read/list operation rather than a mutation, which is reasonable context. However, it doesn't disclose what the returned data looks like, whether listing is real-time or cached, or whether permission/auth requirements exist. For a simple list tool with no annotations, this is adequate but not rich.

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

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

A single sentence, perfectly concise, with zero wasted words. It states the action, the resource, and the scope. There is nothing extraneous.

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

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

For a zero-parameter list tool with no output schema, the description is reasonably complete. It tells the agent what files are returned (uploaded app files for the current user). However, it doesn't mention whether the list is ordered, limited, or includes metadata like upload dates or app IDs, which could matter for an agent selecting a specific app file. Given the tool's simplicity, this is mostly acceptable.

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 has 0 parameters, and schema description coverage is 100% (trivially so, since there are no properties to document). With zero parameters, the baseline is 4 per the rubric. The description doesn't need to add parameter semantics when there are none.

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 'List uploaded app files belonging to the current user' has a clear verb (list) and resource (uploaded app files), and scopes it to the current user. It distinguishes from siblings like app_upload, app_install, and app_delete which perform actions rather than listing. A 5 would require more specificity about what an 'app file' is, but this is clear enough.

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 a read-only listing use case ('List uploaded app files') but provides no explicit guidance on when to choose this versus related tools like device_list_apps, ios_list_apps, or app_upload. The user-scoping ('belonging to the current user') provides some context, but alternatives and exclusions are not stated.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It does mention chunk size limits (100MB) and that chunkIndex is 0-based. However, it doesn't disclose upload completion semantics, whether chunked uploads assemble automatically, error handling, or whether uploads can overwrite existing files with same name.

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

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

The description is compact and front-loaded with the core purpose in the first sentence. The two-sentence structure efficiently covers both upload modes. It's appropriately sized for the tool's complexity, though it could arguably be slightly more organized with separators between the single and chunked instructions.

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

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

The description covers the essentials for a 5-param, 2-required-param upload tool with no output schema and no annotations. It documents the two usage modes and size limits. However, it lacks details on return values (what success looks like), prerequisites (auth requirements), and post-upload behavior.

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

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

Schema description coverage is 100%, so each parameter already has documentation in the schema. The description does add value by explaining the logical grouping (single mode requires fileName+fileData; chunked adds chunkIndex+totalChunks), which clarifies the semantics beyond individual parameter descriptions. However, it doesn't add significant new meaning beyond what the schema 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?

The description clearly states the tool uploads an app file (APK/IPA) to the server, with a specific verb+resource. It also distinguishes between single and chunked upload modes. However, it doesn't explicitly differentiate from siblings like app_install or app_delete; while app_upload is clearly distinct by name and purpose, the description could note that this is the 'upload' step separate from 'install' or 'delete'.

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 specific guidance on how to choose between single vs. chunked uploads by specifying which parameters to provide for each mode. It also gives a concrete size threshold (max 100MB per chunk). However, it doesn't state when one should use chunked vs. single (e.g., 'use chunked for files >100MB'), only how to structure each mode.

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

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

No annotations are provided, so the description carries the full burden. It explicitly flags itself as a mutating operation requiring user confirmation, which is exactly the disclosure needed. It also discloses HTML wrapping behavior for description and the project name subtlety (often same as URL segment after org). Slight gap: no mention of failure modes or permission requirements, but key mutating-warning is stated directly.

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 informative — five sentences covering purpose, return value, safety warning, and the most important param nuances. Slightly dense but every sentence earns its place. None of it is redundant with the schema.

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

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

No output schema, so the description compensates by naming the return (id + browse URL). With 5 parameters and 100% schema coverage, plus key behavioral warnings (confirm-first, HTML wrapping, project name quirk), the description provides solid context for a moderately-complex create tool. Would benefit from a mention of error output format, but coverage is strong overall.

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

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

Schema coverage is 100%, so the schema already documents all 5 parameters. The description adds genuine value beyond the schema: clarifies the project arg matches the URL segment after the org, notes description gets wrapped in <p> tags, and explains tags are stored as semicolon-separated internally. These are non-obvious behaviors the schema doesn't convey.

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?

Description clearly states verb+resource ('Create a new AzDO work item') and explicitly notes it returns the new id + browse URL. Distinguishes cleanly from siblings azdo_get_work_item and azdo_search_work_items via the create semantics.

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 instructs 'ALWAYS confirm with the user before calling' with the reason listed (mutating operation). The 'project' clarification and default workItemType guidance give concrete context on when/how to invoke. Strong behavioral guardrails present.

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

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

No annotations are provided, so the description carries the disclosure burden. It discloses credential handling (uses stored credential, no inline), notes HTML stripping behavior, and states it returns an actionable error if AzDO is not configured. These are genuinely useful behavioral details beyond what the schema conveys, though a read-only safety hint would have added more.

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

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

The description is a compact three-sentence paragraph that front-loads the core purpose and return fields. It efficiently covers return format, credential semantics, and error behavior without wordiness. Loses one point for being a dense block rather than using clearer structural separators, though the density is justified by the field 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 single-parameter read tool with 100% schema coverage and a detailed return-field list, the description is thorough. It discloses return fields, credential requirements, HTML-stripping behavior, and error handling. No output schema exists, so enumerating the return fields is appropriate and adequately compensates. The only minor gap is the absence of a declared read-only hint, which annotations would normally cover.

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 covers 100% of the single parameter with a clear description ('AzDO work item ID (e.g. 12345). Positive integer.'). The description reinforces the integer ID requirement and adds the return-field context that illuminates what the parameter drives, but doesn't need to elaborate further given the high schema coverage. Baseline 3 plus a small bonus for reinforcing the positive-integer constraint in prose.

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?

Description opens with a specific verb+resource ('Fetch a single Azure DevOps work item by integer ID') and enumerates exactly which fields are returned. It clearly differentiates from siblings like azdo_search_work_items (search by query) and azdo_create_work_item (creation). The scope is precise and unambiguous.

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

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

The description states it uses the calling user's stored credential and does not accept inline credentials, providing useful contextual guidance. However, it does not explicitly say when this tool should be used versus alternatives like azdo_search_work_items, nor does it give exclusions. The credential disclosure is helpful but doesn't constitute full when-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the 50-item return cap, clarifies that only IDs are honored from the SELECT clause (batch-fetching full fields), and notes the search scope. This is meaningful behavioral disclosure beyond what's in the schema, though it doesn't mention auth requirements or read-only safety.

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 concise yet information-dense. It packs the core purpose, the query language reference, two concrete examples, a critical caveat about SELECT clause behavior, and the return cap into a compact paragraph with efficient formatting. No wasted words.

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

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

For a search tool with 100% schema coverage and no output schema, the description covers the essential aspects: what it searches, how to query, return limits, and the projection behavior. It could note whether results are sorted or how to handle pagination for more than 50 results, but for typical usage it's reasonably complete.

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

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

Schema coverage is 100%, so both parameters are documented. The description adds meaningful value beyond schemas: it explains the WIQL syntax, clarifies that SELECT columns beyond IDs are ignored, and provides real query examples. The maxResults parameter's behavior and cap are documented 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 states what the tool does: 'Search AzDO work items with WIQL (Work Item Query Language)' with specific verb+resource. It distinguishes itself from azdo_get_work_item by noting it returns the 'same projection,' and the sibling list shows it's unique as the search variant among azdo_create/get work item tools.

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

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

The description provides clear context for when to use this tool (searching with WIQL queries) and gives concrete WIQL examples to illustrate usage. It describes the return cap of 50 items but doesn't explicitly state when NOT to use it or contrast with another search alternative (though jira_search is a sibling for a different platform).

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

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

With no annotations provided, the description carries the full burden. It explains the return format ({ ok, packageName, apks: [...] }), the split APK behavior (config splits, dynamic feature modules), and the role field values, which is substantial behavioral disclosure beyond the bare schema.

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

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

The description is a single dense paragraph, appropriately sized. It front-loads the core purpose, then adds return format details and usage pointers in a logical flow. Slightly verbose with the return JSON but this is concise and valuable information packed efficiently.

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

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

For a two-parameter read-only tool with no output schema, the description adequately covers the purpose, return format, and downstream usage (device_file_pull). The success/error behavior (ok flag) is disclosed. Given no output schema exists, the return format documentation partially compensates for that gap.

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

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

Schema coverage is 100%, so both parameters (udid, packageName) are fully documented in the schema. The description doesn't add additional parameter semantics beyond what the schema provides, but the schema already fully describes both params, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb (List), resource (APK file paths), and mechanism (`pm path`). It distinguishes itself from sibling tools like device_file_list (which lists files broadly) and device_file_pull (which pulls bytes) by explicitly framing this as an APK-specific path listing tool.

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

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

Clearly states the tool returns paths and sizes, and directs users to device_file_pull for fetching bytes with explicit mention of the 5MB cap and 20MB maxSizeBytes. However, it doesn't explicitly state when NOT to use it or name alternatives directly, though the pull tool reference is implied guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description mentions what data is returned (level, charging state, temperature), which is useful. However, it doesn't disclose whether this requires an active device session, whether it's non-mutating, or any rate-limit/auth considerations. The return fields listed add some value but leave the operational context unclear.

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

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

A single, efficient sentence that captures the purpose and the key fields returned. Zero wasted words and the essential details are immediately available.

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

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

For a simple single-parameter read tool, the description covers the basic return values, which is adequate. However, no output schema exists to document the return format/structure, and the description is vague about whether it returns structured metrics or raw values. Given the tool's simplicity, it's acceptable but could note the return format or units (e.g., percentage, Celsius).

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

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

Schema description coverage is 100% (the single udid parameter is documented as 'Device serial number (UDID)'). The description adds no additional parameter context beyond what the schema provides. A baseline of 3 is appropriate since the schema fully documents the one parameter and it's a simple, self-explanatory required field.

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

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

The description clearly states the tool gets battery status including level, charging state, and temperature for an Android device. It uses a specific verb ('Get') with a clear resource ('battery status of an Android device'). It's slightly generic compared to the sibling ios_battery, but the Android-platform qualifier helps distinguish it from other device_* tools.

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

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

The description implies when to use it (when you need device battery info), but provides no explicit when-not-to-use guidance or alternative suggestions. It's clear this is a diagnostic/status tool vs actions like device_shell or device_info, but no exclusions or alternatives are named. There's no mention of preconditions like requiring a connected/focused device.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. 'Clear all data and cache' does communicate the destructive nature of the operation, which is the key behavioral trait. However, it doesn't mention side effects like user sign-out, in-app state loss, or whether cache vs data can be selectively cleared. Given zero annotations, it's workable but leaves details 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?

Two sentences, zero wasted words. The first sentence states the action clearly and the second anchors it to an intuitive equivalent users know. Every element 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 destructive mutation tool with no annotations, the description communicates the core operation ('clear all data and cache') and its equivalence to Clear Storage. It lacks warnings about irreversibility, user session loss, and doesn't note that this tool is irreversible vs alternatives. With no output schema and no annotations, it could do more to explain post-conditions, but the essential semantics are captured.

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

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

Schema description coverage is 100%, so both parameters (udid and packageName) are already well-documented with clear descriptions including an example. Per baseline rules, a 3 is appropriate when the schema does substantive documentation work. The description adds the packageName-to-app-data correlation which is consistent with the schema.

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

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

The description uses a specific verb+resource combination ('Clear all data and cache for an app on an Android device') and adds the equivalent 'Clear Storage' in Settings reference, which gives the agent a concrete mental model. It clearly distinguishes from siblings like device_clear_app_locale and app_delete, as it's specific to clearing app data on Android.

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 when to use this (when needing to reset an app's data/cache on Android), and the 'Equivalent to Clear Storage in Settings' provides useful framing. However, it doesn't explicitly state when NOT to use it, and importantly doesn't warn that this is destructive (logs users out, resets app state) or contrast it with device_terminate_app or app_delete or device_clear_app_locale. No 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 provided, the description carries the full burden of behavioral disclosure. It does state the Android 13+ requirement, which is valuable. However, it doesn't disclose that this is a read/toggle-style operation with no destructive side effects, nor does it describe what happens if no override exists or what the return value looks like. The Android version constraint is the main behavioral note.

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, zero waste. Each sentence earns its place: what it does, its counterpart, and the platform version requirement. Efficient and front-loaded with the action.

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

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

The tool is simple (2 required params, no output schema, no nested objects) and the description covers the core purpose well. However, it doesn't specify behavior when no override is set, error conditions, or the return value. Given the simplicity, this is adequate but not thorough.

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

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

Schema description coverage is 100%, so both parameters (udid and packageName) are already documented in the schema with clear descriptions. The description adds no additional parameter-level insight beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states what the tool does: drops the per-app locale override so it falls back to device system language. It identifies the resource (Android app locale override) and the verb (clear/drop). It names a direct sibling counterpart (device_launch_app_in_language), providing good differentiation from related tools.

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

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

The description implies when to use it (to remove a locale override set by device_launch_app_in_language) by explicitly naming the counterpart tool. However, it doesn't explicitly state when NOT to use it or list alternative tools like device_set_device_language, which sets the device-wide language rather than per-app.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does explain the mechanism (helper service stops pushing mocked fixes and apps fall back to real GPS/network provider), which is useful context. However, it doesn't mention edge cases like what happens if no mock is active, whether the real location provider was disabled concurrently, or idempotency behavior.

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

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

Two sentences, zero waste. The description is front-loaded with the primary action, then adds the counterpart reference and behavioral explanation. Every word 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?

This is a simple single-parameter, no-output-schema tool operating with an evident counterpart. The description is complete for this complexity level — it identifies the action, the mechanism, and the fallback behavior. The only minor gap is edge-case behavior (idempotency, no-mock-active scenario), which a 1-param tool might reasonably omit.

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

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

Schema description coverage is 100%, with the single 'udid' parameter fully documented as the device serial number. The description adds no parameter-specific detail beyond the schema, which is acceptable given the parameter is trivial and well-documented.

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

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

The description clearly states the verb+resource ('Stop mock GPS on an Android device') and explicitly names its counterpart (device_set_location). This distinguishes it from related sibling tools like device_set_location and ios_clear_location while making the purpose unambiguous.

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

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

The description provides clear context by explicitly naming the counterpart tool (device_set_location) and explaining the behavioral effect (apps fall back to real GPS/network provider). It doesn't explicitly state when not to use it or mention alternatives, but the sibling relationship with device_set_location gives adequate contextual guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the mechanism (reads text length, sends DELETE keycodes, moves cursor to end) and the requirement to focus the field first. It doesn't describe failure modes or the return value, but for a clear-text operation the disclosed mechanics are reasonably transparent.

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

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

Two sentences, front-loaded with the purpose, then mechanism, then prerequisite and alternative. Zero wasted words; every sentence earns its place by either stating what it does or how to use it.

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 focused-field clear operation with a single udid parameter and no output schema, the description covers purpose, mechanism, prerequisite (focus), and an alternative approach. It's slightly limited by not describing failure behavior (e.g., what happens if no field is focused), but the core information is complete for an agent to select and invoke correctly.

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

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

There is only one parameter (udid) at 100% schema coverage, and udid is a standard device serial identifier with no ambiguity. The description focuses on behavior rather than parameters, but with a single self-explanatory required parameter, the schema fully documents it and no additional semantics are needed.

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

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

The description clearly states the tool clears the focused text field on Android by sending DELETE keycodes equal to the current text length, after moving cursor to end. This is specific (verb=clear, resource=focused text field on Android) and distinguishes from siblings like device_type, ios_clear_text, and device_clear_app_data.

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 states to tap the field to focus it first as a prerequisite. Also names an alternative: 'To clear and re-type in one call, use device_type with clearFirst:true instead.' This provides clear when-to-use guidance and names the sibling alternative directly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers substantially. It explains the internal technical reason (shell process lacks foreground/READ_CLIPBOARD_IN_BACKGROUND on 13+), and crucially discloses that it returns an 'empty-clipboard sentinel' rather than the raw OS error. This empty-sentinel behavior is a critical behavioral trait that could otherwise mislead an agent into thinking the clipboard is genuinely empty.

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

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

The description is a single, focused paragraph that front-loads the core purpose ('Read the current clipboard content') before diving into version-specific caveats. It's well-structured, and every sentence earns its place by covering purpose, OS-version differences, and the recommended workaround. Slightly dense in the middle section but appropriately so given the complexity of the cross-version 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 simple single-parameter, no-output-schema tool, the description is thorough. It covers the core operation, the version-dependent failure mode, the sentinel return value, and the mitigation strategy. It could arguably be complete at 5 for its simplicity, but the deep technical rationale (shell permissions) is perhaps more detail than strictly needed, and the fact that it reads as more iOS-comparative than necessary tempers the score slightly.

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 (udid) has 100% schema description coverage ('Device serial number (UDID)'), so the schema already fully documents it. The description adds no parameter-specific detail beyond the schema, which is acceptable given the baseline of 3 for high coverage. No additional syntax or format guidance is needed for a simple string UDID parameter.

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

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

The description clearly states what the tool does: 'Read the current clipboard content from an Android device.' It uses a specific verb (read) plus resource (clipboard content), and it distinguishes itself from the sibling device_clipboard_set by explicitly noting the 13+ blocking behavior and recommending the set-then-paste alternative. It also differentiates from the iOS clipboard tools (ios_clipboard_get_hid, ios_get_pasteboard) by specifying the Android platform.

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

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

The description provides explicit when-to-use guidance by explaining the Android version dependency: reliable on 12 and earlier, blocked on 13+. It names the specific alternative approach (device_clipboard_set for round-tripping text on 13+) and warns explicitly not to rely on read-back on 13+. This goes beyond implied usage and provides actionable context for the agent.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It explains the KEYCODE_PASTE injection being 'built into the device control protocol,' discloses that empty string clears clipboard, and implies a state-modifying operation. Good disclosure of side effects without 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?

Three concise sentences, each earning its place: the primary purpose, the paste injection detail, and the empty-string clearing edge case. No fluff or redundant restatement of parameter names.

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

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

For a straightforward clipboard-set tool with 3 simple params and full schema coverage, the description covers the essential behavioral nuances (paste injection, clear semantics). It doesn't mention return values, but with no output schema and a fire-and-forget device control operation, that's acceptable. Missing only minor details about return confirmation.

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

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

Schema description coverage is 100%, so the schema documents all 3 parameters (udid, content, paste). The description adds context by connecting the paste parameter to the KEYCODE_PASTE behavior and clarifying empty string semantics, complementing rather than redundantly restating 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?

Specific verb+resource: 'Set the Android device clipboard via the device control channel.' It clearly states what it does, including the paste injection behavior and empty-string clearing. Distinguishable from siblings like device_clipboard_get and ios_clipboard_set_hid.

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 paste:true behavior and explicitly notes that no separate Ctrl+V is needed, which guides correct usage. It doesn't enumerate exclusions or when-not-to-use scenarios, but provides clear context for the main usage pathway.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It states this is a read-only query (get current app) and specifies what it returns (package name and activity), which covers the core behavior. However, it doesn't describe edge cases like what happens when the home screen or system UI is foreground, whether a lock screen counts, or the exact return format/type.

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

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

The description is a single sentence, two clauses, with zero waste. It's front-loaded with the primary purpose. Slightly more detail could have been included about return format, but for a simple read-only tool this is appropriate.

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

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

This is a simple tool with 1 parameter and no output schema. The description names what it returns (package name and activity) but doesn't describe the return structure or format. Given the lack of output schema and annotations, a bit more detail on edge cases (e.g., behavior when device is locked, home screen foreground) would improve completeness, but the current description is adequate for a simple query 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?

The schema has 100% coverage on its single parameter (udid described as 'Device serial number (UDID)'), so the schema fully documents the parameter. The description doesn't add parameter-specific semantics beyond what the schema provides. Baseline 3 applies since schema coverage is 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 description clearly states what the tool does: 'Get the currently active (foreground) app on an Android device.' It uses a specific verb+resource combination and returns package name/activity. However, it doesn't explicitly distinguish itself from the similar sibling 'ios_active_app' or device app-related tools, though the Android-specific naming implicitly handles that.

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

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

The description implies usage context (get foreground app on Android device) but provides no explicit when-to-use guidance or exclusions. It doesn't mention when this is preferable to alternatives like device_page_source, device_screen, or device_find_element. No prerequisites or conditions are stated, though the Android-specific name provides partial guidance.

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

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

No annotations provided, so description carries full burden. It discloses the mechanism (keycode 187 APP_SWITCH shell, policy-gated), the wait-for-settle behavior, the locates-and-swipes approach, and the return shape ({ success, action, ... }). This is rich behavioral disclosure for a side-effecting UI automation 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?

Three sentences, front-loaded with the core action, followed by use cases and mechanism detail. Slightly verbose with implementation specifics (keycode 187, policy-gated) that could arguably be trimmed, but each clause earns its place for transparency.

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 3-param tool with 100% schema coverage and no output schema. The description covers the mechanism, the use case, the return shape, the optional all flag behavior, and default packageName behavior. No meaningful gaps remain for an agent to correctly select and invoke this 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% with each parameter well-documented ('Tap Close all instead of swiping a single card', 'package name... If omitted, dismisses the first/frontmost card'). The description adds marginal context by mentioning the return includes an action field, but parameters are fully explained by the schema, so baseline 3 applies.

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

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

Specific verb+resource: opens Recents, dismisses an app card via swipe, with optional 'Close all'. Clearly distinguishes from siblings like device_terminate_app (which kills directly) and device_swipe (generic swipe) by naming keycode 187 (APP_SWITCH). The intent is unambiguous.

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

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

States clear use cases: 'clearing background apps or verifying an app was killed.' Implicitly distinguishes from device_terminate_app (which terminates in-process rather than via Recents UI). Doesn't explicitly name an alternative when NOT to use it, but the context is clear.

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

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

With no annotations provided, the description carries the full burden. It discloses the multi-phase gesture mechanics (hold, then motion), default timings, the coordinate space (physical pixels from page_source bounds), and the deliberate-grab requirement. It does not explicitly state that a drag is a mutating/screen-changing operation or mention any permission/auth needs, but the gesture mechanics disclosure is substantive and useful.

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

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

Three tight sentences deliver purpose, differentiation, use cases, and coordinate semantics with zero filler. Every sentence earns its place, and the most critical selection-differentiation detail (how it differs from swipe/long_press) is front-loaded.

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

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

The tool has 7 params (5 required) with 100% schema coverage and no output schema (returns void presumably). The description covers the gesture mechanics, defaults, coordinate space, alternatives, and use cases. The only gaps are edge-case behavior (e.g., zero durations, out-of-bounds coords) and whether the drag can cross screen boundaries, but for a gesture tool with full schema coverage this is largely complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the semantic roles of the coordinate parameters within the gesture flow: (x1,y1) is the hold point for the deliberate grab, and (x2,y2) is where the drag ends. It also explains the role of holdMs (grab) and durationMs (motion). However, it does not detail edge cases like what happens if holdMs is 0 or coordinate bounds.

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

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

The description uses a specific verb+resource ('Drag-and-drop on an Android device') and clearly details the mechanism (hold at (x1,y1), move to (x2,y2) over duration). It explicitly distinguishes itself from sibling tools device_swipe (no hold) and device_long_press (no motion), providing concrete if/then decision criteria.

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

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

The description explicitly names alternative tools and when NOT to use them ('Distinct from device_swipe... and device_long_press...'). It gives concrete use cases ('app-icon reorder, drag-into-folder, slide gestures that need a deliberate grab') that map to when this tool is appropriate, which is strong guidance for selection.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses the sorting behavior ('Sorted smallest-first so the most specific element comes back first') and the scope filter (only elements with resource-id, text, or content-desc present). However, it does not state whether this is a read-only operation, whether it may take a screenshot, side effects, or performance characteristics. The key behaviors disclosed are useful but the read-only nature is implicit rather than stated.

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

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

Three sentences, each earning its place: sentence one defines scope and output, sentence two explains sorting order, sentence three gives concrete usage guidance with examples. No filler, no redundancy with the schema.

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

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

Given no output schema and no annotations, the description does a good job explaining return contents (attributes, bounds, center coords, locator strategies) and sorting behavior. However, it does not disclose the read-only nature explicitly, error conditions (e.g., empty region, invalid coordinates), or the relationship to sibling tools like device_find_element or device_locators_for. For a moderately complex enumeration tool with 6 params and no annotations, it is fairly complete but could mention error/edge cases.

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

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

Schema description coverage is 100%, so all 6 params are documented in the schema. The description adds semantic value beyond the schema: it explains what 'intersects' means for the coordinates, and mentions the limit's role (capping returned elements). It clarifies the physical-pixel unit in the description and coordinates context. The schema provides per-field definitions, so the description modestly supplements rather than restates. Given 100% coverage, baseline 3 applies, but the description adds meaningful contextual meaning around the region semantics and the limit.default.

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

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

The description clearly states the verb ('List'), the specific resource ('addressable UI elements'), the filtering criterion ('bounding box intersects the given physical-pixel rectangle'), and what each element contains ('attributes, bounds, center coords, ranked locator strategies'). It also distinguishes from likely siblings like device_page_source or device_find_element by framing it as region-scoped enumeration without full XML parsing.

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 clear context for when to use it: 'Use to enumerate the contents of a region (bottom nav, dialog, list section) without parsing the full XML.' This explains the use case well and contrasts it against full-XML page parsing, but does not explicitly name alternative tools or state when NOT to use it. It does not mention exclusions like non-addressable elements or interaction tools.

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

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

No annotations are provided, so the description carries full burden. It discloses the return format ({ok, remotePath, count, entries}), the protocol used (file-sync, no shell roundtrip), and an edge behavior (symlinks resolved one level). This is solid behavioral disclosure for a read-only listing operation, though it doesn't detail error cases or permissions.

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 sentences, zero wasted words. Every sentence adds value: what it does, protocol note, return shape, and common roots. Front-loaded with the core purpose and immediately follows with actionable details.

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

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

For a fairly simple two-parameter read-only listing tool, this description is well-rounded. It documents the return structure inline, gives practical path examples, and notes the symlink behavior. It lacks an explicit output schema but compensates by documenting the return shape in prose. Error handling and permission requirements are not addressed, but breadth is appropriately capped for a low-complexity 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% with both parameters (udid, remotePath) documented in the schema. The description adds value by clarifying common root paths and showing example values (/sdcard/Download), plus the entry fields (name, isDir, size, modTime) which enrich what parameters would return. This slightly exceeds the baseline 3 for full schema coverage.

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

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

The description clearly states 'List files and directories at a path on the device', a specific verb+resource combo. It distinguishes from sibling tools like device_file_pull and device_file_push by naming the file-sync protocol (no shell roundtrip) which separates it from device_shell. It also documents the exact return shape.

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

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

The description provides clear usage context by listing common roots (/sdcard/, /sdcard/Download, /sdcard/DCIM) which helps an agent know typical paths to use. However, it doesn't explicitly state when NOT to use this tool or name alternatives like device_shell, though the file-sync protocol note implies the distinction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers: explicitly states it returns base64-encoded content, describes the default 5MB cap and 20MB override limit, discloses that it refuses directories and oversized files before transferring, and documents the exact return shape. This is exceptional transparency for a tool with zero annotation coverage.

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

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

Three dense sentences with zero waste. Every element earns its place: the action, the encoding format, the size constraints with defaults and overrides, the refusal conditions, and the return schema. Highly efficient and front-loaded.

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

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

For a tool with 3 params, no output schema, and no annotations, this description covers the essential behavior comprehensively: size limits, refusal conditions, return format. It omits nothing critical for an agent to invoke correctly. Slightly incomplete in not describing error conditions beyond refusal cases, but the core contract is fully documented.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters well (udid, remotePath, maxSizeBytes). The description adds value by explaining the default size cap behavior and the return contract, but doesn't add parameter-level semantics beyond what the schema provides. Baseline 3 is appropriate given full schema coverage.

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

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

The description states 'Pull a file from the device' with a specific verb+resource. It also clearly differentiates from siblings: device_file_push (write direction) and device_file_list (listing), making the pull direction unambiguous and well-scoped.

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

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

The description provides clear context on when to use it (pull files from devices) and its size limits/overrides. It doesn't explicitly name alternative tools for exclusions, but the pull direction vs push/list siblings is self-evident. The maxSizeBytes override behavior is clearly documented.

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 behavioral disclosure burden. It discloses the 20MB decoded size hard cap, the metacharacter restriction on remotePath, and the return shape { ok, remotePath, sizeBytes }. It doesn't mention auth/permissions needs or overwrite behavior, but the disclosed constraints are meaningful and beyond basic expectations.

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 dense sentences with zero waste. Each sentence carries distinct useful information: operation+format, allowed destinations, size cap+security constraint, and exception routing with return shape. Front-loaded with the primary action.

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

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

For a 3-param tool with no output schema and no annotations, the description covers operation, encoding, destination constraints, size limits, security notes, alternative routing, and return format. It could mention overwrite behavior or permission requirements, but for a file-push utility the coverage is solid and practical.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value beyond the schema: it clarifies content is base64-encoded (matching the schema's description but reinforcing encoding format), specifies the 20MB decoded cap interpreting content size, and explains remotePath's constraints (no shell metacharacters, must be an allowed absolute path). This adds genuinely useful semantics.

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

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

The description clearly states 'Push a base64-encoded file to the device' with a specific verb+resource pairing. It distinguishes this from device_file_pull (pull direction) and app_install (for APKs explicitly), and the sibling list contains both device_file_pull and app_install, showing intentional differentiation.

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

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

Provides explicit when-to-use guidance including allowed destinations (/sdcard/, /data/local/tmp/), what those dirs are for (frida-server, tcpdump), hard size cap, metacharacter constraint, and explicitly directs APK cases to app_install instead. This is strong when/when-not guidance.

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

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

With no annotations provided, the description carries the full burden. It usefully discloses that the output is in PHYSICAL pixels and requires no scaling — a valuable behavioral detail. However, it doesn't disclose whether the find fails (behavior when no match found), returns first match only, or whether both text and contentDesc can be combined, leaving some behavior opaque.

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

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

Two sentences, both carrying essential information. The first states the purpose and search criteria; the second imparts the critical coordinate-scaling detail. Zero wasted words.

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

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

For a locator tool with 100% schema coverage and a clear integration point (device_tap), the description is largely complete. It explains the core output transformation (physical pixels). It's slightly short on failure behavior and match ambiguity (multiple elements matching the same text), but for this complexity level with full schema coverage it's adequate.

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

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

Schema coverage is 100%, with each of the four parameters (text, udid, resourceId, contentDesc) already described in the schema. The description adds that matches are by 'visible text or content description,' which maps to two params, but doesn't add meaning beyond the schema for resourceId or how parameters interact (e.g., AND vs OR semantics). Baseline 3 is appropriate.

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

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

The description clearly states the verb ('Find') and resource ('UI element on an Android device'), specifies the search criteria (visible text or content description), and differentiates itself from siblings by noting it returns physical pixel coordinates usable directly with device_tap. This distinguishes it from device_tap_by_text, device_locators_for, and device_wait_for_element.

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 when to use this tool (to locate an element before tapping) by explaining the output is directly consumable by device_tap. However, it doesn't explicitly state when NOT to use it or name alternative tools (e.g., device_tap_by_text for direct text-based tapping, device_elements_in_region for region-based queries), which would strengthen usage guidance.

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

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

No annotations are provided, so the description carries the full behavioral-transparency burden. It discloses the return format (short summary + matching logcat lines, newest last), the filter sources, and the semantic meaning of an empty result. It does not detail rate limits, time-window semantics of 'recent', or whether it mutates state, but as a read-only diagnostic it is well covered given no annotations exist.

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 that each earn their place: purpose+timing, filter details, and interpretation of empty result. Slightly dense with technical detail in the filter clause, but no wasted words. It is effective and front-loaded; could arguably be trimmed but the density serves the diagnostic use case.

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 diagnostic tool with 2 params (100% schema coverage) and no output schema, the description thoroughly covers what the agent needs: when to invoke, what filters are applied, expected return shape, and how to interpret both populated and empty results. The completeness is high for its complexity class—every decision point the agent might face is addressed.

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

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

Schema description coverage is 100% (both udid and max are documented in the schema). The description adds behavior for max ('Newest last') which the schema already states, and clarifies output ordering but not much beyond the schema. The description restates the 'newest last' ordering for the return rather than adding new parameter meaning, so baseline 3 is appropriate.

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

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

Description states a clear purpose: 'Read recent Android focus-change events from logcat' with a specific verb (Read), resource (logcat focus events), and scope (recent). It names concrete log sources (ViewRootImpl, WindowManager, InputMethodManager). Although there are no direct siblings doing logcat focus reads, the description differentiates from device_type and device_tap by explicitly positioning it as the diagnostic step between tap and type.

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?

Exceptionally clear usage guidance: specifies exactly WHEN to use it ('AFTER a tap on an input field and BEFORE device_type'), names the race condition it diagnoses ('type went into the wrong field'), and explains how to interpret the result (empty result = tap did NOT change focus; lists two specific failure modes: missed tap or non-focusable element). This goes beyond 'when to use' into 'how to interpret outcomes', which is excellent.

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

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

No annotations are provided, so the description carries the full burden. It discloses that this is a read-only operation (getting a URL) and that it returns a URL string. However, it doesn't mention what happens if Chrome isn't open or no page is loaded (error vs blank), device prerequisites (Chrome must be installed/running), or whether multiple tabs are handled (which URL is returned). These gaps are notable for a device-state-reading tool.

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

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

Two sentences, both earning their place: the first states the purpose, the second highlights the efficient benefit (no page-source parsing). It is front-loaded and compact, though the second sentence edges slightly toward marketing language rather than hard functional 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?

For a simple single-parameter read tool with no output schema, the description provides the core value proposition (returning URL string without parsing source). It could be more complete about edge cases (no Chrome running, multiple tabs), but given the low complexity and that this is a straightforward getter operating within a larger device tool family, it's reasonably complete. There are related siblings (ios_get_browser_url, device_page_source) but the description's differentiation is adequate.

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

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

Schema description coverage is 100% (udid is documented as 'Device serial number (UDID)'). With full coverage, baseline is 3, but the description's note about needing the device's UDID to target a specific Android device adds useful context beyond the schema. The description doesn't add format/syntax details but doesn't need to given the single, self-explanatory 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?

Description uses a specific verb+resource: 'Get the current URL loaded in Chrome on an Android device.' It clearly identifies the resource (Chrome browser on Android) and the action (get URL). It distinguishes well from siblings like device_page_source (full source) and device_navigate_url (navigation), and relates to ios_get_browser_url as the Android counterpart. However, it doesn't explicitly name these siblings as alternatives.

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 notes 'without needing to parse page source,' which implies it's a lighter-weight alternative to device_page_source for URL extraction. It implies the context (when you just need the URL, not the full page source) but doesn't explicitly state when NOT to use it, such as when the target is a different browser or a WebView within an app rather than Chrome.

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

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

No annotations are provided, so the description carries the full burden. It discloses the key behavioral insight about coordinate systems (physical pixels matching page_source bounds) which is genuinely useful beyond what the schema shows. However, it doesn't mention return format, whether it's read-only (safe), or any side effects. The coordinate insight is valuable context but the behavioral profile is partially 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?

Two sentences, both high-value. The first states the purpose; the second delivers the critical coordinate-system context that links this tool to gesture tools. No filler, no redundancy. This is an exemplary concise description.

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

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

Given a read-only info tool with one well-documented parameter and no output schema, the description covers the essential aspects: what it returns (detailed info, screen size), why it matters (physical pixel coordinates for gestures), and how it relates to page_source bounds. The coordinate guidance fills a potential knowledge gap. It could arguably benefit from a note about output structure, but the no-output-schema context lowers that burden.

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

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

Schema description coverage is 100% (the udid parameter is documented as 'Device serial number (UDID)'). The description adds no additional parameter-specific meaning beyond schema, so the baseline 3 applies. The udid parameter is self-explanatory given the sibling tool family and general device tool context.

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

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

The description clearly states it gets detailed device info including physical screen size. It distinguishes from siblings like ios_device_info, device_battery, device_network_info by focusing on general device info and specifically calling out the physical screen size relevance to coordinate systems. However, it doesn't fully enumerate what 'detailed info' includes beyond screen size.

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

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

The description provides clear context on when this matters: device_tap/device_swipe use physical pixel coordinates, so retrieving device info (screen size) is relevant before gesture operations. This implicitly guides the agent to fetch this before performing coordinate-based interactions. It doesn't name an alternative tool explicitly, but the coordinate guidance is actionable context.

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

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

No annotations are provided, so the description carries the full burden. It excels here by disclosing the routing behavior (control channel vs shell), the fallback mechanism, and the special handling for system-policy keys. This is rich behavioral context that an agent needs to understand execution nuances.

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 concise and information-dense, packing key purpose, accepted values, and routing behavior into a compact block. It's front-loaded with the core purpose. Slightly verbose on the routing explanation, but every clause earns its place given the complexity of the 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 2-parameter tool with no output schema, this description is quite complete. It covers accepted values, routing behavior, and fallback logic. It could mention what happens on failure or what the return value is, but the behavioral coverage is strong. The description is adequate for an agent to select and invoke correctly.

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

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

While schema coverage is 100% and both parameters are described in the schema, the description adds value by clarifying the keycode parameter's dual nature (numeric OR named) and listing the specific accepted named keys. It also explains the behavioral difference between system-policy and regular keys, which adds meaning beyond the schema's simple type definitions.

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

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

The description clearly states the tool's function: 'Send a keycode to a device' with specific verb+resource. It distinguishes itself from siblings like device_tap/device_swipe by focusing on keycodes. However, it doesn't explicitly differentiate from ios_key_hid or webpage_press_key, relying on the 'device' prefix for context.

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

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

The description provides explicit guidance on when to use this tool: it explains that system-policy keys always go through shell, while other keys try the control channel first with fallback behavior. It also lists the accepted key names, giving concrete usage direction. This is strong behavioral guidance beyond what the schema provides.

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