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

No annotations are provided, so the description carries full responsibility. It communicates that assertions can wait with a timeout_ms parameter, but doesn't disclose the failure behavior (exception thrown vs. return value), whether failures abort the session, or what passing/failing outcomes look like. For a test-assertion tool, this behavioral detail is a meaningful 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 front-loads the primary purpose and immediately follows with actionable guidance on the check parameter. No wasted words, though the enumeration of eight check types could arguably live entirely in the schema enum and still be accessible to the agent.

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 5 parameters and no output schema, the description covers the check-type usage pattern but omits the return value/outcome behavior entirely. Given there are 28 sibling tools and no annotations, the description should clarify what happens on success vs. failure, which is central to using an assertion tool correctly in an automation loop.

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 five parameters are documented in the schema. The description additionally clarifies the relationship between 'check' and 'expected' (which check types require which expected value types), which adds value beyond the schema. This is slightly above the baseline 3.

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

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

The description states 'Runs an assertion check on a widget' with a specific verb+resource. It lists the eight assertion types, distinguishing the tool's capabilities among the sibling actions (tap, enter_text, etc.). It's clear but doesn't strongly differentiate from the general verification tools like get_text or get_widget_tree, which could serve verification purposes too, so it doesn't reach a 5.

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

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

The description provides clear context on how to use the tool ('Use 'check' to specify the type') and enumerates the valid check types. However, it doesn't explicitly state when not to use it or name alternative sibling tools (e.g., get_text for reading values vs. asserting them), 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 of behavioral disclosure. It explicitly discloses that actions run sequentially, pumpAndSettle occurs between actions, and it stops on first error. This is meaningful behavioral context beyond the schema. It doesn't mention error semantics (what happens to the stop, partial success exposure), but the core execution traits are well 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 a single functional paragraph of about 40 words that front-loads the core purpose and then lists supported tools. Every sentence earns its place. The tool list is necessary context. Slightly more structure (bulleted execution semantics) could help, but it is appropriately 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?

Given the single parameter with 100% schema coverage, no output schema, and no annotations, the description covers the essential behavioral contract including sequential execution, pumpAndSettle delay, stop-on-error semantics, and the supported tool whitelist. It could elaborate on how errors are surfaced or whether partial results are observable, but for a batching facade this is reasonably complete.

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

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

Schema description coverage is 100%, and there is only 1 parameter (actions). The description lists the allowed tool names but does not explain how to structure each action object or what 'args' should contain. With only one array parameter and high schema coverage, the baseline of 3 is appropriate—the description adds the tool list but doesn't need to add much more.

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 executes multiple actions in a single call, lists the supported sub-tools, and conveys the sequential execution model. It distinguishes from siblings by being the batching/composition primitive. However, its name 'batch_actions' already implies the purpose, so it's clear but not maximally differentiated.

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

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

The description explains when to use it (multiple actions in one call), the execution semantics (sequential, pumpAndSettle between, stops on first error), and lists the supported sub-tools, which tells the agent which actions can be batched. It doesn't explicitly state when NOT to use it or contrast with alternatives, but the execution details provide solid usage 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 full burden for behavioral disclosure. It doesn't state what happens after the drag (e.g., whether a drop event fires, whether the target must exist, whether the offset requires the 'to' field to be absent), and whether the 'to' and offset (dx/dy) are mutually exclusive. The agent is left uncertain about preconditions and side effects.

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

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

A single concise sentence that states the core operation. Efficient with no wasted words. Slight deduction for not front-loading the mutually exclusive pattern clearly, but structurally it's clean and short.

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 5-parameter interaction tool with no annotations and no output schema, the description is somewhat thin. It covers the basic intent but misses important usage context: which destination should be preferred (offset vs. target string), when each makes sense, and whether this tool waits for the drag animation to complete. The schema documents all parameters, but the operational context is incomplete.

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 a doc line. The description adds context that either 'to' or an offset (dx/dy) can be the destination, but it doesn't clarify whether 'to' and dx/dy are mutually exclusive, nor the semantics of duration_ms beyond 'duration of the drag animation.' Given full schema coverage, 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 verb (drags), the resource (source widget to target widget or offset), which distinguishes it from siblings like tap, scroll, and enter_text. It conveys a specific action that isn't ambiguous. However, it doesn't explicitly clarify the relationship to the offset alternative beyond naming it, which is minor given the clear action 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?

No guidance on when to use drag_and_drop versus alternatives. Among siblings there are tap, scroll, scroll_until_visible, and enter_text, but no exclusions or comparisons are given. The description doesn't mention common drag scenarios (e.g., reordering lists, moving elements) that would help the agent decide to select 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 provided, so the description carries the full burden. It clearly discloses the default behavior (replaces existing text) and the clearFirst option, which is genuinely non-obvious behavioral context. However, it doesn't describe side effects like whether the widget gains focus, what happens on failure, or any authentication/permission needs. Still, the default-vs-option behavior disclosure is valuable and above baseline.

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 filler. The first sentence states the core action and default behavior, the second explains the key option. Every word earns its place. Fully front-loaded with the most important information first.

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

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

For a text-entry tool with full schema coverage and no output schema (return value is presumably trivial), the description covers the core behavior and the most important flag (clearFirst). It's reasonably complete, though it could mention focus behavior or confirmation of action. Given the tool's moderate complexity, this is adequate.

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

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

Schema coverage is 100%, so the schema already documents all 5 parameters thoroughly, including the target string format examples. The description adds meaning to clearFirst (explaining its purpose as clearing and re-focusing) but doesn't add significant value for the other parameters 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 a specific verb+resource ('Enters text into a widget found by the target string') with clear scope. It distinguishes itself from sibling tools like tap and get_text by focusing on text entry, and the target-based widget matching is clearly described.

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 core use case (entering text into a widget) and clarifies the clearFirst behavior, but it provides no explicit when-to-use guidance versus alternatives. Among siblings, get_text is the inverse operation and tap is related, but no explicit distinction is drawn. The clearFirst explanation offers some usage context but not full comparative 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. It doesn't explain whether this reads the accessibility tree, widget tree, or does semantic analysis, what output form it produces, whether it explores recursively or top-level only, or what the 'within' constraint does to behavior. For a screen-exploration tool, these behavioral details matter significantly.

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 concise sentence with zero waste. However, it's under-specified given the tool's complexity—a one-liner is economical but doesn't earn beyond a 4 because the conciseness comes at the cost of completeness.

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 two optional parameters, no annotations, no output schema, and a vague purpose, the description should provide significantly more context. An agent cannot determine what 'explore' returns, how it differs from widget/accessibility tree queries, or what filtering semantics apply. The sibling ecosystem (get_widget_tree, get_accessibility_tree, screenshot) makes this tool's unique value unclear.

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 (filter, within) are already documented in the schema. The description 'Maps out interactive elements' adds a general sense of what the output is but doesn't clarify how 'filter' and 'within' interact or what values are valid (e.g., what flags beyond isButton/isTextField are supported). Baseline 3 is appropriate since schema covers everything.

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 'Maps out interactive elements on the screen' has a clear verb+resource ('Maps out...elements on the screen'). However, it doesn't distinguish itself from siblings like 'get_widget_tree' or 'get_accessibility_tree', which could serve similar roles, and 'explore_screen' sounds like it could overlap with screenshot or widget inspection functions.

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 guidance on when to use this tool versus sibling tools like get_widget_tree, get_accessibility_tree, or screenshot. There's no context about when exploration is preferred over querying widget/accessibility trees directly, nor any exclusions or alternatives mentioned.

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 describe what the returned tree contains (nodes, roles, labels, states), whether it represents only visible elements, how large the result could be, or whether it reflects a static snapshot or live view. For an inspection tool with zero annotation coverage, this is 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?

The description is a single, efficient sentence with no wasted words. It's appropriately minimal for what it conveys, though the brevity trades off against behavioral completeness.

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 is provided, so the description should explain what the returned tree structure looks like or at least its characteristics. The description does not mention return format, hierarchy depth, whether semantic roles are included, or how includeRect affects output. For a tool whose primary value is the tree content itself, this is under-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 coverage is 100% and the single parameter (includeRect) has its own description, so baseline 3 is appropriate. The description adds no further semantic context beyond the schema, but no compensation is needed since the schema adequately documents the only 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 'Returns the accessibility (semantics) tree' has a specific verb+resource, making the core purpose reasonably clear. However, it does not distinguish from sibling tools like get_widget_tree or explore_screen, which could be confused with this tool when selecting which to invoke.

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 guidance is given on when to use this tool vs alternatives like get_widget_tree (DOM) or explore_screen. The agent must infer when an accessibility tree is preferred over widget tree or screen exploration, which is a notable gap for a GUI automation context with many similar browsing/inspection 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 disclosure burden. As a pure read operation ('Returns the name'), the behavior is largely self-describing. However, it doesn't disclose what the return value looks like (format of route name, whether it's null/error when no route is active), which matters since there's no output 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?

Single sentence, zero waste, immediately states the core function. 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?

The tool is simple (0 params, no schema), and the description covers the core function adequately. However, since there's no output schema and no annotations, the description could add marginal value by clarifying the return format or edge cases (e.g., what happens when the stack is empty). It's adequate but not rich for a read operation with no structural support.

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, so there's nothing to document. The schema coverage is 100% (vacuous), and the description correctly needs no parameter explanation. Baseline 4 for zero-parameter tools is appropriate.

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

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

Description clearly states the verb (returns), the resource (currently active route on the Navigator stack), and the scope (active route). It's unambiguous and distinct from siblings like navigate_to and go_back, which modify the route rather than read it.

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 check the current Navigator route) but doesn't explicitly contrast with siblings or state when not to use it. For a simple getter in a UI automation context, the usage is fairly self-evident, but there's no explicit guidance about alternatives like get_widget_tree or get_accessibility_tree for navigation inspection.

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 it returns text content but doesn't clarify failure behavior (e.g., what happens if the target isn't found), whether it waits for widget presence, or what happens with hidden/off-screen widgets. The timeout_ms parameter hints at waiting behavior but the description doesn't explain 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?

Single clear sentence that is efficient and straightforward. Front-loaded with the verb and resource. 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 2-parameter read tool with 100% schema coverage, the description is adequate but thin. It doesn't explain failure semantics, return value structure, or interaction with widget visibility. Given no annotations or output schema, slightly more behavioral context (e.g., what happens on no-match) 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?

Schema coverage is 100%, so the schema fully documents both parameters including example formats for the target string. The description adds minimal value beyond the schema—it confirms the resource type being retrieved but doesn't add semantic details about return format or edge cases.

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 ('returns') and resource ('text content of a widget'), and distinguishes from sibling tools like get_widget_tree and get_accessibility_tree. It clearly identifies what data is retrieved, though it doesn't explicitly contrast with those sibling read 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 this tool (retrieve text from a widget) but provides no explicit context about when to prefer this over get_widget_tree or get_accessibility_tree. No exclusions or alternative guidance is given. The tool name and description make usage reasonably self-evident.

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 says it 'returns a JSON representation' but doesn't disclose behavior details: whether this is a read-only operation, whether it captures the current screen or the whole session state, what the tree structure looks like, or any filtering behavior related to summaryOnly. For a tool with zero annotations, this is insufficient.

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, zero waste, front-loaded with the core purpose. No unnecessary elaboration. Appropriate for the modest scope of the tool.

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 no output schema, no annotations, and an ambiguous parameter (summaryOnly). For a query tool that returns potentially large structured data, the description should clarify what the JSON contains, how summaryOnly restricts it, and how it differs from get_accessibility_tree. Given the low context in structured metadata, the description is under-developed.

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

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

Schema coverage is 100%, but the only parameter (summaryOnly) has a minimal description ('If true, returns a filtered tree') that doesn't explain what 'filtered' means—filtered how, for what purpose? The description repeats the parameter briefly without adding meaningful semantics beyond the schema.

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

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

Clear verb+resource (`Returns a JSON representation of the widget tree`). It distinguishes itself from siblings like get_accessibility_tree by mentioning JSON representation and widget tree specifically, though it doesn't explicitly contrast them.

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

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

No guidance on when to use this tool vs alternatives like get_accessibility_tree or explore_screen. The description doesn't explain what distinguishes widget tree from accessibility tree, which sibling tools a user might confuse it with.

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 transparency burden. It does disclose the behavioral action (popping the route) and the analogy to a back button gives a sense of reversibility. However, it doesn't disclose edge cases like what happens when the stack has only one route, deep-linking implications, or whether the app's unsaved state is preserved.

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, zero waste, front-loaded with the core action. Perfectly succinct for a zero-parameter tool.

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, no-output-schema tool, the description is appropriately complete. The back-button analogy helps an agent understand the semantic effect. It could add edge-case behavior (empty stack) but for such a simple tool this is adequate.

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

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

The tool has zero parameters, so there's nothing to describe beyond what the schema shows. With 0 params, the baseline is 4 per the rubric, and the description appropriately needs no parameter elaboration.

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 ('Pops the current route off the Navigator stack') with a clear analogy to the back button. It's clear what the tool does, though it doesn't explicitly distinguish itself from the sibling navigate_to or get_current_route tools, which are related navigation operations.

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 guidance on when to use this tool versus alternatives like navigate_to or simulate_background. The description implies usage via the back-button analogy but there are no explicit when/when-not conditions or alternative tool references.

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 gives no information about whether the interception is scoped app-wide, whether it persists until cleared, what happens to concurrent requests, whether prior interceptions are overwritten, or whether partial null values (only one null) have defined 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 with zero filler. The text is appropriately brief and front-loaded with the core purpose in the first three words. However, this brevity comes at the cost of important behavioral and parameter 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 2-parameter tool with no annotations, no output schema, and 0% schema coverage, the description is underspecified. It doesn't explain URL pattern matching syntax, response body format, lifecycle/clearing semantics beyond the single null hint, or interaction with other network tools. The tool is more complex than the description acknowledges.

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 makes no explicit mention of urlPattern or responseBody as parameter names. The "Pass null for both" instruction implicitly references the two parameters but never maps them by name, leaving the agent to guess which parameter holds the pattern versus the body.

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?

"Mocks a network response" uses a specific verb with a resource, and pairs naturally with siblings like set_network_status. However, it doesn't clarify the scope (which requests it intercepts, whether it's URL-based or global), and the second sentence about passing null to clear is only understandable once you infer the two parameters correspond to urlPattern and responseBody.

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 one usage hint (pass null to both to clear), which tells how to undo the mock, but provides no guidance on when this tool should be used versus alternatives like set_network_status or read_logs, no scenarios, and no context on 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?

With no annotations provided, the description carries the full behavioral burden. The key behavioral detail disclosed is 'Does NOT require a running app', which differentiates its execution context. It doesn't mention what the output looks like or whether it includes emulator vs physical device details, but the simplicity of the tool (0 params, list operation) reduces the need for extensive disclosure. No contradictions with annotations since none 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, both earning their place. The first states the core purpose clearly, and the second adds a genuinely useful semantic qualifier about app state. No wasted words or redundant 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 zero-parameter, simple list operation, this description is largely sufficient. It states what it does and a key behavioral constraint. It doesn't explain return format, but with no output schema and a straightforward device-listing tool, the expected output is reasonably inferable. Given the tool's low complexity, this is adequate.

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

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

The tool has 0 parameters, so the description doesn't need to explain parameter meanings beyond what the schema provides. The schema has 100% coverage (empty properties), and the description adds the important qualification about not requiring a running app, which is contextual value beyond the schema. With no params, baseline 4 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 'Lists available Flutter devices' with a specific verb+resource. It distinguishes this from sibling tools (start_app, tap, etc.) by being the device enumeration tool. The 'Does NOT require a running app' clarification reinforces the tool's distinct 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 mentions it lists devices and explicitly clarifies it doesn't require a running app, which gives helpful context for when to use it (e.g., before starting an app to know available targets). However, it doesn't explicitly state when-not-to-use or name alternative tools, though given siblings like start_app/stop_app, the placement of this command is fairly obvious.

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 discloses the critical limitation (non-compatibility with GoRouter/custom routers) and the underlying navigation API (pushNamed), which is genuinely useful. However, it doesn't disclose what happens on failure (e.g., if the route doesn't exist), or whether navigation is awaited or fire-and-forget, leaving some behavioral 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?

Two sentences, zero wasted words. The first sentence states the action, the second delivers a critical constraint plus a concrete fallback. Every word earns its place, and the most important caveat (GoRouter incompatibility) is front-loaded in the NOTE.

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 navigation tool with 100% schema coverage, the description covers the essential context: what it does, its key limitation, and the fallback approach. It doesn't describe return behavior or failure modes, but given the tool's simplicity (1 param, no output schema guaranteed), what's provided is reasonably complete. It could mention what happens if the route doesn't exist, but this is a minor 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 the schema documents the single 'route' parameter fully. The description adds the implementation context (named route, pushNamed semantics) which gives meaning to the param beyond 'Named route to navigate to', but doesn't add format details like whether route strings need leading slashes or pattern conventions. 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 ('Pushes a named route') using a specific mechanism (Navigator.pushNamed), which clearly identifies the tool's purpose. It doesn't explicitly differentiate from siblings like go_back or get_current_route, but the named-push behavior and the explicit GoRouter exclusion give strong contextual 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 explicitly states when NOT to use this tool ('Does NOT work with GoRouter or other custom routers') and provides a clear alternative ('use tap() to navigate via on-screen elements instead'). This gives an agent an explicit when/when-not and names a specific alternative tool, which is exactly what this dimension rewards.

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 says 'hot restart' which conveys it's faster than a full restart, but doesn't disclose whether the current app state is preserved, whether it interrupts in-flight operations, how long it takes, or what happens on failure. Given zero annotation coverage, this is a significant gap for a state-affecting 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 concise sentence, no waste, adequately front-loaded. Very efficient. Could add a bit more behavioral context without hurting score, but as written it's appropriately short.

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 it's a state-mutating tool with no annotations and no output schema, the description is underspecified. It doesn't explain what state is preserved, when it's appropriate (e.g., after code changes vs. to recover from a crashed state), or the return/result expectation. Sibling tools list (start_app, stop_app, tap, etc.) implies a UI testing framework, but the description doesn't connect hot restart to that workflow.

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 with 100% schema coverage (empty schema means nothing to document). Baseline for 0 parameters is 4. The description correctly implies no inputs are needed, so the schema and description are consistent.

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: 'Performs a hot restart of the currently running app session started by this server.' It's clear this restarts the app session. However, it doesn't distinguish from sibling tools like stop_app+start_app or suggest when hot restart differs from a cold restart; siblings include start_app, stop_app, simulate_background but no other restart tool, so differentiation is limited.

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 guidance on when to use hot restart versus stopping and starting the app, or whether it applies only to a session started by this specific server. The phrase 'started by this server' implies a constraint but doesn't explain the implications (e.g., won't work on externally-launched apps). No exclusions or alternatives mentioned.

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 only states what it does (simulates a key press) but doesn't disclose side effects, focus requirements, whether this operates on a hardware keyboard vs virtual keyboard, or whether modifier keys are supported. As a mutation-style input tool with zero annotation coverage, more behavioral context is needed.

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, no wasted words. The sentence is front-loaded with the clear purpose. Could arguably be more concise but it's already efficient and to the point.

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 tool, the description is mostly adequate. However, without any annotations or output schema, the description should clarify return behavior (does it succeed silently, return a result?) and the context in which key presses are meaningful (e.g., requires an active field or focused element). These gaps lower the completeness below what would be ideal for a tool with zero annotations.

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 lists all valid key names. The description adds the human-readable examples which reinforces the key values but adds no semantic beyond what the schema's key description already provides. With 100% coverage, 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 states 'Simulates a keyboard key press' with a specific verb and resource, and lists concrete examples (enter, tab, escape, backspace, arrow keys). It's clear in purpose. It doesn't explicitly distinguish from siblings like enter_text or tap, but the keyboard-press focus is distinct enough given the examples.

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 when-to-use or when-not-to-use guidance is provided. It doesn't clarify when to use press_key versus enter_text (which likely handles text input) or tap (which handles UI tapping). An agent would have to infer the distinction from the examples rather than from explicit 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. It discloses the source (stdout/stderr) and scope (last N lines), but doesn't disclose what happens if the app isn't running, whether logs are buffered/truncated, or return format. For a read-only tool the risk is low, but the description doesn't add much beyond the raw 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?

One sentence, perfectly sized for the tool's simplicity. Every word earns its place — verb, resource, and scope in a single line. No fluff or repetition.

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

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

The tool is simple (1 optional param, no output schema). The description covers the basic function adequately. However, it doesn't mention what the output looks like (plain text lines? structured?), whether the default 50-line behavior is significant, or any relationship to timing of log capture. For such a simple read tool, this is adequate-but-minimal.

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 'lines' param has a description and default). The tool description adds 'stdout/stderr' context but doesn't add meaning to the parameter beyond what the schema already specifies. Baseline 3 is appropriate since the schema adequately documents the parameter.

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

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

The description states 'Reads the last N lines from the app's stdout/stderr' — a specific verb (reads) plus resource (app logs) and clear scope (last N lines, stdout/stderr). It distinguishes from siblings like start_app/stop_app which are lifecycle actions, though it doesn't explicitly differentiate from other diagnostic tools like get_widget_tree.

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 guidance on when to use this tool versus alternatives, nor any exclusions. It doesn't clarify when log reading is appropriate (e.g., after failures, for debugging) versus other diagnostic tools like assert or get_text. There's no mention of prerequisites like app running state.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to state that capturing a screenshot is a safe, non-destructive read operation, whether it requires the app to be running, whether it waits for widget visibility, or what happens with the timeout_ms when no target is given. The timeout parameter's behavior is entirely unexplained.

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 concise, focused sentences that efficiently convey the core purpose and the primary behavioral distinction (with/without target). No wasted words. Could arguably add behavioral caveats but what's here is tight and front-loaded with the essential 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 screenshot tool with no annotations and no output schema, the description is adequately minimal but leaves gaps. The timeout_ms, save_path vs base64 behavior, and the type parameter's restriction to 'only for full-app screenshots' are all left to the schema. For a four-parameter tool with zero annotations, this is acceptable but not thorough—the interaction between type and target isn't clarified anywhere.

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

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

Schema coverage is 100%, so all four parameters have descriptions in the schema itself, establishing the baseline of 3. The tool description itself does not add semantic depth beyond what the schema provides—it doesn't clarify how type interacts with target, or what implicit wait means in context. The description adds little beyond the schema's own 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?

Clearly states it captures a screenshot with a specific verb+resource. Distinguishes two modes: full-app (no target) vs specific widget (with target). However, its interaction with get_widget_tree could be ambiguous, and it doesn't differentiate from the recording siblings despite being a clearly distinct 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 explains the two usage modes (with/without target) which implies when each is appropriate. However, it doesn't explicitly state when each mode is preferred, doesn't discuss when to use this instead of start_recording, and says nothing about the save_path vs base64 return distinction—an important usage decision the agent must make.

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 disclosure burden. It clarifies that direction auto-computes dx/dy and that distance has a 300px default, which is helpful. However, it doesn't disclose what the return value is, whether the scroll targets a specific widget or the viewport, or any failure behaviors beyond the generic timeout_ms 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?

A single efficient sentence that front-loads the purpose and then covers the two usage modes. Zero wasted words. Could arguably add sibling differentiation, but as structured it's tight and readable.

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 6 parameters, no output schema, and no annotations, the description does a reasonable but not complete job. It covers the core distinction between modes and key defaults. However, it lacks guidance on target semantics, how timeout_ms applies, expected return/result, and how this differs from scroll_until_visible which appears to be a closely related sibling. Adequate but with clear gaps.

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

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

Schema coverage is 100% with each parameter already described (dx, dy, direction, distance, timeout_ms, target). The description adds the relationship between direction and dx/dy being auto-computed and the distance default, which provides genuine value beyond the schema. However, the description doesn't clarify how target interacts with scrolling (does it scroll a specific widget or the screen containing it?) or semantics around dx/dy sign conventions.

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 ('Scrolls or swipes a widget') and clearly distinguishes the two primary modes (dx/dy pixel-precise vs direction/distance swipes). It's clear and distinguishes from siblings like scroll_until_visible and drag_and_drop at a basic level, though it doesn't explicitly name the alternatives.

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

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

The description implies usage by describing the two modes and when each applies ('pixel-precise scrolling' vs 'named swipe gestures'), but doesn't explicitly state when NOT to use this tool or how it compares to scroll_until_visible or drag_and_drop siblings. No exclusions or alternative recommendations are provided.

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

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

No annotations are provided, so the description carries the full burden. It states the core behavior (scroll until visible) but doesn't disclose what happens on scroll failure timeout, whether it works with fling/momentum scrolling, or how it handles targets that never appear. It also doesn't explain the default scroll direction or step behavior. The behavior is partially disclosed but with meaningful gaps.

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

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

The description is a single concise sentence that states the core function without filler. It's appropriately brief for a straightforward action tool. Slightly more detail on behavior could be warranted, but as written it's 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?

Given this is an action tool with 5 parameters and no output schema, the description is somewhat thin. It doesn't explain the scroll delta stepping behavior, the interaction between dx/dy and target visibility, or what 'visible' means (fully scrolled into view vs partially). The existence of sibling tools like 'scroll' and 'drag_and_drop' suggests the description should clarify the differentiating intent more explicitly. A list-style tool might be adequate at this level, but this action tool would benefit from more detail.

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 5 parameters are documented in the schema itself. However, the description adds no parameter-level semantics beyond what the schema already provides. The schema also defines defaults for dx (0.0) and dy (-50.0) which gives context, so the description adds no marginal value. Baseline 3 is appropriate since 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 'Scrolls a scrollable widget until a target widget is visible' clearly states the verb (scroll) and the object (scrollable widget) plus the goal (until target visible). It distinguishes from the sibling 'scroll' tool by adding the visibility-until condition behavior, though it doesn't explicitly name the sibling as an alternative.

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 in a scenario where a target widget is off-screen and needs scrolling to become visible. However, it doesn't explicitly state when to prefer this over the sibling 'scroll' tool, nor does it specify when NOT to use this tool. The context of needing a visibility target is clear but exclusions/alternatives 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?

With no annotations provided, the description carries full burden for behavioral disclosure. 'Simulates network connectivity changes' gives a minimal hint that this is a simulation/emulation rather than a real change, which is useful, but it doesn't disclose scope, side effects, whether it affects only the app or the whole device, or whether changes persist.

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

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

A single short sentence. There's no filler or redundancy. While it's brief, it's technically efficient—however, the brevity comes at the cost of substance, so it earns a 4 rather than a 5.

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

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

For a mutation tool with no annotations and no output schema, the description is under-specified. It doesn't clarify the relationship to sibling tool intercept_network, doesn't explain the scope of the simulated change, and doesn't indicate what the result/effect of setting wifi=false would be. A 1-parameter tool is simple, but the ambiguous relationship to siblings and lack of behavioral detail leaves 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 coverage is 100% with a single boolean 'wifi' parameter directly described as 'Enable or disable WiFi'. The description adds the context that this is network connectivity simulation, which slightly supplements the schema. Baseline 3 is appropriate since the schema already fully documents the parameter.

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

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

The description 'Simulates network connectivity changes' uses a verb and resource but is very vague. It doesn't specify that this toggles WiFi connectivity, nor does it distinguish itself from sibling tools like intercept_network (which likely modifies network interception). The purpose is only loosely conveyed.

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 guidance is given about when to use this tool versus intercept_network or other network-related siblings. There's no mention of scenarios (test conditions, offline reconnection checks) or exclusions. The agent has no way to know if this is testing-related or how it differs from intercept_network.

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 doesn't disclose whether the tool blocks until the app returns to foreground, whether it's safe/non-destructive, whether there's any risk to app state, or what observable effects occur. For a control-action tool that alters app lifecycle, 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?

Single sentence, zero waste, front-loaded with the core action. Perfectly concise for the complexity level of this tool.

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 simple schema (1 optional param, no output schema, no nested objects). However, given it's an imperative action that mutates app state (even temporarily), it could benefit from notes on expected outcomes or verification steps. Adequate for a simple tool but not exceptional given it's a lifecycle-control action.

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 param 'duration_ms' is documented as 'How long to keep the app in the background'. The description adds context by mentioning the complete lifecycle simulation (going to background AND coming back), which frames the duration parameter's role. With one well-described param at full schema coverage, baseline 3 plus modest added context justifies a 4.

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 what the tool does: simulates app entering background and returning to foreground. Specific verb 'simulates' with resource 'app' and a clear lifecycle action. However, it doesn't explicitly distinguish itself from siblings like start_app/stop_app, though its purpose is distinct enough to be understood.

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 testing lifecycle behavior but doesn't explicitly state when to use it vs alternatives. No exclusionary guidance or mention of related tools. The context of 'simulate background' is clear but the agent gets no framing about why one would do this or what to check after.

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 bears the full burden of behavioral disclosure. 'Injects the harness' hints at side effects (running app processes, possibly leaving the app running until stop_app), but neither the injection side effects, the need to call stop_app afterward, nor any state implications are disclosed. For a stateful tool that starts a process, 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?

One short sentence, efficient with no waste, but the terse structure omits critical context (usage, side effects). This is under-specification rather than conciseness—the single sentence does not fully earn its brevity given the missing behavioral 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?

The tool starts a long-running app in test mode—a state-heavy action—yet provides no output schema, no annotations, and no guidance on lifecycle expectations (how to stop, what happens to state, whether it blocks). Given 26 siblings forming an app-testing workflow, the description should clarify that start_app is the workflow entry point, which it does not.

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 (project_path, device_id) are already documented in the schema. Baseline is 3. The description adds no parameter-specific detail beyond the schema, so it neither enhances nor degrades the 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 description states a specific verb ('injects the harness and starts') plus a clear resource ('the Flutter app in test mode'). It distinguishes reasonably from siblings like stop_app and pilot_hot_restart by establishing the startup role, though it could more explicitly frame itself as the entry point among the device-control sibling 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 gives no guidance on when to use this tool versus alternatives. There is no mention of prerequisites like needing a device, running list_devices first, or that this must precede interaction tools like tap/enter_text. With 26+ siblings, usage context is notably 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?

With no annotations provided, the description carries full burden and excels: it discloses immediate capture behavior (no warmup), platform-specific formats, the max 180s limit on Android, the single-recording-at-a-time constraint, the 5-minute auto-stop, and the auto-stop trigger on stop_app. This is exceptionally transparent for a stateful recording 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?

Five sentences, every one adds distinct value: capture timing, platform formats, concurrency limit, auto-stop conditions. No redundancy, front-loaded with the operational verb and immediate-usage 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 single-optional-param tool with no output schema, the description is nearly complete. It covers formats per platform, duration limits, concurrency, and lifecycle interactions with stop_app. Minor gap: doesn't state what the return value is (e.g., the file path or recording ID), though no output schema exists to convey this.

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 save_path parameter, which is already fully described as an optional absolute path with temp-directory fallback. The description adds no parameter-specific detail beyond 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?

The description clearly states the verb+resource ('Starts recording the screen of the running app's device') and distinguishes from siblings like screenshot and stop_recording. It specifies immediate capture with no warmup delay, which is critical behavioral detail for agent selection.

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

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

The description provides clear context on platform support (iOS Simulators, macOS Desktop, Android), the single-recording constraint, and auto-stop conditions. It doesn't explicitly name sibling alternatives (e.g., stop_recording) when to use them instead, but the context is sufficient for typical selection decisions.

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. 'Stops the currently running Flutter app and cleans up' implies destructive action, but 'cleans up' is vague - it doesn't specify what gets cleaned up (processes, session state, emulator state?), whether the flutter tool remains connected, or what happens if no app is running. Some context is implied but not specified.

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

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

A single concise sentence. Efficient and to the point. Could arguably be criticized for being under-specified, but for a zero-parameter tool, it's appropriately brief.

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 0 parameters and no output schema, making it structurally simple. However, the description doesn't clarify key operational details: is this idempotent? What does 'clean up' entail? How does it interact with start_app or pilot_hot_restart? For a tool that terminates a running process, a bit more behavioral context would help the agent know when and how to invoke it safely.

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 there are no parameter semantics to describe. A 0-parameter tool doesn't need the description to explain parameters. Baseline 4 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 states the verb (Stops) and resource (currently running Flutter app) and notes it cleans up. It's clear what it does, but it doesn't distinguish itself from sibling tools like start_recording/stop_recording, though those are clearly different operations. It's adequate but not differentiated from alternatives.

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

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

No guidance on when to use this vs alternatives. It doesn't specify whether stop_app is required before starting another app, nor does it explain the relationship with start_app (does it reset state, kill the session?). There is no when/when-not guidance, and it doesn't reference any sibling 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 provided, so description carries the burden. It discloses the behavioral result (finalizes video file) and return values (path, format, duration, size). However, it doesn't describe error behavior when no recording is active, or any side effects, which would benefit from disclosure given 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 tightly-scoped sentences. First states the action and result, second lists return values, third clarifies the automatic-call relationship with stop_app. Zero wasted words.

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

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

For a parameterless tool with no output schema, the description covers the action, return values, and relationship to stop_app. Minor gap: doesn't address what happens if no recording is active (error vs no-op), which an agent might need to know. But given the tool's simplicity, it's 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?

Tool has 0 parameters, so schema carries no burden. The description compensates by explaining return values clearly (file path, format, duration, file size), which is the meaningful semantic content for this parameterless tool. Baseline 4 for 0 params is appropriate.

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

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

Clear verb+resource (stops recording) with explicit outcomes (finalizes video file, returns file path, format, duration, file size). Well-defined scope that distinguishes it from sibling start_recording.

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?

Mentions it's called automatically by stop_app if a recording is active, which gives useful context about when it's invoked. Doesn't explicitly state when NOT to use it or name alternatives, but the automatic-call note and sibling context make usage fairly 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 exist, so the description carries the full burden of behavioral disclosure. It does not mention side effects (e.g., whether a failed tap waits, throws, or how timeout_ms behaves on failure), what happens if the target isn't found, or whether tapping triggers navigation/state changes. The timeout_ms parameter hints at fail behavior but isn't explained.

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 concise sentences with zero wasted words. Purpose, default, and mode-switching mechanism are all covered efficiently. Well front-loaded with the primary action first.

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

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

Given the tool's moderate complexity (3 params, all documented, with enums), the description is reasonably complete. It explains the gesture variants and default behavior. However, it lacks guidance on topic interactions like tab-switching ambiguity resolution, failure behavior, and prerequisites, which would round out completeness for an interaction 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 already documents all three parameters. The description adds the default 'tap' mode and clarifies gesture usage, but provides no extra meaning beyond the schema—e.g., targeting syntax nuances beyond the examples already in the schema. Baseline 3 is appropriate since 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?

Description clearly states the action (taps, long-presses, double-taps) targeting a widget, with a default behavior noted. It distinguishes the gesture variants from each other. However, it doesn't explicitly differentiate from sibling interaction tools like drag_and_drop, scroll, or press_key, though the primary verb+resource ('taps a widget') is specific 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 states the gesture parameter ('Use gesture to change') which helps select the mode. However, it gives no guidance on when to use this tool versus siblings like wait_for, assert, or explore_screen, and no context on prerequisites (e.g., whether the target must be visible, whether a prior start_app is required).

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 explains the wait-for-disappearance behavior and timeout semantics are implied by the params. It doesn't disclose what happens on timeout (throws? returns false?), default timeout behavior, or whether this is a blocking call vs. polling, leaving some ambiguity.

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 compact sentence that front-loads the primary purpose and adds a representative example. It's efficient with 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?

The tool is relatively simple (wait for appear/disappear), but the description doesn't address the ambiguous dual-timeout params, default timeout behavior, or failure semantics. With no output schema and no annotations, the description could reasonably add a note about what happens on timeout or how the tool differs from wait_for_animation.

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 both 'gone' and 'target' have descriptive schema text. The description adds context for 'gone' (loading spinners use case). However, there are two timeout parameters (timeout and timeout_ms) whose distinction is unclear even from the schema, and the description doesn't clarify which to use or the 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 states a clear verb+resource ('Waits for a widget to appear or disappear') and explains the 'gone' flag for disappearance with a specific example (loading spinners). It's clear and specific, though it doesn't explicitly distinguish itself from the sibling wait_for_animation tool, which could cause 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 gives a concrete example ('e.g. loading spinners') for when to use 'gone=true,' which implies usage context for disappearance scenarios. However, it doesn't explicitly state when to use this vs. wait_for_animation or vs. other interaction tools, nor any 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It explains that frames are pumped at ~60fps and that it does NOT wait for all animations to settle, which is genuinely informative. However, it doesn't disclose side effects like potential state divergence, leftover animation states, or whether timed-out pending timers cause errors — gaps for a pump-based 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?

Two sentences, efficient and front-loaded with the core action. No wasted words. Slight deduction because the ~60fps detail and default could be restructured, but overall tight and readable.

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 good schema coverage and no output schema, the description is adequate. However, it doesn't mention return value, whether it can throw on leftover pending timers, or edge cases (e.g., pumping when animations never finish). Given the sister tool wait_for exists, some clarification on selecting between them would round out 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?

Schema coverage is 100% (the single duration_ms parameter is documented with default and timing). The description adds minimal but useful context: duration in milliseconds, default 500, and the ~60fps frame-pumping detail that clarifies the actual behavior. Small incremental value over the schema, justifying slightly above baseline.

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 (pumps frames) and resource (specified duration), and explicitly contrasts with pumpAndSettle timing out. It distinguishes itself from what would be a natural sibling alternative (discovery tooling for animations). The hero transitions / page animations / custom animation controllers examples reinforce scope.

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

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

The description gives clear when-to-use context: hero transitions, page animations, or custom animation controllers where pumpAndSettle would time out. However, it doesn't explicitly state when NOT to use it (e.g., when you need animations fully settled) or reference sibling tools like wait_for as alternatives, so it misses the exclusion criterion for a full 5.

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