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, the description fully carries the transparency burden. It discloses that scroll:true changes the screen and does not scroll back, triggers loading on lazy lists, only examines drawn elements, cannot observe ancestor-touch-dispatched tap areas, and tap-target results are a screening signal not a verdict. It also states exactly what each finding contains (label, class, pixel rect). No behavioral surprises are left hidden.

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 earns its place. It is front-loaded with the core purpose, then logically progresses through what findings look like, how to use scroll, and important limits. The structure (purpose → usage → findings → boundaries) makes the length feel necessary and well-organized, not 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?

For a complex audit tool with no output schema, the description is exceptionally complete. It describes the return value (findings with label, class, pixel rect), how to act on it (rect center is tappable), what checks are included, what limitations exist, and what is intentionally not covered (contrast, text-size). An agent can confidently decide to invoke this tool and correctly interpret its 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?

Although schema coverage is 100%, the description adds substantial meaning beyond parameter names and types. It explains what each check actually detects (e.g., DuplicateClickableBounds = 'screen reader announces the same thing twice'), gives concrete examples, and explains the side effects of scroll:true and the meaning of localeIsEnglish. This significantly enriches the schema's terse enum descriptions.

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

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

The description opens with a clear verb+resource: 'Run an accessibility audit on the CURRENT screen of an Android device.' It immediately distinguishes this tool from its iOS sibling and names the device platform. It also aligns with Google's Accessibility Scanner rules, giving a concrete, recognizable 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?

Explicitly states a prerequisite: navigate to the desired screen first via device_tap_by_text or device_launch_app. It also instructs when to use scroll:true ('to cover content below the fold') and when not to ('Leave it off when the app must not be disturbed'). Limitations explicitly say what this tool does NOT do (contrast/text-size), steering users away from inappropriate use.

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 describes what data is returned (tag, text, attributes, bounding box, visibility, locators) and explains the locator fields in detail. However, it does not explicitly state that the operation is read-only or non-destructive, which is important for an extraction tool. The description is partially transparent but misses a definitive statement about side effects.

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

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

The description is well-structured: it opens with the primary purpose and high-level return data, then dives into the locator field details, usage warnings, the `includeStyles` option, and the `pageId` auto-select. While dense, every sentence adds value. It could be slightly more concise by separating output format details from usage guidance, but it is efficient and logically ordered.

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 has no output schema, the description does a good job of conveying what the agent can expect: for each element, it lists the fields (tag, trimmed text, key attributes, classes, bounding box {x,y,w,h}, visibility flag) and explains the locator fields (`suggested`, `playwright`, `css`, `xpath`) in depth. It also covers the default element selection (interactive/meaningful) and the `includeStyles` option. It lacks explicit statement about the return format (e.g., an array of objects) and does not describe pagination behavior beyond the limit parameter. Still, it is fairly complete for a complex 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% (all 6 parameters have descriptions), so the baseline is 3. The description adds minimal value beyond the schema: it clarifies that omitting `pageId` auto-selects the active page, but does not elaborate on defaults (e.g., `limit` default of 150 is not stated). The locator output explanation is not directly about parameters. Overall, the description does not significantly enhance parameter understanding 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 clearly states the tool extracts 'locator-friendly element data from a page on the device for building Playwright/Selenium locators.' It specifies the verb (extract) and the resource (element data). However, it does not explicitly differentiate from sibling tools like `device_locators_for` or `ios_safari_elements`, which could share similar purposes. The purpose is clear and specific but lacks sibling distinction.

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 actionable guidance on how to use the output: it directs users to prefer the `suggested` locator over `css`/`xpath`, explains what to do when `suggested` is null, and advises omitting `pageId` for auto-selection. This helps the agent interpret results correctly. However, it does not offer when-to-use or when-not-to-use guidance relative to other element extraction tools, which keeps it from a 5.

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

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

With no annotations, the description carries the full burden. It discloses that enabling Runtime is a side effect, that results include pageId/pageUrl to catch wrong-page execution, and that omitting pageId auto-selects the active tab with a navigation-specific behavior. This is rich behavioral context, though it doesn't address potential error conditions or side effects of the JS execution itself.

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, front-loaded with the core purpose, and each sentence adds value—purpose, return behavior, and pageId auto-selection. 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?

There is no output schema, but the description covers the key return fields (result, exception details, pageId/pageUrl) and the wrong-page caveat. It could be more complete with error cases or prerequisites, but for a 6-param tool with 100% schema coverage, it provides enough context for an agent to use it correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minor extra context for pageId (auto-select after navigate), but does not add meaningful semantics for other parameters like awaitPromise or returnByValue beyond what the schema already states.

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

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

The description clearly states it evaluates a JavaScript expression in the context of a page on the device via CDP, with a specific verb and resource. It distinguishes itself from sibling tools by mentioning the CDP mechanism, the Runtime enablement, and the return of pageId/pageUrl to identify the actual target tab.

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

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

It provides clear context: use this to evaluate JS in a page on an Android device, and it explains how pageId selection works (auto-selecting the active tab, especially after a navigate). It does not explicitly mention alternatives, but the context and name make the intended use 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 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?

The description discloses important behavioral nuances not visible in annotations (which are absent): it explains the meaning of 'active: true' as the default target for other tools when pageId is omitted, clarifies that 'visible' is a WebView-only hint and null for ordinary browser tabs (with tested evidence), and warns that stale tabs accumulate across sessions. These are non-obvious behavioral traits that materially affect how the agent should use the output.

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 highly efficient: every sentence carries meaningful information, covering purpose, output format, key field semantics, usage caveats, and cleanup recommendation in just a few lines. It is front-loaded with the core function and then provides critical details without redundancy or filler.

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

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

Given the tool's moderate complexity, the absence of annotations, and the absence of an output schema, the description is exceptionally complete. It explains the return fields, the ordering (newest-active first), the semantic meaning of 'active' and 'visible', the default resolution behavior of sibling tools, and the recommended follow-up action for stale tabs. This is more than sufficient for an agent to use the tool correctly.

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

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

Schema description coverage is 100% with both parameters (udid and socket) documented in the schema. The description does not add much beyond the schema for these parameters; the richness of the description is focused on output semantics and usage guidance instead. Since the schema already covers parameter meaning, a 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 tool lists debuggable pages/targets on a device and specifies the exact fields returned (id, type, title, url, active, visible). It immediately distinguishes itself from sibling tools by using the specific verb 'list' and the resource 'pages/targets', and further differentiates from related tools like android_devtools_close_page and ios_safari_list_pages.

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 practical usage guidance: it explains when you do NOT need to use this tool (acting on the current tab, omit pageId) and when you DO need it (acting on a different tab). It also directs handling of stale tabs by referencing android_devtools_close_page as the cleanup tool. This goes beyond basic context and includes specific exclusions and 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?

With no annotations, the description fully covers behavioral traits: modes (mock/abort), effect scope (web content only, no device-wide change, no certificate installed), immediacy, navigation survival, and the idle field recommendation. No contradictions.

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?

All sentences are valuable and front-loaded. The description starts with the core action and then efficiently adds critical distinctions (update capability, modes, scope, native app alternative) without redundancy. Appropriate length for 14 parameters.

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

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

For a complex tool with 14 parameters, no output schema, and no annotations, the description covers purpose, scope, modes, parameter usage, and alternatives thoroughly. Minor omission: no explicit mention of what the tool returns (e.g., route ID) but this is acceptable given lack of output schema requirement.

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%, the description adds substantial context for many parameters: id for update, mode differences, pageId recommendation, bodyEncoding base64, headers iOS charset caveat, delayMs clamping, matchType defaults. This far exceeds 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 it adds or updates a mock/abort rule for Chrome/WebView requests on the device. It distinguishes from sibling tools like android_traffic_mock_add (for native code) and other platform-specific mock tools, and notes the scope is web content only.

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 (for browser/WebView requests) and when not (native app code), directs to android_traffic_mock_add as alternative, and explains the update behavior when id matches an existing route.

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?

With no annotations provided, the description carries the full burden and does so excellently. It discloses the wait behavior with waitMs, the conditional return of finalUrl for redirects, auto-selection of the visible page when pageId is omitted, and the side effect of setting the current page for subsequent tools. This goes well beyond a basic 'navigate' statement.

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

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

The description is somewhat long but every sentence adds value: purpose, wait behavior, return fields, page selection, and side effects. It is front-loaded with the main action and structurally organized. It earns a 4 rather than a 5 due to its density, though there is no wasted text.

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

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

There is no output schema, so the description's detailed explanation of return values (url, finalUrl, loaderId, errorText, frameStoppedLoading) is essential and provided. It also covers timing behavior, page selection, and the current-page side effect, making it complete for a tool of this complexity.

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 meaningful semantics beyond the schema: it explains that omitting pageId auto-selects the visible page, that waitMs controls waiting for frameStoppedLoading, and it details the return values, which is valuable given no output schema.

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

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

The description starts with a specific verb and resource: 'Navigate a page running on the device to a URL via CDP (Page.navigate)'. This clearly states what the tool does and distinguishes it from other android_devtools_* tools by detailing the navigation action, wait option, and page selection behavior.

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

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

It provides clear usage context, especially the note about calling other android_devtools_* tools without pageId after success, avoiding a list_pages round trip. However, it does not explicitly mention alternatives like device_navigate_url or when NOT to use this tool, so it falls slightly 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 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, the description carries the full burden, and it does well: it reveals that the image is captured at physical resolution, never downscaled, and pixel positions match device_tap coords, plus image-only returns to keep the call fast. It also implies the prerequisite that the stream must already be running. However, it does not explicitly state what happens if the stream is not running or the output encoding, but it covers the key behavioral tradeoffs.

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 moderately sized but front-loaded with 'PREFERRED fast screenshot' and every sentence adds distinct value: performance rationale, resolution invariance, and alternative guidance. It is not overly verbose, though it could be slightly tightened. It earns a 4, not a 5, because there is some redundancy around 'faster' and 'fast' and the 'PREFERRED' emphasis is repeated thematically.

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 has only one parameter, no output schema, and no annotations, the description effectively covers the essential context: what it returns (a JPEG frame), the resolution guarantee, and when to use the alternative. It does not specify the exact return representation (e.g., base64 vs binary) or error behavior if the stream is not running, which would make it fully complete, but it is quite thorough for a simple screenshot 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 already fully documents the single parameter 'udid' with 'Device serial number (UDID)' (100% coverage). The description does not add any extra meaning beyond that, so the baseline of 3 is appropriate; the schema is sufficient.

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 explicitly says 'PREFERRED fast screenshot of an Android device via the ALREADY-RUNNING shared video stream' and 'Returns a single JPEG frame decoded from the live video stream — no fresh full-resolution screen grab is spawned.' This clearly identifies the specific verb (screenshot), resource (Android device), and mechanism (video stream), and distinguishes it from device_screenshot. The 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?

It gives direct usage direction: 'Use this for routine per-action screen checks; it is much faster than device_screenshot, so make it your default for iterating on a flow.' It also explicitly reserves device_screenshot for cases needing 'the bundled labeled-elements list or a full-fidelity image.' This is an explicit when-to-use and when-not-to-use with a named alternative.

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?

With no annotations, the description carries the full burden. It discloses that flows are decrypted, bodies are truncated, and it returns the most recent limit flows. It also mentions the 'snapshot' nature. Missing details like what happens if capture isn't started, but the prerequisite is implied. Overall, strong behavioral context 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?

The description is three sentences, front-loaded with the core purpose, then details output fields and configurable options. Every sentence adds value, with no redundancy or fluff.

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 is no output schema, the description lists the returned flow fields (method, url, host, status, etc.) and explains filtering and body inclusion. It implies the need to call android_traffic_start but doesn't explicitly state 'call this first.' The sibling list and tool name partially compensate. Overall, it is quite complete for an agent to 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?

Schema description coverage is 100%, so the parameters are fully documented. The description adds only minor clarifications, such as 'truncated' for bodies and the filtering intent, but the schema already explains parameter meanings (e.g., onlyErrors as '5xx / connection-error flows', includeBodies as 'bodies capped at 32000 chars'). 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 names the tool's function: 'Snapshot recent DECRYPTED HTTPS flows (request/response)' with a specific verb and resource. It identifies key output fields (method, URL, status, sizes, duration) and distinguishes itself from sibling tools like android_traffic_status or android_devtools_capture_network by focusing on captured HTTPS flows since a start event.

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: it must be used after android_traffic_start, and explains configuration options (includeBodies, urlSubstring, onlyErrors). It does not explicitly mention when to choose this over alternatives like android_devtools_capture_network, but the 'since android_traffic_start' dependency implies the intended workflow.

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

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

With no annotations, the description carries full burden and discloses key behaviors: requests never reach the server, mock vs abort modes, live per-device storage without restart, and the pinned-app limitation. This is notably transparent for a state-changing proxy 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 well-structured sentences: core function, mode explanation, then prerequisites/limits. Every sentence adds valuable information without redundancy or fluff.

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

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

For a complex 12-parameter tool without an output schema, the description covers the main behaviors, prerequisites, and limitations. Missing return value info and potential error conditions, but the overall context is strong.

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 semantic context for mode/status/headers/body by explaining mock vs abort behavior, and clarifies id-based update-in-place, going 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 clearly states the tool's action (add or update in place), resource (mock/abort rule), and context (TLS-inspecting proxy for device HTTPS traffic). It distinguishes from sibling list/remove tools by detailing the short-circuiting behavior and update 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?

Provides a clear prerequisite (requires TLS capture via android_traffic_start) and a limitation (pinned apps won't be intercepted), giving context for when this tool is appropriate. However, it doesn't explicitly name alternative mocking tools or state when not to use it beyond the pinned-app case.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It accurately describes a listing operation, which implies non-destructiveness, but does not mention side effects, device connection requirements, or behavior if 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?

The description is a single sentence that is concise and front-loaded, with a useful pointer to the add tool. There is no redundant or unnecessary 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?

For a simple listing tool with one documented parameter and no output schema, the description sufficiently covers purpose and scope. It could provide more detail on what 'mock/abort routes' entails, but overall it is complete for the tool's simplicity.

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 only parameter, 'serial,' is fully described in the schema as 'Android device serial (adb serial)' (100% coverage). The description adds no additional semantic value 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 the specific verb 'List' and names the resource 'mock/abort routes,' clearly indicating a read-only inspection tool. It also references the sibling 'add' tool, helping to distinguish its role as a query 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 implies the tool is for viewing currently configured routes, and the cross-reference to android_traffic_mock_add provides context, but it does not explicitly state when to use this tool versus alternatives like remove or status.

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

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

With no annotations, the description must carry the burden of disclosing behavioral traits. It states the side effect (removal) and return value (resulting route list), which is essential. However, it does not mention error behavior (e.g., invalid id, no routes configured) or whether removal affects ongoing traffic. This is a basic disclosure, not deeply informative. It does not contradict any annotations since there are none.

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-structured sentence that front-loads the primary action and uses backticks for parameters. It contains zero filler or redundant information. Every word contributes to understanding the tool's purpose, conditionally, and return 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 a simple removal operation, and the description covers the core behavior (removal scoping) and return value (resulting list). The schema covers all parameters, and the description references id sources indirectly through schema descriptions. For a low-complexity tool without an output schema, this is nearly complete; the only missing element is explicit error/edge-case handling, which is non-critical for selection and invocation in most scenarios.

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 (id, all, serial) having a clear description. The tool description adds minimal semantic value beyond the schema—it reiterates 'by id' and 'when all is true' but does not explain parameter syntax, precedence rules, or edge cases. Per the rubric, baseline 3 applies when schema does the heavy lifting, and the description does not notably exceed that.

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: removing one mock/abort route by id or all routes on a device. It uses a specific verb ('Remove') and resource ('mock/abort route'), and distinguishes itself from siblings by mentioning the 'all' flag and resulting route list. This is unambiguous and differentiates from related tools like android_traffic_mock_add or android_traffic_mock_list.

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 clearly conveys when to use the tool (removing one specific route by id or clearing all routes via 'all=true'). It does not explicitly compare with alternatives, but the id reference to android_traffic_mock_add/list in the schema and the self-contained behavior give adequate usage context. A slight deduction for not explicitly stating when not to use it (e.g., if only a subset of routes needs removal) or clarifying relationship with list/add tools in the main description.

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

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

With no annotations, the description carries full behavioral disclosure. It explains the proxy setup, silent CA installation in DPC mode, fallback to manual adb proxy, and prerequisites around certificate trust. It does not explicitly state that device network settings are modified, but this is strongly implied by 'points the device at it' and the mention of an adb global proxy.

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 detailed but front-loaded with the primary action, then explains modes, prerequisites, and limitations. Every sentence adds value, though it is longer than necessary; it could be tightened slightly without losing important information.

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

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

Given the tool's complexity (proxy setup, CA installation, fallback modes, prerequisites, and limitations) and the absence of an output schema, the description covers all essential context: what it does, how it behaves in different modes, requirements for success, and next steps. It is complete for an agent to decide and invoke the tool correctly.

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

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

The single parameter 'serial' is fully described in the schema as 'Android device serial (adb serial)', providing 100% coverage. The description adds no additional information about the parameter beyond identifying the device as Android, 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 tool's purpose: starting TLS inspection on an Android device by bringing up a proxy and pointing the device at it. It distinguishes itself from Chrome DevTools by noting it works for native apps, and the scope (per-device) is explicit.

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

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

The description provides clear context on when to use this tool (to decrypt/capture HTTPS traffic for native apps) and mentions an alternative (Chrome DevTools) by contrast. It also outlines the workflow of driving the app and reading flows with android_traffic_flows. However, it does not explicitly list scenarios where this tool should NOT be used beyond the certificate-pinning limitation.

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 contents of the report and implies a read-only operation ('report'), but it does not explicitly state that it has no side effects, or mention prerequisites (e.g., device connection, existing traffic session), or describe error/edge-case behavior. It provides some context but not deep behavioral 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 a single sentence that immediately states the tool's purpose and enumerates the three report components. There is no wasted wording, repetition, or tangential information; every phrase 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 simple, but without an output schema the description must convey return information. It lists the three components (TLS inspection running, proxy mode, buffered flow count) but does not specify their format (e.g., booleans vs strings) or any prerequisites/relationship to traffic start/stop. It is minimally adequate but leaves gaps in expecting an agent to understand the full response structure.

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 covers the only parameter, 'serial', with a clear description ('Android device serial (adb serial)') at 100% coverage. The description does not add any extra meaning about the parameter, so it does not exceed the schema baseline. A score of 3 is appropriate given the high 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 uses the specific verb 'report' and identifies the resource (TLS inspection status for an Android device) with three distinct output elements: running status, proxy mode (dpc/manual), and buffered flow count. This makes it clearly distinguishable from sibling tools like android_traffic_start/stop (which control traffic) and android_traffic_flows (which likely list flows).

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 clearly conveys that this is a status/read tool and implies it complements the traffic start/stop tools, but it does not explicitly name alternatives or state when not to use it. The context is clear enough for an agent to infer its role among the siblings, but explicit exclusions are missing.

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 thoroughly explains conditional side effects (leaving proxy and DPC CA running for other consumers), return behavior (stillRunning: true), and full cleanup only when all consumers stop. This is rich, transparent context beyond basic function.

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 long and each sentence carries meaningful information without fluff. While slightly longer than the minimal two-sentence ideal, the multi-consumer complexity justifies the length. It is well-structured, starting with the core action and then explaining conditional outcomes.

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 stop operation with multi-consumer semantics, the description covers the essential behavioral outcomes and even hints at response content (stillRunning). It could mention error cases (e.g., no active capture) but given the simple schema and no output schema, it is quite complete for the tool's purpose.

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 input schema already provides 100% coverage for the single 'serial' parameter with a clear description. The tool description does not add new information about parameters, so the baseline of 3 is appropriate; the schema does the heavy lifting.

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

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

The description clearly states the specific function: 'Stop TLS inspection for an Android device' with a precise verb and resource. It also distinguishes the scope ('from THIS (AI) consumer only') and differentiates from siblings like android_traffic_start and ios_traffic_stop by referencing Android TLS inspection.

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 the tool (to stop this AI's TLS inspection on a device) and includes a detailed multi-consumer caveat. It doesn't explicitly name alternatives like android_traffic_start or android_traffic_status, but the intended usage is inferred through the consumer-only scope and sibling 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 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?

With no annotations provided, the description carries full behavioral disclosure. It clearly states the tool only formats a URL, does not validate the run, uses a relative path routed internally, and produces a markdown link. This is complete for a simple, non-mutating helper.

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 contributing essential information: output behavior, example format, routing context, usage timing, and prerequisite caveat. The description is front-loaded with the core purpose and contains no filler.

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

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

For a one-parameter, no-output-schema tool, the description is fully sufficient. It covers the output format, example, path behavior, when to use it, and a clear prerequisite. An agent has everything needed to invoke it correctly.

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

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

The schema describes sessionId as 'The run's session id,' and the description adds useful semantics by showing how it appears in the URL (session_id=abc123) and in the markdown link. This goes slightly beyond the schema without being verbose.

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

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

The description states a specific action: build a clickable markdown link to a run's detail page, and includes a concrete output example. It clearly distinguishes itself from run-inspection tools like automation_session_get by clarifying it is only URL formatting.

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

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

It gives explicit when-to-use guidance: offer it after explaining a run so the user can see the video, screenshots, and command list. It also names a prerequisite alternative: call automation_session_get first if the run has not been verified, and explicitly states this tool does not check existence.

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 disclosure burden, and it does so well by explaining that counts are computed server-side over the full period and that breakdowns are chart-ready for ra-chart. It does not define exactly what the default period is or explicitly state that the operation is read-only, leaving minor transparency gaps.

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

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

The description is compact and front-loaded: purpose first, then use-case, then chart mapping, then the default-date tip. Every sentence earns its place with no filler or repetition of schema 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 read-only report with zero required params and no output schema, the description covers return contents, when-to-use, correct computation, and default behavior. It could be more complete by defining the default date period and giving a sense of the response shape, but overall an agent can invoke and interpret this tool correctly.

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

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

Schema coverage is 100%, and the schema already documents all four optional parameters with formats and inclusive window semantics. The description adds only the default-period behavior and the date-range context, so it stays at the baseline rather than materially enhancing 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?

The definition states a specific deliverable: pre-aggregated automation statistics over a date range with counts, pass rate, and platform/device breakdowns. It also distinguishes itself from the sibling automation_sessions_list by explicitly saying it is the correct source for any chart or total, so an agent can tell them apart.

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

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

It gives an explicit when-to-use directive ('USE THIS FOR ANY CHART OR TOTAL'), names the alternative (automation_sessions_list), and explains why row tallying would be wrong because it would silently cover only the recent window. It also instructs the agent to omit dates for the default period, which is concrete invocation 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 burden and succeeds: it discloses output summarisation and capping, the whyNoFailedSteps edge case, per-step error messages, locator provenance, behavior on still-running runs, and the fact that limit returns the last n steps. This is unusually rich behavioral disclosure.

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

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

The description is long but every sentence earns its place: it front-loads the core purpose, then covers edge cases, parameter guidance, and sibling routing without redundant filler. Dense, well-ordered, and highly informative rather than 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?

For a debugging-history tool with no output schema, the description fully covers what the tool returns, how to handle empty results, running runs, follow-up tools, and when to drill into a single step. Nothing an agent needs to correctly select and invoke this tool 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?

Although schema coverage is 100%, the description adds significant meaning beyond the schema: failuresOnly is described as the first debugging move, limit is explained as returning the last steps rather than the first, and its interaction with firstFailureIndex and failuresOnly is called out. The description meaningfully augments the parameter 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 first sentence names a specific verb and resource: 'Read the step-by-step command history of a run — every action it performed, in order, with duration and pass/fail per step.' It clearly differentiates from nearby siblings by declaring itself 'THE DEBUGGING TOOL' and pointing to automation_session_get and automation_session_step for adjacent concerns.

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 when-to-use instructions: use failuresOnly=true first when debugging, explains the assertion-failure case, and states when to follow up with session_console_logs / session_network_logs. It also directs when to escalate to automation_session_step for deeper detail, so the agent gets concrete routing among 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?

With no annotations, the description carries the full burden and excels: it explains the verdict/confidence distinction ('reported' is authoritative vs 'inferred' is a guess), instructs how to phrase it ('say so rather than stating it flatly'), warns that stillRunning:true means in-progress and must be reported as such, and discloses the access limitation that another user's session is indistinguishable from a nonexistent one.

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?

Longer than average, yet every sentence earns its place: purpose is front-loaded, followed by trigger conditions, then the behavioral nuances (confidence, stillRunning, access limits) that an agent must know to report correctly. No filler or repetition of schema content.

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

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

For a one-parameter tool with no output schema and no annotations, the description is complete: it enumerates the return contents, defines the semantics of ambiguous values, and covers edge cases (in-progress runs, other users' sessions). Nothing an agent needs to call it correctly 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% — sessionId is documented in the schema with the same /automation?session_id=... source. The description adds marginal context (the agent should recognize a pasted session id as the invocation trigger), but the schema already does the heavy lifting, 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?

States a specific verb and resource — 'Read one finished automation run' — and enumerates the exact data returned (verdict, test, device/browser, capabilities, duration, video/snapshot existence). The singular-scope wording distinguishes it from siblings like automation_sessions_list (plural listing) and automation_session_step (a single step).

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

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

Gives explicit entry conditions: 'START HERE when the user pastes a session id or an /automation?session_id=... link and asks what happened, why it failed, or how it went.' This clearly tells an agent when to reach for this tool, but it does not name alternatives or state when-not-to-use, 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?

With no annotations provided, the description carries the full burden and does substantial work: it reveals server-side filtering across all history, explains that `total` is the true count while `runs` is only one page, clarifies that `search` accepts both short and full session IDs, and notes that `failedOnly` includes inferred failures. It does not cover ordering, response structure beyond `total`/`runs`, or potential rate limits, so it is not a 5, but it is unusually transparent for a list 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 dense but efficient; every sentence earns its place. Use cases are front-loaded, the server-side filtering and pagination semantics are packed into two sentences, and the routing to automation_report is the final punchline. No filler or redundant restatement of the tool name.

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 9 optional parameters and no output schema, the description is nearly complete: it explains what the tool is for, how to locate runs, how pagination works, and when to use an alternative. It does not state the default sort order or mention whether results are newest-first, which would help agents interpret a page of results, but the essential operational knowledge is present.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful semantics beyond the schema: `search` matches both the 8-character UI form and full ID, `offset` is intended to paginate using `total`, `failedOnly` aligns with the tool's own verdict, and `limit`'s default is also the ceiling. This is additive value rather than schema repetition.

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

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

The description opens with a specific verb and resource — 'Find and list your automation runs' — and immediately grounds it in concrete user intents ('how did my tests go', 'what failed recently'). It also differentiates itself from nearby tools by noting it is for locating runs by description rather than by ID, and explicitly routes aggregate stats to automation_report.

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 when-to-use signals with natural-language examples, distinguishes ID-based lookup from described-run lookup, and names the alternative for aggregate pass-rate analysis ('For pass rates and aggregate breakdowns use automation_report'). This is clear routing that leaves little to inference.

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

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

No annotations are provided, so the description carries the full burden, and it delivers: it reveals that element-scoped steps reference an opaque id with an empty body, that networkDuring is browser-only, and that a no-traffic run returns an explicit 'no network captured' signal rather than an empty list that could be misread. This is unusually rich behavioral disclosure.

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

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

The description is dense and somewhat long, but nearly every sentence adds operational value: workflow, locator resolution, and networkDuring edge-case behavior. The emphatic 'THIS IS HOW YOU ANSWER' phrasing is stylistically noisy, but it flags the tool's most important 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 tool with no output schema and no annotations, the description covers the main return values, the required predecessor tool, the special locator-resolution behavior, and an important edge case (no network captured). An agent has enough context to call and correctly interpret 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%, so the schema already documents sessionId, index, and includeNetwork. The description reinforces the index semantics by pointing to automation_session_commands and explains the networkDuring output behavior, but it doesn't need to add additional parameter-level detail.

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

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

The description names a specific verb and resource ('Open ONE step of a run in full') and enumerates what is returned: request body, response body, status, timing, and locator for element-scoped steps. It explicitly contrasts with automation_session_commands, so an agent can distinguish the two tools.

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

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

It provides explicit sequencing: 'Use automation_session_commands first to get the step index, then come here for the step that matters.' It also identifies the special case where this tool is required to answer 'which element?', giving condition-based routing. It doesn't enumerate exclusions, but the guidance is clear enough for correct 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?

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.