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 only mentions the 'stop' argument's side effect of ending capture, but does not disclose whether reading is destructive, whether a capture must be active, or what happens if the buffer is empty. This is minimal transparency for a tool with no annotation safety hints.

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 very concise, with a clear purpose sentence and a single argument note. It is front-loaded with the core action and contains no fluff. Every word adds value, making it an excellent example of conciseness.

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

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

For a tool with six parameters, no annotations, and an output schema present, the description is far too brief. It omits preconditions (e.g., capture must be started), parameter semantics for most fields, and any behavioral details beyond the stop flag. This makes it incomplete for reliable invocation.

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

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

Schema coverage is 0%, so the description must explain parameters. It explicitly covers only 'stop', while 'tag', 'limit', 'package', 'contains', and 'min_level' are implied via 'same filters as read_logs'. This indirect reference is not sufficient for an agent that may not know read_logs' schema, leaving most parameters underdocumented.

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 ('Query') and resource ('background capture buffer'), making the purpose clear. Referencing read_logs for filters helps distinguish it from reading live logs, though it doesn't explicitly contrast with read_logs or other siblings. This is a clear but not fully differentiated description.

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 that the tool is used when you want to read from a capture buffer, but it doesn't explicitly state when to choose this over read_logs or capture_start. No alternatives are mentioned, and the 'same filters as read_logs' comment only suggests similarity. The usage context is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It discloses that recording happens in the background, that it survives log rotation, and that it captures everything including verbose output. It doesn't mention how long the buffer lasts or whether it overwrites, but the key behavioral traits are disclosed.

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

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

The description is compact and front-loaded: the first sentence states the action, the second provides usage context and workflow. Every sentence 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 description covers the tool's purpose, workflow, and key differentiator. It doesn't explain return values, but an output schema exists. It doesn't mention buffer limits or lifecycle, but the core usage context is complete enough for an agent 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?

Schema description coverage is 0%, so the description must compensate. It doesn't explain the 'label' or 'serial' parameters at all. However, both parameters are optional with defaults, and the tool's core behavior is clear. The description adds no parameter-level meaning, so a baseline 3 is appropriate given the low 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 the action ('Begin recording logcat into a background ring buffer') and distinguishes it from read_logs by noting it survives log rotation and captures verbose output. This is a specific verb+resource combination that differentiates it from 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 explicitly says when to use it ('when the user is about to reproduce a bug'), provides a workflow (start capture, reproduce, then query with capture_read), and contrasts with read_logs. This gives clear guidance on when to use this tool versus alternatives.

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

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

No annotations are provided, so the description carries the full burden. It does disclose two concrete behaviors: stopping the capture and releasing the adb process. However, it does not mention what happens if no capture is active, whether the operation is idempotent, or what the output looks like.

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 efficient sentence with no redundant words. It front-loads the primary action and includes the key side effect, making every word useful.

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 no-parameter stop operation, the description provides the essential information: what is stopped and what resource is released. The presence of an output schema reduces the need to describe return values, though slightly more context about the expected state before calling this tool would improve completeness.

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 accepts zero parameters and the schema coverage is complete, so there is no parameter ambiguity for the description to clarify. With no parameters, the baseline is 4 and no additional semantic explanation is 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 uses a specific verb ('stop') and a clear resource ('background logcat capture'), while also specifying the side effect of releasing the adb process. This clearly distinguishes it from sibling tools like capture_start and capture_read.

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 as the counterpart to starting a background logcat capture, but it does not explicitly state when to use this tool versus alternatives or mention any preconditions. The context of 'background logcat capture' gives enough signal for an agent to infer its purpose, though exclusions are absent.

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 disclose behavioral traits. It states 'clear' which implies a destructive action, but it doesn't warn about irreversibility, potential impact on multiple devices (since serial is optional and defaults to null), or any permission requirements. The description is too terse to convey the full behavioral scope.

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 plus a clause, with no wasted words. The main action is front-loaded and the usage hint follows naturally. It is efficiently 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?

The tool has an output schema (not described) and a single optional parameter. The description does not explain the output, the parameter, or the scope of the operation (e.g., whether null serial clears all devices or the current device). For a tool with no annotations, this is under-specified. An agent would need to infer too much.

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 has one parameter 'serial' with 0% description coverage. The description does not mention this parameter at all, leaving the agent without guidance on whether it's required, what it does, or the effect of the default null value. Since the description carries the full burden for parameter semantics, this is a significant gap.

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

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

The description clearly states the action ('Clear all logcat buffers') with a specific verb and resource. It distinguishes itself from sibling tools like read_logs and find_crashes by focusing on the clearing operation. The purpose 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?

The description provides explicit context: 'Do this before reproducing a bug so logs stay clean.' This gives clear guidance on when to use the tool. It doesn't explicitly mention alternatives or when not to use it, but the context is strong enough for an agent to infer appropriate usage.

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

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

No annotations exist, so the description carries the behavioral burden. The verb 'Report' implies a read-only query with no destructive side effects, and the listed output fields are a form of behavioral disclosure. However, it does not mention prerequisites (e.g., connected device), what happens if the foreground activity is unavailable, or how serial affects the query.

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

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

It is a single front-loaded sentence with zero filler. Every word adds meaning and the size is appropriate for the tool's surface area.

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

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

An output schema likely documents return values, so the four reported fields suffice. The notable gap is the undocumented serial parameter and the absence of any context on how to target a specific device, which makes the description incomplete for a parameterized tool.

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

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

Schema description coverage is 0%, so the description needed to compensate, but it never mentions the serial parameter at all. An agent cannot tell what value to pass, whether it selects a device, or why it defaults to null.

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 concrete action ('Report') and a specific resource (device info), enumerating four exact data points: screen size, density, Android version, and foreground activity. This is enough to distinguish it from sibling commands like list_devices or screenshot without opening any structured 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?

No explicit when-to-use or when-not-to-use guidance is provided, and the optional serial parameter is never explained. Usage is only implied by the tool's name and output list, rather than stated 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, the description carries the full behavioral burden. It does disclose the output ('whole stack traces') and the data source ('crash buffer'), making the extraction appear non-destructive, but it does not explicitly state whether reading affects the buffer or whether special permissions are needed. It is acceptable 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?

One functional sentence plus a compact, well-organized Args block with no filler. Every sentence earns its place and the most important information 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 straightforward read tool, the description covers purpose, source, output, and all parameters; the output schema further covers return structure. It could add an explicit note about no side effects or when to use alternatives, but nothing necessary for a basic invocation 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 description coverage is 0%, so the description must define all three parameters, and it does: package restricts matching traces, limit controls trace count, and serial disambiguates devices. This adds real semantic value over the bare property names and types.

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

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

The opening sentence names a specific verb ('extract'), a specific resource ('recent crashes and ANRs'), and the source ('the crash buffer'), which clearly distinguishes it from siblings like read_logs or clear_logs. This is more than a tautology and gives an agent a precise idea of the tool's 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 behavior description implies the tool is for retrieving crash/ANR stack traces, but it never explicitly says when to prefer it over read_logs or capture_* tools, nor does it mention exclusions. This is adequate as an implied usage signal but lacks explicit routing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does disclose a key behavioral trait: without attaching, hot reload is impossible because the VM Service lacks a Dart compiler. However, it does not describe operational side effects such as whether the attach command persists, whether it can fail if no app is running, or what the user should expect while attached.

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, stating the core action in the first sentence. The supporting explanation and parameter list each earn their place without filler. It is structured for quick agent scanning.

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

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

The tool has a small parameter set and an output schema, so the description does not need to explain return values. It covers purpose, when to use it, and both parameters. It would be more complete with notes on failure modes, such as what happens if no running app is found or if attach is called when already attached.

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

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

Schema description coverage is 0%, but the description fully compensates. It defines project_dir as "the Flutter project root, the directory holding pubspec.yaml" and serial as "device serial when several are attached." Both parameters are given meaningful, actionable semantics that go well beyond the raw JSON 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 opens with a specific verb and resource: "Attach the Flutter tool to the running app so hot reload becomes possible." It clearly differentiates the tool from flutter_hot_reload by stating it is a necessary precondition, and explains the underlying reason (VM Service has no Dart compiler). This makes the tool's purpose unambiguous even among many sibling Flutter 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 explicitly states when to use the tool: "Needed once per session before flutter_hot_reload". It gives clear context about the prerequisite and the consequence of skipping it. However, it does not provide explicit when-not-to-use guidance or name alternatives such as flutter_connect, so it falls just short of a 5.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses that relaunch 'force-stop[s] and restart[s] the app,' that the VM Service URI is only emitted at launch, and that connectivity is limited to debug/profile builds. It does not cover connection lifecycle (e.g., whether flutter_detach is required), but the main side effects and constraints are 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?

The description is tight and front-loaded: the core action and 'call this first' come in the opening sentence, followed by a short context paragraph and a compact Args list. No sentence is redundant.

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

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

Given that annotations are absent and the schema carries no descriptions, the tool definition supplies the necessary prerequisites (logcat-only URI, debug/profile builds), the optional relaunch behavior, and parameter semantics. An output schema exists, so omitting return-value details is acceptable; the only minor gap is not explaining what later tools require this connection.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: package is explained as 'application id, needed for relaunch,' relaunch as 'force-stop and restart the app to capture a fresh URI,' and serial as 'device serial when several are attached.' Each parameter's purpose and condition is clearer than the bare schema.

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

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

The description uses the specific verb 'Connect' with a defined resource, 'a running Flutter app's Dart VM Service,' and adds the sequencing instruction 'Call this first.' It does not explicitly distinguish itself from the sibling tool flutter_attach, so it falls short of the highest bar, but the target and action are 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 explicit context: the URI appears only in logcat at launch and only for debug/profile builds, and relaunch=True is the workaround when it has scrolled out of the buffer. This explains when the optional destructive path should be taken, though it does not name alternatives such as flutter_attach or state when not to use this 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?

No annotations are present, so the description carries the behavioral burden. It explicitly discloses the important side effect that ending the session does not terminate the app, which is the main behavior an agent must know before calling it.

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

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

One sentence with no filler. The core action and the distinguishing side effect are both front-loaded and each 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?

For a no-parameter, simple operation with an output schema present, this description covers the action and the key non-destructive side effect. Nothing needed to invoke 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?

The tool has zero parameters and schema coverage is 100%, so there is nothing for the description to document. The baseline for a parameterless tool is 4; the description adds no unnecessary parameter 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 operation ('End the attach session') and adds the key qualifier that the app stays running. This clearly distinguishes it from stop_app and other device-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 phrase 'attach session' plus 'leaving the app running' gives agents clear context for when to detach vs stop the app. It doesn't explicitly name alternatives or exclusions, but the usage context is strong enough for a simple no-parameter 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 provided, the description carries the full burden of behavioral disclosure. It describes the core behavior (pulling and ordering both error traces) but does not explicitly state that it is a read-only operation, nor does it mention any side effects, required permissions, or limitations such as what happens when no errors exist. The description gives useful behavioral context but lacks explicit safety or side-effect statements, which is a notable gap without annotation support.

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

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

The description is appropriately sized—two short introductory sentences plus a structured 'Args' block. It front-loads the primary purpose and then explains arguments efficiently. There is no redundant filler, and the structure aids comprehension. It could be slightly tightened, but it is already concise and well-organized.

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 moderately complex (correlates two data sources) and has an output schema, so return values are covered. However, the description does not mention any prerequisites, such as requiring a connected device or an active Flutter session, which are hinted at by the 'serial' parameter and sibling tools like flutter_connect. It also does not discuss edge cases like missing Dart errors or invalid package names. Given no annotations, this leaves some contextual gaps that an agent might need to resolve.

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 0% description coverage, so the description must fully explain the parameters. It does exactly that: it clarifies 'package' as restricting native logs to a specific app, 'limit' as the number of Dart errors to report, and 'serial' as the device serial for multi-device setups. This adds meaningful semantics beyond the bare type and default values, making each parameter's purpose clear.

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 action: correlating Dart-side errors with native Android logs. It explains the scenario and distinguishes itself from sibling tools like read_logs or find_crashes by emphasizing the time-ordered correlation of both trace types. This is unambiguous and gives an agent a precise sense of what the tool accomplishes.

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 usage context: when a Flutter failure leaves two unrelated traces, this tool brings them together. It implies when to use it (for correlating errors with native logs) but does not explicitly name alternatives or state when not to use it. The context is sufficient for an agent to infer applicability, but explicit exclusions would make it stronger.

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 burden. It discloses the prerequisite, the key limitation of plain reloads, and the meaning of full_restart. It does not discuss failure modes or side effects, but it provides substantial behavioral context beyond a bare operation label.

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 well-structured: a one-sentence purpose, a prerequisite, a clear usage caveat, and an args block. Every sentence earns its place, and the most important operational information 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?

Given that an output schema exists, return values do not need explanation. The description covers the prerequisite, the full_restart decision, and the boolean flag. The main gap is that package/serial semantics are delegated to 'elsewhere', and error behavior is not described, but the tool is still usable in a toolset with established conventions.

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 has 0% description coverage, so the description must compensate. It clearly explains full_restart ('hot restart instead of hot reload'), but package and serial are only described as 'as elsewhere', which relies on conventions from other tools rather than defining them here. This is useful but not self-contained.

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 ('Apply Dart source edits') and a specific resource ('the running app'), making the tool's purpose immediately clear. It distinguishes this from sibling tools like flutter_attach (connection) and flutter_diagnose (inspection) by focusing on applying source edits.

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 says 'Requires flutter_attach first', establishing the prerequisite. It also gives concrete guidance on when to use full_restart instead: after changing initState, global state, or main(), which a plain reload cannot pick up. This is strong when-vs-alternative 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 carries full responsibility for behavioral disclosure. It reveals that tap coordinates come from Android's semantics tree and source location from Dart VM Service, and clarifies that the text parameter may match visible text, semantics label, or widget type. It doesn't state preconditions like needing a connected Flutter app, but the mention of Dart VM Service implies an active debug session.

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 first sentence is a sharp summary. The second provides useful context about how the tool works and why it matters. The Args section is compact and clear. Every sentence adds value; 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?

The tool is relatively simple (3 parameters, output schema present) and the description covers the core workflow, input semantics, and the two data sources. It stops short of specifying failure behavior (e.g., no match found) or explicit prerequisites like a prior flutter_connect call, but the intended usage is fully understandable.

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

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

Schema description coverage is 0%, so the description must explain parameters. It effectively explains the required 'text' parameter (visible text, semantics label, or widget type) but passes off package and serial as 'as elsewhere,' relying on external convention. This leaves a gap for an agent that doesn't already know the established device-targeting parameters, though they are relatively self-explanatory.

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 something on screen' and reports both 'how to tap it and where it lives in code.' It goes further by naming the exact data sources (Android semantics tree and Dart VM Service), clearly distinguishing it from Flutter widget tree, UI dump, and tap tools. This is a model of a clear, differentiated 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 gives a concrete scenario: 'go from this looks wrong on screen to the exact line that built it.' This implies when to use the tool, and the bridge metaphor explains why it is different from other UI inspection tools. It does not explicitly mention alternatives or when-not-to-use, but the context is clear enough that an agent can select it appropriately.

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 default filtering behavior, the case-insensitive filter semantics, the max_depth semantics (0 = no limit), and the source-location output format. It doesn't mention performance implications or whether the tree is a snapshot, but for a read-only inspection tool this is solid 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?

The description is compact and front-loaded: the core purpose is in the first sentence, the default filtering behavior in the second, and the output format in the third. The Args section is a tight list with no filler. Every sentence earns its place.

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

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

The tool has 6 parameters, no annotations, and an output schema exists. The description covers the key behavioral parameters and the output format (source location per line). The 'as elsewhere' shorthand for package and serial relies on sibling consistency, which is a minor gap, but overall an agent has enough to call this correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains contains (case-insensitive filter on widget type or description), max_depth (0 for no limit, otherwise prune deeper), limit (max widgets returned), and include_framework (also show framework/third-party widgets). The 'package, serial: as elsewhere' shorthand is terse but acceptable given sibling consistency. This adds real meaning beyond the bare schema.

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

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

The description states a specific verb ('Show') and resource ('live widget tree'), and adds a distinctive detail: each line ends with the file and line that built it. This clearly distinguishes it from siblings like ui_dump or screenshot, which capture UI state or pixels rather than the widget tree with source locations.

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

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

The description explains the default behavior (only own-project widgets shown, framework wrappers are noise) and documents the include_framework flag to opt into framework/third-party widgets. It doesn't explicitly name sibling alternatives or say when not to use this tool, but the context is clear enough for an agent to decide when to use it.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It reveals key constraints: ASCII-only limitation (adb limitation), the need for focus, and the behavior of submit (Enter key) and clear (deletes existing contents). It does not mention error handling or what happens if focus is missing, but the disclosed constraints are important and non-obvious, making this a solid 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 concise and well-structured. The opening sentence immediately states the action and prerequisite, followed by a compact argument list. Every sentence earns its place, and the information is front-loaded. 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?

For a simple text-input tool, the description covers everything needed: usage precondition, parameter semantics, and behavioral limitations. An output schema exists (though not shown) to handle return values, so no further description is needed. The description is complete and self-sufficient.

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

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

Schema coverage is 0%, so the description must compensate, and it does excellently. Each parameter is explained: text (with ASCII limitation), submit (press Enter), clear (delete existing contents), serial (device serial when multiple attached). This adds substantial meaning beyond the raw schema types and defaults, making the tool safe and easy to invoke correctly.

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: 'Type into the focused field.' It specifies the action (typing) and the resource (focused field), and differentiates it from siblings like tap or press_key by focusing on text input. The mention of 'Tap the field first' also implies the necessary precondition, 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 usage guidance: it instructs the agent to tap the field first to ensure focus, and explains the effect of the submit and clear flags. It does not explicitly list alternatives or when-not scenarios, but the prerequisite is explicit and the tool's role is clear given the sibling set. This is sufficient for an agent to know when to use it.

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

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

No annotations are provided, so the description carries the burden. It discloses the clear_data side effect ('wipe the app's data first') and the activity override behavior, which is useful. However, it doesn't mention whether launching is a blocking call, whether it returns immediately, what happens if the app is already running, or any permission requirements. The description adds some behavioral context but not comprehensive transparency.

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

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

The description is compact and front-loaded with the main purpose, followed by a concise parameter list. Every sentence earns its place. The Args section is slightly redundant with the schema but adds semantic value. It could be slightly more structured (e.g., separating the main description from parameter docs), but it's efficient overall.

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 an output schema (not shown in detail) and 4 parameters with 0% schema coverage. The description covers all parameters and the core behavior, but lacks context about return values, error cases (e.g., app not installed), and interaction with siblings like stop_app or flutter_connect. For a launch tool, an agent might need to know if it should check device_info or list_devices first, or how to handle failures. The description is adequate but not 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 description coverage is 0%, so the description must compensate. It does: it explains package as 'application id', activity as 'fully qualified activity to start instead of the launcher entry point', clear_data as 'wipe the app's data first', and serial as 'device serial when several are attached'. This adds real meaning beyond the bare schema titles. The only minor gap is not explaining the default behavior when activity is null (launcher entry point is implied but not explicit).

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 ('Launch') with a clear resource ('an app') and immediately distinguishes the optional clean-state behavior. It names the key parameter (package) and the optional activity override, which differentiates it from sibling tools like stop_app, tap, or swipe. The purpose 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?

The description implies usage context (launching an app, optionally from a clean state) but does not explicitly state when to use this tool versus alternatives. It doesn't mention that stop_app is the inverse, or that flutter_connect/flutter_attach are for Flutter-specific launches. The clean-state hint ('for a true first-run test') gives some context, but no explicit when/when-not guidance.

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

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

No annotations provided, so the description carries the full burden of behavioral disclosure. It mentions the output (state and model) but does not state whether it's read-only, if it requires adb server running, or any other behavioral traits. Minimal disclosure beyond the obvious listing operation.

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

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

Single sentence, front-loaded with the verb and resource, no wasted words. Efficiently conveys 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?

Simple tool with no parameters and an output schema exists. The description covers the essential purpose and output fields. Adequate for a simple listing tool, though it could mention read-only nature or prerequisites, but these are minor gaps given the 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?

Tool has 0 parameters, so schema coverage is trivially 100%. Baseline for 0 params is 4. The description adds no parameter information but none is 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?

States a specific verb 'List', resource 'connected Android devices and emulators', and adds 'with their state and model' clarifying the output. Clear purpose but does not explicitly differentiate from sibling tools like device_info, which may focus on a single device.

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 alternatives. The purpose implies it's for enumerating devices, but there's no context about when to prefer it over sibling tools or any exclusions. Implied usage only.

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 does not state whether the key press is injected into a specific app, whether it requires a foreground activity, whether it is synchronous, or what the return value indicates. The description is mostly a parameter list rather than behavioral context.

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

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

The description is compact and front-loaded with the core purpose. The key list is long but necessary given the schema has no enums. The serial explanation is minimal. It earns its place, though the key list could arguably be trimmed by referencing Android's keycode documentation.

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 params, no nested objects) and has an output schema, so the description doesn't need to explain return values. However, with no annotations and no usage guidance, an agent might not know whether pressing a key requires a focused field, whether it works on all Android versions, or what happens if the key is invalid. The key list is helpful but the behavioral context is thin.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it enumerates valid values for the key parameter and explains that raw KEYCODE_* names or numeric keycodes are accepted. The serial parameter is only mentioned as 'device serial when several are attached', which adds some context beyond the schema's bare type definition.

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: pressing a hardware or navigation key. It lists the supported key names and mentions that raw KEYCODE_* names or numeric keycodes also work, which distinguishes it from sibling input tools like tap, swipe, and input_text.

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 for pressing keys, and the key list provides context for when to use it. However, it does not explicitly state when to use this tool versus alternatives like tap or input_text, nor does it mention any exclusions or prerequisites.

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 hard cap on results ('hard-capped by FLUTTER_BRIDGE_MAX_LINES') and defaults for min_level and buffer, which are beyond what the schema conveys. However, it doesn't mention whether reading logs has any side effects (unlikely) or whether it requires an active device connection, though that's implied by the serial parameter.

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 purpose and then lists parameters in a clear Args block. It is appropriately sized, not overly verbose, and each parameter line adds value. It could be slightly more compact but is well-organized and easy to scan.

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 seven parameters and no annotations, the description covers all parameter semantics and the limit cap. The output schema exists, so return format is not required in the description. It lacks explicit prerequisites (e.g., requires a device) but that is inferable from the serial parameter and sibling tools. Overall, an agent can invoke it correctly with the provided 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 description coverage is 0%, and the description compensates thoroughly. It explains every parameter: package, tag, min_level, contains, limit, buffer, and serial, providing meanings and constraints (e.g., min_level options, case-insensitive contains, hard cap). This is far more than the schema's bare defaults, giving an agent everything needed to choose and format arguments.

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 action: 'Read recent logcat output, filtered.' This specifies a verb (read), a resource (logcat output), and the concept of filtering. It distinguishes itself from siblings like find_crashes (which searches for specific crashes) and clear_logs (which clears logs), making its 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 no explicit guidance on when to use this tool versus alternatives. It doesn't mention find_crashes for targeted crash analysis or capture_* for streaming, nor does it state when not to use this tool. Usage context is only implied by the filtering capabilities.

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 of behavioral disclosure. It states the action but does not mention side effects, error behavior, or whether the operation is read-only. It also doesn't describe what happens on missing mapping files or malformed input, leaving the agent with limited understanding of edge cases.

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

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

The description is concise and front-loaded: one sentence for purpose, followed by a compact bullet list for args. No wasted words; every part earns its place.

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

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

For a simple two-parameter tool with an output schema present, the description provides enough context for correct invocation. It could mention error conditions or the need for the mapping file to match the build, but these are minor given 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?

Schema description coverage is 0%, so the description fully compensates. It explains stacktrace as 'the obfuscated trace, copied from find_crashes output' and mapping_path with a typical file location pattern. This adds significant meaning beyond the bare string types in 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 action: 'De-obfuscate an R8/ProGuard stack trace using a mapping.txt file.' This specifies a verb, resource, and context, making it distinct from sibling tools like find_crashes (which discovers crashes) and read_logs (which reads raw logs).

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

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

The description implies usage by noting the stacktrace is 'copied from find_crashes output,' which gives a clear workflow context. However, it does not explicitly state when not to use it or mention alternative tools, so the guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries the burden. It discloses a key non-obvious behavior: the image is downscaled, so coordinates read off it are not the device's own. This gives the agent actionable knowledge to avoid incorrect tap targets. It does not mention other behavioral aspects like permission requirements, but the core risk is covered.

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 purpose, immediately followed by the critical downscaling warning, then the parameter details. Every sentence earns its place; there is no filler or repetition of schema 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?

For a simple tool with two optional parameters and no output schema, it covers the behavior and parameters well. The only minor gap is not explicitly stating the return format (e.g., image data type), but the phrase 'The image is downscaled before sending' implies it returns an image, so 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 0%, and the description fully compensates by explaining both parameters: max_width as 'longest edge of the returned image in pixels' and serial as 'device serial when several are attached'. This adds meaning beyond the schema's bare type/default declarations.

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 'capture' and the resource 'what is currently on screen', and positions it as a pre-action observation tool. It distinguishes itself from ui_dump and tap by noting they are needed for real tap targets, though it does not explicitly contrast with capture_* siblings which could be ambiguous.

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

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

It gives a clear 'when to use': 'see the app before acting on it'. It also provides a 'when not to rely on it' by warning that coordinates from the image are not device coordinates and directing the agent to ui_dump/tap instead. This is useful but could be stronger by naming all relevant alternative 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 were provided, so the description carries the burden. 'Force-stop' communicates the core destructive behavior and the cold-start pairing explains the intended effect, but it does not disclose side effects, permission requirements, or behavior when the app is not running.

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: the purpose and pairing are stated first, followed by a concise args list with useful examples. No sentence is wasted.

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

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

For a simple two-parameter tool with an output schema, this description covers purpose, usage context, and all parameter semantics. Nothing an agent needs to select or invoke 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 0%, but the description fully compensates: it explains package as an application id with a concrete example, and serial as only necessary when multiple devices are attached. This adds real meaning beyond the bare schema titles.

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

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

The description states the specific action (force-stop) and target (an app), and explains its relationship with launch_app for cold-start testing. This clearly distinguishes it from the sibling tools without ambiguity.

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 says to pair this with launch_app when testing a cold start, giving clear context for when to use it. It does not list exclusion cases or alternative tools, 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, the description carries the burden and does a good job: it explains that 'up' scrolls content up/reveals what is below, that duration_ms controls slow drag versus fling, and that coordinates are a fallback. It does not disclose return behavior, but an output schema is present, so the description covers the critical gesture semantics.

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

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

The description is compact and front-loaded with the essential purpose, followed by a terse parameter list. Every line adds information and there is no filler.

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

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

For a 7-parameter gesture tool with no annotations, this is largely complete: all parameters are explained and the direction semantics remove ambiguity. It stops short of perfect completeness by omitting explicit alternative-tool routing and coordinate units, but nothing essential about invoking the 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?

Schema coverage is 0%, so the Args block must explain the parameters, and it does: direction values, coordinate start/end points, duration semantics, and serial use are all described. It loses one point for not specifying coordinate units (e.g., pixels) and not enumerating direction values in a formal enum.

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

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

The opening line 'Swipe or scroll' states the action and resource clearly, and the coordinate/direction alternatives make the tool's scope obvious. It is easily distinguished from sibling gesture/input tools like tap, input_text, and press_key.

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

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

The description implies usage by explaining direction versus explicit coordinates ('Give a direction for a centred swipe, or explicit coordinates'), but it never explicitly says when to prefer swipe over sibling tools like tap, or states exclusions. The 'up... matching how a finger moves' note is helpful context but not a full usage comparison.

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 x/y are ignored when text is given, and that ambiguous matches result in no tap and a list of matches. These are important behavioral traits. It doesn't cover potential errors or prerequisites, but the provided details are 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?

The description is well-organized: a clear purpose statement, a preference note, and a compact Args section. It is front-loaded with the core function and the preference, and every sentence adds value without 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?

The description covers all parameters and key behaviors, and an output schema exists (so return format is handled). It does not mention error conditions or prerequisites (e.g., device state), but for a simple tap operation, the provided information is sufficient for correct invocation.

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

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

Schema coverage is 0%, so the description is the sole source of parameter meaning. It explains x/y as device coordinates (ignored when text is present), text as matching text/content description/resource id, and serial for multi-device scenarios. This fully compensates for the schema's bare types.

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 ('Tap the screen') and specifies two modes: coordinate-based and text-based. It distinguishes itself from siblings like swipe, input_text, and press_key by focusing specifically on tapping, and the text/coordinate distinction adds specificity.

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 to prefer 'text' for robustness against layout changes, and explains when to fall back to coordinates (when multiple elements match). This provides clear decision-making guidance for the agent, though it doesn't contrast with alternative tools, it fully covers the internal choice.

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 states the tool 'remembers the current screen' but does not disclose side effects, whether it is read-only, what happens to previous checkpoints, or what the output is. It gives minimal behavioral context beyond the core action, which is inadequate for a tool without annotation safety hints.

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

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

The description is concise and well-structured. It leads with the purpose, then gives a usage example, then lists arguments in a clear format. Every sentence serves a purpose, and it is front-loaded with the most important information. There is 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 simple checkpoint tool with optional parameters and an output schema (though not detailed), the description is reasonably complete. It explains when to use it (before code edits), what it does (remembers screen), and how to parameterize it. It doesn't describe the return value, but the presence of an output schema means the description needn't explain that. Minor gaps like preconditions (e.g., device attached) are not critical given the sibling 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?

The description explicitly explains both parameters: 'label: name for this checkpoint' and 'serial: device serial when several are attached.' This adds meaning beyond the schema, which only provides types and defaults. Since schema description coverage is 0%, the description compensates well by explaining each parameter's purpose.

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: 'Remember the current screen so a later ui_diff can show what changed.' This is a specific verb (remember) and resource (current screen), and it distinguishes from ui_diff by explaining the relationship. It is not a tautology and gives a clear mental model.

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 usage pattern: 'Take one before editing code, then call ui_diff after hot reloading.' This gives a clear context and sequencing, and implicitly tells the agent to use it before code edits and ui_diff after reload. It doesn't explicitly state when not to use it or name alternatives, but the workflow is clear and sufficient for a simple 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?

Annotations are absent, so the description carries the full burden. It discloses outputs (summary + outlined image) and explains how threshold tuning ignores animations, but it does not explicitly state that the operation is non-destructive or what happens if the referenced checkpoint does not 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 one-sentence purpose is front-loaded, followed by a compact output summary and clearly organized args. Every sentence earns its place with no redundancy.

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

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

The description covers purpose, output, and all parameters. For a diff tool with no output schema or annotations, it is sufficient, though missing details like error handling for missing checkpoints or image format are not addressed.

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

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

Schema description coverage is 0%, and the description fully compensates: label ('which checkpoint'), threshold ('per-channel difference... raise to ignore animations'), max_width ('longest edge of returned image'), and serial ('device serial when several are attached').

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 pair ('Compare the screen... against a checkpoint') and clearly distinguishes itself from sibling tools like ui_checkpoint (checkpoint creation) and screenshot (plain capture).

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 frames the use case explicitly — 'confirm an edit did what you meant and did not disturb anything else' — which gives clear context. However, it does not name alternatives or state when not to use the tool relative to siblings.

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 communicates a read-like, low-cost operation ('List', 'Cheaper') and a behavioral comparison to screenshot, but it does not explicitly state side-effect-freeness, platform prerequisites, or limitations such as whether Flutter-specific elements appear in the dump. This leaves room for agent uncertainty about what the call actually does behind the scenes.

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 tightly structured: a one-sentence purpose, a one-sentence use-case comparison, and a compact Args list. No filler or repetition, and the most decision-relevant information 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 simple read tool with an output schema and fully documented parameters, the description is mostly complete. However, it does not mention platform scope or when to prefer Flutter-specific siblings, which could matter given the large sibling list and that Flutter widgets may not appear in a generic UI hierarchy dump.

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

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

Schema description coverage is 0%, and the description fully compensates by explaining all four parameters: contains, clickable_only, limit, and serial. Each explanation adds meaning beyond the raw schema, such as 'case-insensitive filter on text, content description or id' and 'only return elements that accept taps.'

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 'List on-screen UI elements with their tap coordinates,' which names a specific verb, resource, and output. It also distinguishes itself from screenshot by claiming to be 'cheaper and more precise than a screenshot when you only need to find a control,' so an agent can tell it apart from a key sibling.

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

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

The description explicitly frames when to use this tool: 'Cheaper and more precise than a screenshot when you only need to find a control.' This gives clear context for choosing ui_dump over screenshot, though it does not discuss other siblings like flutter_widget_tree or when those should be preferred.

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