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

Annotations already indicate readOnlyHint=true and destructiveHint=false. Description adds minimal behavioral context (type of data checked) but not side effects, rate limits, or response 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?

Single sentence is concise but lacks detailed structure. Could be improved by front-loading key usage hints without adding length.

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

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

Given the tool's simplicity and presence of output schema, the description covers the basic purpose but omits important details like what 'check' returns or effect of clearing errors.

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

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

Schema has 0% description coverage, and the description provides no information about the two parameters (session_id, clear) or their usage. Agent receives no guidance beyond raw 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?

Description states 'Check for collected errors and app exceptions,' clearly identifying the tool's function (verb 'check' with resource 'errors and exceptions'). It distinguishes from sibling tools which focus on interaction or navigation.

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 or when not to use it. Lack of context on prerequisites or appropriate scenarios.

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

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

Annotations (destructiveHint=false, openWorldHint=false) already indicate non-destructive, local action. The description adds no extra behavioral context (e.g., what happens if selector not found, whether it triggers events, or side effects). It is consistent but minimal.

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, no wasted words, front-loaded with action and object. Efficient for quick scanning.

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

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

With 4 parameters (2 required) and an output schema, the description is too brief. It omits explanation of all parameters and return value. Agents cannot fully understand how to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints at the 'selector' parameter via 'CSS selector'. It does not explain 'session_id', 'offset', or 'times'. Without this, agents may misuse parameters.

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

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

The description clearly states the action ('Click'), the object ('widget by CSS selector'), and the context ('in a running Textual app'). It differentiates from sibling tools like textual_hover (hover) and textual_press (press keys).

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

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

Usage is implied by the description (clicking a widget by CSS selector) but no explicit guidance when to use vs alternatives, no when-not conditions, and no mention of 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's addition of 'with modal indicators' provides some behavioral context, but lacks details on what the screen stack represents or how modal indicators are conveyed.

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

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

The description is a single sentence and front-loaded, but it omits critical parameter information, making it under-specifying rather than efficiently 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?

Although the tool has an output schema (reducing the need to explain return values), the description fails to cover the input parameter and does not provide enough context for the agent to use it correctly.

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

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

The description does not mention the required parameter 'session_id' at all, and the schema has 0% description coverage, leaving the agent with no understanding of what value to provide.

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 'Get' and resource 'current screen stack with modal indicators', clearly differentiating it from sibling tools like textual_query which queries widgets.

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 does not provide any guidance on when to use this tool versus alternatives such as textual_query or textual_snapshot, nor does it mention prerequisites or 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?

Annotations already declare destructiveHint=false and openWorldHint=false, indicating a safe, non-creative operation. The description adds no further behavioral context (e.g., whether it triggers hover events, requires no special permissions). It is adequate but adds no extra value beyond annotations.

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

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

The description is extremely short (one sentence), which is concise, but it sacrifices completeness. It is front-loaded with the key action, yet lacks essential details, making it under-specified rather than efficiently 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 low complexity (single action, 3 parameters) and the presence of an output schema (though unmentioned), the description fails to cover important context: it omits explanation of session_id, offset, and the return value/behavior. This leaves gaps for an AI agent to correctly invoke the 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?

With 0% schema description coverage, the description must compensate, but it only clarifies that 'selector' is a CSS selector. It does not explain the required 'session_id' (likely a browser session ID) or the optional 'offset' (purpose and format unclear). This leaves the agent with insufficient information for correct parameter usage.

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

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

The description clearly states the action ('hover') and the target ('widget by CSS selector'), which distinguishes it from siblings like textual_click (click) and textual_press (key press). However, it does not elaborate on the nuance such as 'simulates mouse hover event,' leaving some 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 provides no guidance on when to use this tool vs alternatives (e.g., textual_click for clicking, textual_press for keyboard input). No when-not-to-use or prerequisites are 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?

Annotations confirm non-destructive and not open-world; description adds 'headlessly' and 'for QA interaction' which provides some behavioral context. However, it does not disclose what happens to the app state, if sessions are reusable, or any side effects beyond launching.

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?

Extremely short at 7 words, but this conciseness comes at the cost of critical information. It is front-loaded but fails to earn its place due to lack of detail. A sentence this short should be packed with meaning, but it is vague.

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 3 parameters with 0% schema coverage, an output schema, and multiple sibling tools, the description is far from complete. It does not explain what the tool returns, how to use the parameters, or how it integrates with siblings. Substantial gaps remain.

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

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

Schema coverage is 0%, so description carries full burden for parameter meaning. It provides zero explanation for 'app_path', 'size', or 'session_id'. An agent cannot determine how to correctly supply or interpret these parameters.

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

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

The description clearly states the tool's purpose: launching a Textual app headlessly for QA interaction. The verb 'launch' and resource 'Textual app' are specific, and the context differentiates it from sibling tools like textual_click or textual_screenshot which operate on an already launched app.

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. It does not indicate that it should be used before other tools, or mention prerequisites or ordering. An agent has no context on how this tool fits into a workflow.

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

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

Annotations already indicate non-destructive and non-open-world behavior. The description adds no additional behavioral context, such as how keys are sent (sequence or simultaneous), modifier handling, or any side effects.

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

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

The description is a single sentence that directly states the tool's action with no extraneous information. It is efficiently 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?

While the tool is simple, the description omits important details like the return value (output schema exists but unmentioned) and parameter constraints. For a tool with 2 required parameters and no enum hints, more context is needed.

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

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

Schema coverage is 0%; the description does not explain the meaning or format of 'session_id' (how to obtain it) or 'keys' (e.g., whether special keys like 'enter' are valid). The agent has no guidance beyond parameter names.

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

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

The description 'Simulate key presses in a running Textual app' uses a specific verb 'simulate' and resource 'key presses in a running Textual app', clearly distinguishing it from siblings like textual_click or textual_type_text.

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

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

No guidance on when to use this tool versus alternatives such as textual_type_text for text input or textual_click for mouse interactions. The description does not mention prerequisites or 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?

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds minimal context beyond 'Query', which aligns but doesn't enhance transparency.

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

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

One sentence, 8 words, no filler. Extremely concise 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?

With two parameters and an output schema, the description covers the basic function but misses behavioral context, parameter details, and output interpretation.

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

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

Schema coverage is 0%. Description only explains 'selector' as CSS selector, but does not explain 'session_id' or provide format constraints.

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 queries widgets by CSS selector and returns properties. It distinguishes from sibling interaction tools like textual_click or textual_hover, but could specify what 'properties' means.

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 usage guidelines are provided. The description does not specify when to use this tool versus alternatives or any 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, so the description's lack of explicit safety disclosure is acceptable. The description adds context that the screenshot is 'visual' and of the 'running app', which is helpful, but does not mention potential performance impact or resolution limitations. No contradiction with annotations.

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

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

The description is a single, well-front-loaded sentence with no unnecessary words. It efficiently conveys the core purpose and key format options.

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

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

Given the tool has a required session_id parameter and an optional format parameter, the description is incomplete. It fails to explain what session_id refers to or how to obtain it, and does not list accepted format values. The output schema exists but the description omits any behavioral details like whether the output is a file path or base64 data.

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

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

With 0% schema description coverage, the description must compensate for documenting parameters. It only hints at the format parameter by mentioning 'text or SVG', but does not explain session_id or specify allowed format values. The default value and the role of session_id remain undocumented, offering minimal added value beyond the schema.

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

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

The description clearly states it captures a visual screenshot of the running app, and mentions the text or SVG format options. It is specific about the resource (running app) and verb (capture), but does not explicitly differentiate from the sibling tool 'textual_snapshot', which may have overlapping functionality.

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

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

The description provides no guidance on when to use this tool versus alternatives like textual_snapshot or textual_query. It does not specify when to choose text vs SVG format, nor any prerequisites for using the tool.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that the snapshot includes widget tree, refs, focus, bindings, and errors, which provides some behavioral context beyond annotations. However, it does not discuss performance, blocking, or output size. No contradiction with annotations.

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

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

Single sentence, 22 words, front-loaded with key action and resource. No unnecessary words. Very 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?

Tool has moderate complexity (3 params, 1 required, output schema exists). Description covers purpose but lacks parameter explanations critical for correct invocation. With 0% schema description coverage, this is a significant gap. Output schema exists but doesn't compensate for missing param info.

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

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

Schema has 3 parameters (session_id, max_depth, include_styles) with 0% schema description coverage. The description does not explain any parameter meanings, such as that max_depth limits the widget tree depth or include_styles filters style information. Description adds no value for 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 clearly states the verb 'Snapshot' and the resource 'current app state', and lists specific included elements (widget tree, refs, focus, bindings, errors). This distinguishes it from sibling tools like textual_screenshot (visual capture) or textual_query (search).

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. Does not mention when it is appropriate to snapshot vs. using textual_check_errors or textual_query. No exclusions or prerequisites.

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

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

Annotations already provide destructiveHint=true. The description adds minimal context beyond 'running,' not disclosing idempotency, confirmation, or effects on unsaved state.

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 with no wasted words, front-loading the action and resource.

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?

Adequate for a simple stop operation with destructive hint and output schema, but missing guidance on error states or prerequisites like session existence.

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

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

Schema coverage is 0%, and the description does not explain what session_id is, its format, or how to obtain it, adding no value beyond the schema.

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

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

The description clearly states the action (stop) and the resource (a running Textual app session), distinguishing it from sibling tools like textual_launch (start) and textual_press (key press).

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

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

No explicit guidance on when to use vs. alternatives or prerequisites. The purpose is implied but lacks details on when not to use (e.g., session already stopped).

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

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

Annotations provide minimal safety hints (non-destructive), but description adds no behavioral context such as whether text is appended or replaces, or how the 'submit' parameter affects the action. The agent lacks insight into 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?

Single sentence, no unnecessary words. Efficiently front-loaded and minimal.

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

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

Given 3 parameters and an output schema (not shown), the description omits crucial details like session handling, submit behavior, and return value. Incomplete for reliable agent invocation.

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

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

With 0% schema property descriptions, the description fails to explain the role of session_id, text, or submit beyond their names. No parameter meaning is added beyond the schema itself.

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

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

Description states verb 'type' and resource 'text into focused input widget', clearly indicating the action. However, it does not explicitly distinguish from sibling 'textual_press' which may have overlapping behavior.

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

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

No guidance on when to use this tool versus alternatives like textual_press or textual_click. No context about prerequisites or exclusions is provided.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds value by listing the types of conditions that can be waited on. However, it does not disclose important behavioral details such as timeout behavior, whether the tool blocks until condition is met, or what happens on failure (e.g., error vs. timeout). The output schema exists but is not referenced to clarify return values.

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 short and front-loaded with the core purpose, which is good for conciseness. However, it is overly terse and lacks any structure (e.g., bullet points for conditions). It does not fully earn its place as the sole narrative for 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?

Given the tool has 5 parameters and a rich domain (UI automation), the description is incomplete. It does not explain what the tool returns (output schema exists but is not detailed), how selectors and text are used, or the behavior of the timeout parameter. The agent lacks critical information to use the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It only partially addresses the 'condition' parameter by listing its possible values (idle, animation, workers, widget). Other parameters (session_id, selector, text, timeout) are not explained at all. The agent cannot infer semantics for these from the description alone.

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

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

The description clearly states the tool's purpose: 'Wait for a condition' and lists the specific condition types (idle, animation, workers, widget). This provides a clear verb and resource. However, it does not differentiate from sibling tools like textual_query or textual_snapshot, which might also involve waiting or checking states.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not specify prerequisites, scenarios where waiting is appropriate, or when to choose another tool (e.g., textual_check_errors). The agent is left without context for decision-making.

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