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

No annotations are provided, so the description carries the full behavioral disclosure burden. It makes the read-only nature of the check reasonably clear and mentions that instructions are provided if permission is missing, but it does not specify the exact return format, whether user interaction might be involved, or explicitly confirm that no state is changed.

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

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

Two focused sentences with no filler. The core action is front-loaded, followed by the practical context and the fallback behavior.

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

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

For a simple parameterless permission check, the description covers what it does, why it matters, and what happens if permission is missing. Adding an explicit note about the return value or confirming no side effects would make it fully complete, but nothing critical is missing for correct invocation.

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

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

The tool has zero parameters and schema coverage is 100%, so there are no parameter semantics for the description to clarify. The baseline of 4 applies because no additional parameter documentation is needed.

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

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

States a specific verb ('Check') and resource ('Accessibility permissions') and ties it directly to UI element detection and programmatic interaction. This clearly distinguishes it from sibling accessibility tools that operate on the tree or perform clicks.

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

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

Explicitly identifies the prerequisite context: accessibility permissions are required for UI element detection and programmatic interaction. It also explains what happens if permissions are not granted. It does not name explicit alternatives or when-not-to-use scenarios, so it falls just short of a 5.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It usefully reveals that the tool performs an accessibility 'press' rather than a synthetic mouse event. However, it does not mention accessibility permission requirements, behavior when no matching element is found, or potential side effects, leaving some operational uncertainty.

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 front-loaded sentence that states the action, mechanism, and advantage over alternatives without wasted words. Every clause contributes to understanding how to use 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?

For a tool with only three parameters and no output schema, the description covers the core invocation details well and explains why it exists. It omits permission prerequisites and error/matching behavior, which are relevant but not fatal given the sibling accessibility_check tool and the simplicity of the operation.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds minimal new parameter information beyond reinforcing that title is optional and that role/title together select the element. Most semantic detail is already in the schema.

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

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

The description opens with a clear verb and resource: 'Click a UI element by its accessibility role and optional title.' It also distinguishes itself from coordinate-based clicking by explaining that it uses an accessibility 'press' action, which separates it from sibling mouse_click 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 concrete guidance on when this tool is preferable: it is 'more reliable than coordinate-based clicking for buttons, menu items, etc.' This implies usage for accessible UI elements, though it never explicitly names alternatives like mouse_click or specifies exclusion cases where coordinate clicking would be better.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It makes the read-only nature clear and states the return contents, but it does not mention edge cases such as invalid coordinates, no element at the position, coordinate system/scaling, or accessibility permission requirements.

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 efficient sentences: the primary action, the return payload, and the practical use case. No redundant information or filler.

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

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

For a simple two-parameter read-only getter with no output schema, the description covers what it does, what it returns, and when it is useful. It lacks edge-case details like no-element or coordinate validity, but those are minor for this tool's complexity.

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

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

Schema description coverage is 100% since both x and y parameters are clearly documented as screen coordinates. The description reinforces the coordinate-based purpose but adds no meaning beyond the schema.

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

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

The description uses a specific verb and resource: 'Get the UI element at a specific screen coordinate.' It also names the returned data (role, title, value, position, size), which clearly differentiates it from sibling tools like accessibility_tree or ai_find_element.

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

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

The description gives a clear context for use: 'identifying what is under the mouse cursor or at a specific screen location.' It does not explicitly name alternatives or state when not to use it, but the intended scenario is concrete and helpful.

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

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

With no annotations, the description carries the burden of explaining behavior. It makes the read-only nature clear with 'Get', describes the return structure (hierarchical tree of UI elements with role, title, value, position, size, state), and notes maxDepth controls detail. It does not mention permission requirements or failure behavior, but for a read-only inspection tool this is reasonably transparent.

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

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

Three concise sentences, each earning its place: the first states the primary function, the second describes the return data, and the third gives practical depth guidance. It is front-loaded and free of fluff.

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

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

There is no output schema, so the description compensates by describing the returned tree's contents and fields. It covers the key calling options adequately for a simple read-only tool, though it omits edge cases like accessibility permission requirements and what happens when no app matches the pid.

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%: pid and maxDepth are already well documented in the schema. The description's mention of maxDepth adds little beyond what the parameter description already offers, so the baseline of 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 states a specific verb ('Get') and resource ('accessibility UI element tree of an application'), then enumerates the contents and distinguishes it from screenshot-based approaches. This clearly separates it from the many 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?

It gives clear usage context: this is the primary way to understand the screen without screenshots, and it advises using maxDepth for detail level. It does not explicitly name alternatives or say when not to use it, so it falls 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?

The description discloses meaningful behavior: it searches the accessibility tree of the frontmost app and returns elements with exact coordinates, implying a read-only operation. With no annotations provided, though, it leaves gaps around failure behavior, multiple-match handling, accessibility permissions, and what happens if no element is found.

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

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

The description is three sentences and front-loaded with the core action and return value. The '[AI-Optimized]' prefix adds little and the final sentence partly restates the opening, but the overall length is appropriate 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?

Core usage is covered: what to pass, what the tool searches, and what it returns. Since there is no output schema and no annotations, the description could be more complete about the result shape, matching behavior for multiple elements, and error cases, though the tool is relatively simple.

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

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

Schema description coverage is 100%, so the baseline applies. The description's mention of 'natural language' and 'frontmost app' mostly echoes the existing schema descriptions rather than adding new meaning beyond them.

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 ('Find a UI element by description in natural language'), the resource ('accessibility tree of the frontmost app'), and the result ('returns matching elements with their exact coordinates'). It does not explicitly name a sibling distinction, but the search-by-description behavior separates it from generic tree or point-based accessibility 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 phrase 'Use this to locate buttons, text fields, menu items, etc.' gives a concrete context for when to invoke the tool. However, it does not mention alternatives like ai_screen_elements, accessibility_tree, or accessibility_element_at, nor does it state when not to use this tool.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It reveals that OCR runs through the macOS Vision framework and that returns include positions, but it omits important operational details such as screen-recording permission requirements, coordinate system/units, and behavior when no text is found.

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

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

The description is two sentences with no wasted words. It front-loads the primary function and output, then adds the usage rationale in a second concise sentence.

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

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

There is no output schema, so the description's 'Returns recognized text with positions' is the only return-format guidance. Important context is missing: required permissions, coordinate system, and failure behavior. For a simple 4-parameter tool this is acceptable but has 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 description coverage is 100%: each parameter is described as a 'Region X coordinate' or similar. The description adds 'screen region' context but does not clarify coordinate origin or units, so it provides no additional semantic value beyond the schema 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 states a specific verb ('Extract'), resource ('screen region'), and method ('macOS Vision framework OCR'), and specifies the output ('recognized text with positions'). It also distinguishes itself from accessibility-based siblings by noting it is for text not accessible via the accessibility API.

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

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

The description gives clear context: 'Useful for reading text that isn't accessible via the accessibility API.' This tells the agent when to prefer this tool over accessibility-based alternatives. However, it does not explicitly name which sibling tools to use instead or state exclusions, so it stops short of a 5.

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

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

With no annotations, the description carries the behavioral burden, and it discloses what the tool returns (screenshot with grid overlay, accessibility tree with interactive elements, mouse position, frontmost app info). 'Capture a snapshot' implies a non-mutating read, and the enumeration makes the behavior concrete, though it does not mention permission requirements or performance costs.

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 front-loads the core purpose and uses a numbered list to compactly enumerate returns, making the structure easy to parse. The final two sentences earn their place by giving the primary use case and an explicit alternative; no filler or redundant restatement exists.

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

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

There is no output schema, so the description compensates by listing all four return categories and their key contents. It covers primary usage and the main alternative, though it does not specify output details such as coordinate formats or tree structure, which are mildly relevant but not essential for invoking the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters clearly. The description adds slight semantic alignment (e.g., coordinate grid overlay maps to gridSpacing, accessibility tree maps to maxDepth), but it does not materially increase parameter understanding 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 opens with 'Capture a comprehensive snapshot of the current screen state for AI analysis', giving a specific verb and resource, then enumerates four concrete return components. It also explicitly differentiates from ai_screen_elements by stating that tool is for clicking, so the agent can distinguish this from an overlapping sibling without inspecting schemas.

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

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

It states a clear use case ('Good for understanding screen context') and provides an explicit when-not: 'For CLICKING elements, prefer ai_screen_elements which gives precise coordinates.' This is a direct alternative-selection signal, satisfying the when/when-not/alternative requirement.

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 explains the underlying mechanisms (accessibility tree for native apps, Chrome DevTools Protocol for web), describes the exact return format (annotated screenshot, element list, web: prefixes), and states the accuracy advantage. This is rich, non-obvious behavioral context that goes well beyond a basic summary.

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

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

The description is front-loaded with the key usage directive and organized with numbered return points, making it scannable. It is slightly repetitive in its preference messaging ('PREFERRED', 'Always prefer this') and has some promotional tone, but each sentence still contributes useful 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 tool with no output schema and no annotations, the description provides a complete picture: what it detects, how it detects it across native and web contexts, what it returns, how results are formatted, and why its coordinates are preferable. An agent has enough information to select and invoke this tool correctly without further guessing.

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 (pid and maxWidth) are already fully documented in the input schema. The tool description adds no additional parameter-specific semantics, which matches the baseline score of 3 for high schema coverage.

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

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

The description clearly states that the tool auto-detects all interactive UI elements and returns an annotated screenshot plus a numbered element list with center coordinates. It differentiates itself from manual screenshot coordinate guessing and makes its scope ('when you need to click or interact with UI elements') immediately apparent, even though it doesn't explicitly contrast with named 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?

It gives explicit usage timing: 'Use this FIRST when you need to click or interact with UI elements' and 'Always prefer this over screenshot+manual coordinate guessing.' This provides clear context for when to use it, but it does not mention when not to use it or name alternative tools such as ai_find_element or accessibility_tree.

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

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

With no annotations, the description carries the behavioral burden. It is upfront about the main side effect ('Auto-launches a CDP-enabled Chrome if needed') and about navigation when a URL is provided. It also clarifies that the result includes screen coordinates intended for mouse_click, giving agents a concrete sense of the output shape. Exact return format and tab-state changes are not disclosed, but the core behaviors are covered.

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

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

The description is front-loaded with the action and mechanism, and each sentence adds either launch behavior, usage context, or element-type detail. The '[AI-Optimized]' tag is mild filler, and 'ALL interactive elements' overlaps slightly with the later enumeration, but overall it is compact and easily parsed.

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 scan tool with no required parameters and no output schema, the description covers the main inputs, the optional Chrome launch behavior, and the kind of results returned. It would be even stronger with explicit return-structure details and an explicit contrast to ai_screen_elements or accessibility_tree, but an agent has enough context to invoke it correctly.

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

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

All five parameters already have complete schema descriptions, so the baseline is 3. The description adds little beyond restating URL semantics and emphasizing the coordinate output for mouse_click; it does not clarify cdpPort, tabIndex, includeText, or visibleOnly beyond what the schema already provides.

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

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

Describes a specific action ('Scan ALL interactive elements'), a concrete resource ('a web page'), a mechanism ('Chrome DevTools Protocol'), and an output detail ('screen coordinates for mouse_click'). The enumeration of element types makes it clear that this targets DOM/web elements, distinguishing it from screen-based or accessibility-tree 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?

Provides direct invocation guidance: supply a URL to navigate and scan, or omit it to scan the current page, and notes that Chrome will auto-launch if needed. However, it never explicitly says when to choose this tool over close siblings like ai_screen_elements or accessibility_tree, so the comparative usage decision is left to inference.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It explicitly states that the tool does NOT actually click and only shows the animation effect, which is a critical non-mutating behavior. It doesn't mention side effects or blocking behavior, but for a simple visual feedback tool this is reasonably transparent.

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

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

The description is highly efficient: three short sentences with no filler. The primary action is front-loaded, the key non-click clarification is immediate, and the usage context is stated clearly. Every sentence earns its place.

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

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

For a simple tool with fully documented parameters and no output schema, the description covers purpose, behavior, and usage adequately. It could add coordinate-system context or mention that the animation is transient, but these are minor gaps and not essential for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no extra meaning about the coordinates, color, or button style beyond what the schema provides, so the baseline score 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 specific action: 'Show a visual click ripple animation at the specified coordinates.' It explicitly distinguishes itself from an actual click by saying 'Does NOT actually click,' which separates it from sibling tools like mouse_click and accessibility_click.

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 clear usage context: 'Use for visual feedback.' It also implicitly excludes the main alternative (actual clicking) by explicitly stating the tool only shows the animation effect. However, it does not name alternatives or provide when-not-to-use conditions beyond that.

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

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

With no annotations, the description carries the burden of behavioral disclosure, and it does convey the core visual behavior: a pulsing border and optional label over a rectangular region. However, it does not clarify whether the highlight is a non-interactive overlay, whether it auto-dismisses after a duration, or whether it blocks clicks to underlying elements. These are meaningful gaps for an animation tool.

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

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

The description is two sentences with no filler. The first sentence front-loads the action and visual effect, and the second sentence adds the use case. Every word earns its place.

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

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

For a simple parametric tool with all parameters documented in the schema, the description covers the essential purpose and usage context. The main gap is the lack of behavioral detail about overlay behavior and dismissal, but the schema's duration default and the simplicity of the tool keep this from being a major deficiency.

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

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

Schema description coverage is 100%, so the input schema already documents all seven parameters thoroughly. The description adds only a small amount of semantic context (e.g., that the label is shown above the highlight, implied by 'optional label'). This aligns with the baseline of 3 for fully covered schemas.

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

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

The description states a specific action ('Highlight a rectangular region on screen') with a distinctive visual effect ('pulsing border and optional label'), and names the intended use case ('draw attention to UI elements'). This clearly differentiates it from sibling animation tools like animation_click, animation_trail, animation_type, and animation_scroll, which perform different effects.

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

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

The description explicitly says when to use it: 'Use to draw attention to UI elements.' This gives a clear purpose and context. It does not name specific alternative tools or state when not to use it, but for a simple visual-highlight tool, the guidance is sufficient.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly discloses the most important behavior: this tool does not actually scroll, only displays an animation. It does not detail side effects or return behavior, but for a non-destructive visual indicator the main safety-relevant trait is covered.

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

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

Two short sentences with no filler. The first sentence states the purpose, and the second sentence prevents a critical misinterpretation about scrolling. Every word earns its place.

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

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

For a simple visual indicator tool with no output schema, the description and fully documented parameters are nearly sufficient. Minor gaps remain around coordinate-system basis and return value, but these are unlikely to prevent correct invocation.

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

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

Schema description coverage is 100%, with each parameter already documented including the color default and direction enum. The description adds no additional semantic meaning about how x and y are interpreted or how direction affects the animation, so the baseline score 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 uses a specific verb 'Show' with a clear resource 'visual scroll direction indicator animation' and explicitly disambiguates by saying 'Does NOT actually scroll.' This distinguishes it from mouse_scroll and other animation siblings without needing to inspect schemas.

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

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

The description gives clear context: this is a visual-only animation, not an actual scroll. It explicitly tells the agent when not to expect scrolling behavior. However, it does not name an alternative like mouse_scroll for actual scrolling, so routing guidance is slightly incomplete.

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 honestly states that the tool is a visual-only animation and that the mouse is not actually moved, which is the key behavioral trait. It does not mention return behavior or whether it blocks, but the core non-mutating nature is explicitly disclosed.

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

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

Two sentences, no filler. The main purpose is stated first, and the critical caveat about not moving the mouse is given its own sentence. Every word earns its place.

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

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

For a simple visual animation tool with only three well-documented parameters, the description covers the essential usage: it shows a trail, takes coordinates, and does not move the mouse. Minor gaps like return value and whether execution is synchronous are not critical given the tool's simplicity.

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

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

The input schema already describes points, color, and duration with 100% coverage, so the baseline is 3. The description's phrase 'along a path of coordinates' reinforces the meaning of the points parameter but does not add meaningful semantic detail beyond the schema.

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

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

The description uses a specific verb 'Show' with a clear resource: a visual mouse movement trail along a path of coordinates. The explicit caveat 'Does NOT actually move the mouse' sharply distinguishes it from mouse_move and other animation tools in the sibling set.

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

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

The description clearly communicates that this tool is for visual feedback only and explicitly rules out actual mouse movement, which guides the agent away from using it for real cursor movement. It does not explicitly name an alternative like mouse_move, but the exclusion is clear enough in 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?

With no annotations, the description carries the behavioral disclosure burden. It surfaces the critical caveat that the tool only shows an animation and does not perform actual typing, which prevents misuse. The wording also implies a non-mutating visual operation.

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

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

The description is two short sentences with the purpose front-loaded and the critical behavioral caveat placed second. Every sentence earns its place, with no repetition of schema details.

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

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

For a simple visual-effect tool with fully documented parameters, the description covers the essential behavioral context: it is a visual animation only, not actual typing. Nothing necessary for a correct call is missing.

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

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

The input schema already describes all four parameters (x, y, text, and color) with 100% coverage, so the description does not need to explain them. The description adds no new parameter-specific semantics beyond reiterating that coordinates and text are used, meeting the baseline for high schema coverage.

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

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

The description uses a specific verb and object: 'Show a visual typing indicator animation with text at specified coordinates.' It also clearly distinguishes itself from actual typing by stating 'Does NOT actually type — only shows the animation,' which differentiates it from keyboard_type and other animation siblings.

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

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

The description clearly frames the tool as a visual-only effect and states an explicit exclusion: it 'does NOT actually type.' This tells an agent not to use it when real keyboard input is needed, though it does not explicitly name an alternative such as keyboard_type.

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 accurately communicates that the tool performs a read-only listing and specifies the exact data returned, including active/hidden status. No hidden side effects or mutation is suggested, so this is sufficient for a simple list 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?

A single sentence that immediately states the action and resource, then lists the returned fields with no filler or redundancy. Every word contributes to the agent's understanding.

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 listing tool, the description is complete: it names the resource, the scope ('all running'), and every field the agent can expect in the output. No output schema exists, but the description fills that gap adequately. Sibling differentiation is also implicit through the application-vs-window distinction.

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 the baseline of 4 applies. The description does not need to explain parameter meaning because there are no inputs to document or configure.

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 ('List'), a clear resource ('all running applications'), and enumerates the exact fields returned (name, PID, bundle ID, active/hidden status). This distinguishes it from sibling tools like window_list, which target windows rather than applications, without needing to open schemas.

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

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

The description clearly implies 'use this when you need a list of running applications' and its field list differentiates it from window- or mouse-related siblings. However, it does not explicitly state when to prefer this tool over alternatives, nor does it mention any exclusions or context such as permission requirements.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It does state the operation is a read and is limited to text content, which communicates non-destructiveness. However, it does not mention what happens with non-text clipboard data, an empty clipboard, or whether reading can fail.

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 one tightly scoped sentence with no filler or redundant phrasing. It front-loads the action and resource immediately, making it easy for an agent to parse.

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-argument, no-output-schema tool, the description is mostly complete: it specifies the platform, the clipboard, and that text content is returned. It could still mention edge cases like non-text clipboard contents or permission requirements, but the core invocation context is clear.

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

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

The tool has zero parameters and schema coverage is 100%, so there is no parameter documentation gap. Per the baseline for 0-parameter tools, the description does not need to compensate for missing parameter details.

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 ('Read') and names the exact resource ('current text content from the macOS clipboard/pasteboard'). It clearly distinguishes itself from the sibling tool clipboard_write by focusing on reading rather than writing.

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

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

The description clearly implies this tool is used whenever the agent needs the current clipboard text. There is no alternative read-focused sibling, so no exclusion is strictly necessary; clipboard_write is obviously the complementary write tool even though it is not named explicitly.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only states the operation and does not disclose that existing clipboard contents will be overwritten, any persistence or format limitations, or what the tool returns after completion.

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, clearly structured sentence that states the action and target up front with zero redundancy. It is appropriately sized for a tool this simple.

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 definition is minimally adequate for a one-parameter write operation, but because there are no annotations and no output schema, it leaves small gaps such as overwrite behavior and return/error semantics. These gaps are not critical for a simple clipboard operation but prevent a higher score.

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

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

The schema already fully describes the single required parameter ('text') with 100% coverage, so the description adds no extra semantic detail. It aligns correctly with the parameter's meaning but provides no additional formatting, encoding, or edge-case guidance.

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 clear action verb ('Write') and names the target resource ('macOS clipboard/pasteboard'), making the tool's function immediately obvious. It is naturally distinguished from the sibling clipboard_read by the write/read polarity.

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 implied use is to set the clipboard to the provided text, and the sibling clipboard_read suggests the complementary operation. However, there is no explicit when-to-use guidance, exclusions, or scenario-based direction for preferring this tool over alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action and key syntax but does not mention whether the hotkey is sent globally, whether it can trigger system-level shortcuts, whether it blocks or waits, or what happens if the combination is invalid. The examples help, but significant behavioral context is missing.

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

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

The description is compact, front-loaded with the core action, and every sentence contributes value. The examples are highly practical and immediately clarify the expected input format without unnecessary elaboration.

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

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

For a single-parameter tool with no output schema, the description provides sufficient context to understand the input format and likely behavior. It is not fully complete—missing details about global/system-level behavior and error cases—but the low complexity and strong examples make it adequately usable.

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

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

Schema description coverage is 100%, so the schema already documents the 'keys' parameter and its '+' separator format. The description adds useful examples like 'cmd+c' and 'ctrl+cmd+f', reinforcing key naming conventions, but it largely repeats the schema's meaning rather than adding new semantic depth.

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 operation: 'Press a keyboard shortcut / hotkey combination.' It is specific about the resource (hotkey combination) and includes concrete examples that convey intent. However, it does not explicitly differentiate from the sibling tool keyboard_press, which could overlap in an agent's understanding.

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 keyboard_press or keyboard_type. The examples imply it is for hotkey combinations, but there is no explicit 'when to use' or 'when not to use' guidance, leaving the agent to infer the selection criteria.

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

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

With no annotations, the description carries the behavioral burden. It does state the core action ('press a key') and that modifiers are optional, and it defines accepted values. However, it does not disclose whether the press is a discrete tap versus a hold, how modifiers are applied/released, or any focus/permission requirements, leaving some behavioral 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?

Two purposeful sentences with the core action first, followed by compact lists of keys and modifiers. No filler, no repetition of schema internals beyond what is useful; lists are structured for easy 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?

For a simple two-parameter keyboard tool with no output schema and 100% schema coverage, the description covers key and modifier syntax sufficiently. The main missing context is behavioral ('tap' semantics) and alternative routing to keyboard_type/keyboard_hotkey, which are more usage-guideline than completeness issues.

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?

Input schema already provides 100% coverage with examples and a default for modifiers, so baseline is 3. The description adds the full allowed key set, key aliases, and modifier names, going beyond the schema's terse examples. It still leaves 'symbols' unspecified, but overall it materially enriches parameter semantics.

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

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

States the action explicitly ('Press a key with optional modifier keys') and enumerates the key and modifier space, so an agent knows exactly what resource/action is involved. It does not explicitly contrast with keyboard_type or keyboard_hotkey, so it falls just short of full sibling differentiation.

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

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

No guidance about when to use this tool instead of keyboard_type, keyboard_hotkey, or other input siblings. The context signals show sibling keyboard tools, but the description never mentions them nor any exclusions or prerequisites. Usage is only implied by the action verb.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does reveal meaningful behavior: character-by-character typing, real keyboard simulation, and Unicode support. However, it omits important context like the need for an active focus target and what happens when there is no focused input field.

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

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

The description is two compact sentences with no wasted words. The core action is front-loaded, and the Unicode support note adds useful detail without bloating the text.

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

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

For a single-parameter tool with no output schema, the description is nearly complete. It explains what the tool does, how it behaves, and what input it accepts. The main gap is the lack of any mention of focus requirements or failure behavior, but the description is still sufficient for straightforward 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?

The schema only documents 'text' as 'Text to type', and coverage is 100%. The description adds real semantic value beyond this by specifying that the text is typed sequentially rather than inserted, and that Unicode including Chinese, Japanese, and emoji is supported. This helps the agent know what kinds of strings are safe to pass.

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 precise action and resource: typing a string of text character by character, simulating real keyboard input. This clearly distinguishes it from siblings like keyboard_press and keyboard_hotkey, which handle individual keys rather than full text strings.

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

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

The description implies when to use it: when text needs to be entered as real keyboard input rather than pasted. However, it does not explicitly name alternatives such as keyboard_press or keyboard_hotkey, nor does it state exclusions like 'when only a single key is needed'.

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 only restates the click action and defaults already present in the schema, and it omits key operational details such as whether coordinates are global screen coordinates, whether the pointer moves first, or whether accessibility permissions are required.

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

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

The description is two short sentences with no filler. It front-loads the core action and compresses supported options and defaults efficiently.

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

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

For a side-effecting input tool with no annotations and no output schema, the description leaves important operational details unspecified, such as coordinate system, coordinate origin, and pointer movement behavior. It is minimally viable for basic calls but incomplete for reliable use alongside the sibling mouse and screen tools.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's mention of button variants and click counts adds little beyond what the parameter descriptions already state, and it does not clarify coordinate units or origin.

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

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

The description clearly states the specific action ('Click the mouse at specified coordinates') and enumerates supported button and click-count variants. This is enough to distinguish it from sibling mouse tools like mouse_move and mouse_drag, though it does not explicitly name 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?

There is no guidance on when to use mouse_click versus related tools such as mouse_move, mouse_drag, accessibility_click, or animation_click. The only implied usage is the bare action described in the first sentence.

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 explaining behavior. It only says 'drag' and lists use cases; it omits critical details such as whether this performs a press-hold-move-release sequence, which mouse button is used, coordinate system conventions, and potential side effects. This is a meaningful transparency gap for an input-injection tool.

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

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

The description is two short sentences with no redundancy. The core operation is front-loaded, and the second sentence adds valuable use-case context. Every word earns its place.

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

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

Even with full parameter schema coverage, a GUI automation agent would still need to know coordinate-space semantics and the exact button-drag behavior to use this tool correctly. There is no output schema and no annotations to fill these gaps, so the description leaves important operational context unstated.

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

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

The input schema already describes all five parameters, including units for duration and a default value, so schema coverage is 100%. The description adds no parameter-specific meaning beyond what the schema provides, matching the baseline of 3.

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

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

The description clearly states a specific action — dragging the mouse from one position to another — and reinforces it with concrete use cases such as drag-and-drop, text selection, and window resizing. This distinguishes it well from sibling mouse tools like mouse_move and mouse_click.

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 contextual use cases for when dragging is appropriate. It does not explicitly mention alternatives like mouse_move for simple movement or mouse_click for clicks, but the stated use cases provide sufficient situational 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?

Annotations are absent, so the description carries the full burden. It adds one genuinely useful behavioral detail — the top-left origin coordinate convention — which prevents a common coordinate-system error. However, it does not disclose whether movement is instant or animated, whether accessibility permissions are required (relevant given the accessibility_* and animation_* siblings), or what happens with out-of-bounds coordinates.

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 totaling roughly 18 words, with zero wasted content. The action sentence comes first, followed by the coordinate convention. It does not redundantly restate parameter names or schema details, and every word earns its place.

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

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

For a simple 2-parameter tool with no output schema, the description covers the action and the most critical contextual fact (coordinate origin). The main gaps — usage routing versus mouse_drag and permission requirements — are real but minor given the tool's low complexity; an agent can make a correct call from this description plus the fully documented schema.

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

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

Schema description coverage is 100%: both x and y are already documented as pixel offsets from left and top respectively. The description's top-left origin note slightly reinforces this but adds minimal new meaning beyond the schema. Baseline 3 applies because the schema already documents both parameters fully.

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

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

The description states a specific verb (move), resource (mouse cursor), and target (screen coordinates x, y), which unambiguously distinguishes it from sibling tools: mouse_click, mouse_drag, mouse_scroll, and the read-only mouse_position. An agent can identify what this tool does without inspecting its schema.

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 mouse_move versus alternatives. There is no mention of when mouse_drag may be the better choice (press-drag-release), when mouse_position is needed for reading current coordinates, or any conditions or prerequisites. The agent must infer usage entirely from the tool name and sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals a non-obvious point: the return includes coordinates in two different origin conventions (CoreGraphics top-left and AppKit bottom-left), which is essential for correct interpretation of the result. It also implies a side-effect-free read 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?

A single front-loaded sentence starts with the action and then adds the critical coordinate-system caveat. There is no filler, redundancy, or vague language. Every word earns its place.

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

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

For a zero-parameter, read-only tool with no annotations and no output schema, this description is complete. It explains the semantic content of the return value (both coordinate systems) and leaves no prerequisites or side-effect concerns ambiguous. The exact return shape is not necessary for selecting or invoking 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?

The tool has zero parameters, so the schema trivially covers 100% of them. With 0 params, the baseline is 4; the description adds no parameter details because none are needed. No additional semantic information is required.

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 ('Get') and resource ('current mouse cursor position on screen'). It also clarifies the two coordinate systems returned, which distinguishes it from sibling mouse action tools like mouse_move, mouse_click, and mouse_drag. An agent can tell exactly what this tool does without ambiguity.

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

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

The description provides clear context: use this tool whenever the current cursor position is needed. It does not explicitly name alternatives, but no sibling tool performs the same read operation, so the usage is unambiguous. There are no exclusions or conditional alternatives to document.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It usefully explains the sign conventions for deltaY and deltaX, but it does not state whether the pointer moves, whether coordinates are absolute screen coordinates, what units the deltas use, or whether scroll events are injected as wheel events.

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 with no filler. The core action is front-loaded, and every sentence contributes useful directional semantics.

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 four-parameter tool with fully documented schema, the description is adequate but not complete. It lacks context on coordinate system, delta magnitude units, focus requirements, and whether the scroll affects the element under the coordinates or requires a prior mouse position.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mostly repeats what the schema already states about positive/negative delta directions, adding little new semantic meaning beyond the structured parameter descriptions.

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

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

The description clearly states the action: scroll at specified coordinates. It is specific enough to distinguish from mouse_move, mouse_click, and mouse_drag, though it does not explicitly differentiate itself from the sibling animation_scroll.

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 alternatives like animation_scroll or keyboard-based scrolling. There are no exclusions, prerequisites, or conditions to help an agent decide between sibling tools.

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

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

With no annotations and no output schema, the description carries the burden of explaining behavior. It does disclose the informational nature of the tool and the specific output fields (resolution, position, scale factor, visible area), which implies a read-only operation. However, it does not describe return format, data types, or any edge cases like disconnected or mirrored displays.

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

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

The description is a single, well-structured sentence that front-loads the action and resource, then lists the key return fields. Every word adds value and there is no redundancy.

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

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

For a simple, parameterless information-retrieval tool, the description covers the main purpose and the expected output categories. Because there is no output schema and no annotations, listing the return fields is helpful. It could be slightly more complete by specifying the return format, but the tool's simplicity keeps the gap small.

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

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

The tool has zero parameters and the schema properties object is empty, so there is no parameter ambiguity to clarify. The description fully covers the tool's interface by indicating what data will be returned. This matches the baseline for parameterless tools.

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 ('Get information') and a clear resource ('all connected displays/screens'), and enumerates the kind of data returned (resolution, position, scale factor, visible area). It does not explicitly contrast itself with siblings like ai_screen_context, but the scope is unambiguous enough for an agent to identify what this tool does.

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?

There is no guidance on when to choose this tool over alternatives such as screenshot, window_list, or ai_screen_context. The intended context is only implied by the description itself: when display/screen metadata is needed. No explicit exclusions or alternative-routing information 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?

With no annotations provided, the description carries the full burden and does more than restate the name. It discloses output optimization, optional grid/compression/cropping behaviors, and a perceptual bias caveat. It stops short of detailing error behavior or what happens with invalid window IDs, but for a read-only capture tool this is strong disclosure.

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

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

The description is compact and front-loaded. Every sentence earns its place: scope, output orientation, routing to the preferred alternative, and a practical positional correction. There is no filler or unnecessary 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?

For a zero-required-parameter tool with full schema coverage, the description is nearly complete. It covers what the tool does, when to use it, what to prefer instead, and a useful visual bias tip. The main omission is distinguishing explicitly from screenshot_annotated among the siblings, plus minor edge-case behavior for windowId.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The description's mention of grid overlay, compression, and region cropping essentially paraphrases schema properties without adding new semantic detail such as coordinate conventions or interaction between 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 opens with a specific verb and resource: 'Take a screenshot of the entire screen or a specific region.' It also clarifies the output purpose ('optimized for AI analysis') and distinguishes the tool from ai_screen_elements, which is for finding clickable elements. This makes the tool's purpose unambiguous and differentiates it from key siblings.

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

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

Usage guidance is explicit: prefer ai_screen_elements when clickable elements are needed, use screenshot only for a raw visual overview or verification, and even warns about visual Y-axis estimation bias. This tells the agent exactly when to choose this tool and when to select an alternative.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It clearly discloses the core behavior—capturing a screenshot and drawing labeled markers—but does not explain the output format, whether an image file is produced, coordinate origin, or any permission requirements. The behavior is straightforward and not misleading, but details are missing.

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

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

The description is two tight sentences with no filler. The primary action is front-loaded, and the use case is stated briefly and clearly.

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 and its parameters are fully documented in the schema, but there is no output schema and the description does not specify what the tool returns—such as image path, base64 data, or an annotated image object. The phrase 'for AI reference' hints at the output purpose but does not define it, so an agent still has some uncertainty about invocation results.

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

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

Schema description coverage is 100%, so the schema already explains the parameters. The description merely echoes 'points' and 'labels' without adding meaningful information about coordinate semantics, coordinate origin, or maxWidth behavior, so it stays at the 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 tool takes a screenshot and annotates specific points with labels, which distinguishes it from the plain 'screenshot' sibling. It is specific about the action and resource, though it does not explicitly contrast with ai_screen_context or other alternative tools.

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

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

The description provides a use case: marking UI elements, buttons, or areas of interest for AI reference. This gives some context for when to use the tool, but it does not explicitly say when to prefer it over alternatives like screenshot, ai_screen_context, or ai_find_element, and it gives no exclusion criteria.

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 disclosing behavior. While 'Execute AppleScript code' implies code execution, the description does not mention that this can run arbitrary code, cause side effects, or require macOS permissions; the examples ('controlling apps') hint at side effects but never warn about them.

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

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

The description is two sentences with the core verb-resource first and use cases second. Every word earns its place, with no redundant restatement of schema details.

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

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

For a tool with only two parameters and full schema coverage, the description is enough to invoke it correctly. However, since there is no output schema and this is a code-execution tool, the definition leaves out what the tool returns, how errors surface, and any permission/environment requirements, so it is not fully 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%, so the schema fully documents the script and timeout parameters. The description doesn't add parameter-level details beyond what the schema already says; it only provides use-case color, so the 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 the core action with a specific verb and resource: 'Execute AppleScript code.' It also names concrete use cases (controlling apps via AppleScript dictionaries, showing dialogs), which clearly distinguishes it from sibling terminal_execute tools that run shell commands.

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

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

The description gives clear context for when to use the tool ('macOS-specific automation,' controlling apps, showing dialogs), but it does not explicitly state when to avoid it or name terminal_execute as an alternative for shell commands. This is clear context without exclusions, so 4 rather than 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 adds some useful behavior: default shell is zsh, timeout defaults to 30 seconds, and arbitrary shell syntax is supported. However, it does not disclose safety-critical traits such as potential side effects, whether stderr is included in output, exit code behavior, or what happens on timeout.

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

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

The description is three short sentences with no filler. It front-loads the core action, then adds the most important capability and defaults. Every sentence contributes useful 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?

The description covers the basic execution flow and key defaults, but with no output schema or annotations, more return behavior detail would help. It does not explain output format, error handling, or how this tool relates to background execution variants. For a powerful shell execution tool, some of that context is missing.

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

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

Schema description coverage is 100%, so the input schema already documents all five parameters. The description repeats the shell and timeout defaults but does not add new meaning beyond that, such as the implications of cwd or env. A baseline score 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 states a clear, specific action: execute a shell command in the macOS terminal and return output. It also usefully scopes capabilities to pipes, redirects, and chaining. However, it does not explicitly distinguish itself from sibling tools like terminal_execute_background or terminal_applescript.

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 general context about running shell commands, but it provides no explicit guidance on when to use this tool versus terminal_execute_background or terminal_applescript. It does not state any exclusions or conditions, such as preferring background execution for long-running commands.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It usefully reveals that the call returns a PID immediately and that the process can be stopped with terminal_execute. However, it does not mention output handling, shell environment, lifecycle after the tool returns, or potential side effects of arbitrary command execution.

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

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

The description is compact and front-loaded: the first sentence states the core action, the second states the key return value, and the third gives the stop procedure. Every sentence earns its place with no filler.

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

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

For a low-complexity tool with two parameters and no output schema, the description covers the essential facts: background execution, immediate PID return, and a termination path. Minor gaps such as stdout/stderr behavior or shell environment details are not critical for an initial correct call.

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% for both command and cwd, so the schema already documents the parameters. The description adds no specific parameter-level details beyond general background execution semantics, which matches the 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 uses a specific verb and resource: 'Start a long-running process in the background' and states the immediate PID return. This clearly differentiates the tool from its foreground sibling terminal_execute, which is also referenced.

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 ('long-running') and gives a follow-up action via terminal_execute, but it does not explicitly say when to choose terminal_execute_background over terminal_execute for launching commands, nor does it state exclusions. Usage context is clear but not fully specified.

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 explaining behavior. It states only that the front window will be closed, but does not disclose consequences such as potential loss of unsaved work, irreversibility, or what happens if no window is available.

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, direct sentence with no filler or redundant content. It is appropriately sized for such a simple tool and immediately conveys the action.

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

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

For a one-parameter tool with no output schema, the description is minimally adequate. However, because closing is destructive and there are no annotations, the description should ideally warn about unsaved changes or mention that window_minimize is a non-destructive alternative. These gaps prevent it from being fully complete.

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

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

The schema already describes appName as 'Application name' with 100% coverage, so the description adds no additional parameter meaning. The parameter is simple and self-explanatory, but the tool description does not clarify how appName is matched or how 'front window' is determined.

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 ('Close') and the resource ('the front window of an application'), so an agent can understand the core purpose. It does not explicitly contrast with sibling tools like window_minimize, but the verb 'close' makes the operation reasonably distinguishable.

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?

There is no guidance on when to use window_close versus alternatives such as window_minimize, window_focus, or window_resize. The description implies a simple dismissal of a window, but it gives no context about preferences, safety, or alternative operations.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does usefully disclose that matching is partial and case-insensitive, and it states the foreground/focus effect. However, it does not mention failure behavior, permission requirements, or side effects on other windows, leaving notable 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 two short sentences with no filler. The primary action is front-loaded, and the important matching caveat follows immediately. Every word earns its place.

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

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

For a simple one-parameter tool without an output schema, the description is largely complete: it explains the action, target, and name-matching semantics. It could be more complete with a note on prerequisites or failure behavior, but the essential calling information is present.

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

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

The schema already documents appName fully with examples, so the baseline is 3. The description adds valuable parameter-relevant semantics by stating that matching is partial and case-insensitive, which affects how appName should be provided and interpreted.

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

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

The description uses a specific verb and resource: 'Bring an application to the foreground and focus it.' It clearly states the target and action, and the partial case-insensitive matching detail helps distinguish it from sibling tools like window_list, window_resize, and window_minimize.

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?

There is no guidance on when to use this tool versus alternatives, such as window_list for discovering names or accessibility_click for interacting with specific UI elements. The description implies its use for focusing an app, but does not provide exclusions or routing to sibling tools.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. The verb 'List' clearly implies a read-only, non-mutating operation, and the description explicitly scopes behavior to *visible* windows, which informs the agent that hidden or minimized windows may not be included. It does not mention permissions or failure behavior, but for a simple list operation this is reasonable.

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

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

Two sentences, no filler. The first sentence states the action, scope, and output fields; the second provides the practical purpose. Every word earns its place and the most important information is front-loaded.

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

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

For a parameterless listing tool with no output schema, the description is nearly complete: it names the output fields and a use case. A minor gap is that it does not describe the exact return format (e.g., array ordering or OS permission requirements), but those are low-stakes for this kind of tool.

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

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

The tool has zero parameters and the schema fully defines that, so there is no parameter ambiguity. The description still adds value by enumerating the output fields, which indirectly tells the agent what data it will receive.

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

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

The description uses the specific verb 'List' and names the resource ('visible windows on screen'), then enumerates the returned fields: app name, window title, position, size, and process ID. This clearly distinguishes it from sibling manipulation tools such as window_focus, window_resize, and window_close, and even from apps_list.

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

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

The description gives concrete use cases: understanding what is currently open and finding window IDs for screenshots. It does not explicitly contrast against related tools like apps_list or the window_* commands, so it stops short of a full 5, but the context is clear enough for an agent to know when to call it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the core action but does not mention whether the application is brought to front first, what happens when the app has no front window, whether accessibility permissions are required, or how the system behaves when the app is already minimized.

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 short sentence that front-loads the action and target. There is no redundant wording, filler, or repetition of the tool name.

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

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

For a simple one-parameter tool this is minimally adequate: it names the action and the target. However, with no annotations and no output schema, it leaves unresolved practical details such as whether the app must already be active, what constitutes the 'front window', and what happens if the app is not running.

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 only parameter, appName, is already described as 'Application name'. The description adds mild context by indicating that appName identifies the application whose front window will be minimized, but it does not go beyond what the schema already communicates.

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 identifies a specific action ('Minimize') and a specific resource ('the front window of an application'), which clearly distinguishes it from sibling window tools like window_focus, window_resize, and window_close. The verb-plus-object construction leaves little doubt about what the tool does.

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 instead of window_close, window_focus, or other window operations. There are no conditions, prerequisites, or exclusions stated, so an agent must infer the appropriate use case solely from the tool name and one-line description.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It states the core operation but omits important details such as coordinate system/origin, whether coordinates are absolute, behavior when multiple windows match appName, or what happens after the operation. This leaves meaningful behavioral 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, concise sentence with no filler. The verb and object are front-loaded, and every word contributes to the meaning.

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 required parameters, no output schema, and no annotations, this one-line description is too thin. It does not explain coordinate semantics, how to reliably determine appName, or what success or failure looks like, leaving an agent under-informed for a call with many required inputs.

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

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

Schema description coverage is 100%, with each parameter individually described, so the baseline is 3. The description adds little semantic value beyond labeling x/y as coordinates and width/height as dimensions; it does not explain units, origin, or coordinate 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 states a precise action ('move and resize') on a specific resource ('an application window') with explicit details ('coordinates and dimensions'). This clearly differentiates it from sibling window tools like window_focus, window_minimize, and window_close, which have distinct purposes.

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 such as window_focus or window_close, nor any prerequisites like obtaining the appName via window_list. An agent is left to infer the appropriate context.

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