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

With no annotations provided, the description carries the full burden. 'Get' implies a read-only operation, which is a positive disclosure, but it does not mention any error conditions, accessibility requirements, or whether the position refers to the primary display. The description is minimal but not misleading; it adequately conveys the core behavior for a simple getter.

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 with no wasted words. It states exactly what the tool does without any extraneous content, achieving maximum efficiency.

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 parameters and no output schema, the description is nearly complete. It clearly indicates the purpose and the coordinate system. It does not explicitly state the return format (e.g., a tuple or object), but 'cursor position in screen coordinates' strongly implies a coordinate pair. This is adequate for an agent to call the tool successfully.

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. The description adds no parameter info, but none is needed. Per the rubric, 0 parameters earns a baseline of 4, and the description does not detract from that.

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

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

The description clearly states the specific action (get) and resource (current cursor position), and specifies 'in screen coordinates' which adds precision. It distinguishes from sibling tools like mouse_move (which changes position) and click actions. The purpose is unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any prerequisites or context. It simply states what it does without any 'use this when...' or 'instead of...' hints. An agent must infer its applicability entirely from the name and siblings.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'Double-click a target' and does not mention how the target is resolved, what modifiers or strategies affect behavior, whether a state is returned, or what side effects occur.

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 with no redundancy, but its brevity is under-specification rather than effective conciseness. It restates the tool name and omits necessary context, so the one sentence does not earn its place.

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

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

This tool has four parameters, a nested target object, two enums, no output schema, and no annotations, yet the description provides almost no contextual information. An agent cannot reliably know how to construct a correct invocation from this definition.

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

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

Schema description coverage is 0%, and the description adds no meaning to the four parameters. It does not explain the required target.type, the strategy enum, modifiers, or return_state, leaving the agent to guess their 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?

The description clearly states the action ('double-click') and the object ('a target'), making the tool's purpose immediately understandable. It is not misleading and is more specific than a pure tautology, but it does not differentiate from sibling click tools like triple_click or right_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?

There is no guidance about when to use this tool versus alternatives such as triple_click, right_click, or left_click. The description only states what the tool does, with no context, exclusions, or alternative routing.

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

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

With no annotations provided, the description carries the full burden. It states the return contents (accessibility tree and state_id) and implies that state_id becomes stale, hence the re-observe instruction. However, it does not disclose potential error conditions (e.g., invalid app_ref), permission requirements, or what happens if called repeatedly without an action. It also does not explicitly label the operation as read-only, though 'observe' implies it.

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

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

The description is two sentences, front-loaded with the core purpose and then usage guidance. Every word earns its place, with no fluff or redundancy. It is highly efficient and easy 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?

The tool has a nested object parameter, an enum parameter, no output schema, and no annotations. The description explains the return type at a high level but leaves out critical operational details such as how to construct app_ref, what 'detail' controls, and what failure modes exist. An agent calling this tool would need to infer parameter semantics from names alone, which is insufficient.

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

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

The description mentions no parameters at all. The schema has 0% description coverage, meaning neither the description nor the schema explains what 'app_ref' or 'detail' mean or how to use them. The agent is left to guess the structure of app_ref and the meaning of detail enum values. This is a significant gap that the description fails to address.

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 observes an app and returns an accessibility tree plus a state_id. The verb 'observe' and resource 'app' are specific, and the purpose is unambiguous. It does not explicitly differentiate from sibling tools, but no other sibling appears to serve the same observation role, so the purpose is sufficiently distinct.

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

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

The description provides explicit timing guidance: 'Call ONCE before acting; re-observe only after an action or when the next step needs fresh UI state.' This tells the agent when to use the tool and how often. However, it does not mention any alternative tools or conditions when this tool should not be used, so it stops short of full when/when-not guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions holding a key for a duration, but does not clarify whether the key is released afterward, whether this is blocking, or what effect 'app_ref' has on the behavior.

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

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

The description is a single, front-loaded sentence with no filler words. It conveys the essential action and unit of measure efficiently, though it is minimal in substance.

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

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

The tool has three parameters including a nested object, no annotations, and no output schema, yet the description only covers the basic hold action. An agent would not know how to construct a valid call involving 'app_ref' or what happens after the duration elapses.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It adds that 'text' likely represents the key and 'duration' is in milliseconds, but it does not explain the 'app_ref' nested object at all.

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 ('hold a key') and the duration unit ('ms'), clearly identifying what the tool does. It does not explicitly differentiate from sibling tools like 'key' or 'type', but the verb 'hold' makes the core purpose 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?

No guidance is provided about when to use this tool versus alternatives such as 'key', 'type', or 'left_mouse_down'. There is no mention of context, prerequisites, or cases where holding a key is appropriate.

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

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

With no annotations, the description must carry the behavioral burden, but it only states the core operation. It does not disclose how app_ref is used, what strategy controls, whether accessibility permissions are needed, or any side effects.

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

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

A single, front-loaded sentence with zero filler. The examples are compact and immediately clarify what qualifies as a non-text key or chord.

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?

Despite a nested app_ref object, a strategy enum, and no output schema, the description does not explain how to target an application, choose a strategy, or interpret the result. An agent only knows what to press, not how to control the press.

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

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

Schema description coverage is 0%, so the description must compensate. It provides valid examples for text, but app_ref and strategy are left completely unexplained; their roles in targeting an app and selecting an input method are not described.

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 ('Press') and a specific resource ('non-text key or explicit chord'), with concrete examples (Return, Escape, cmd+a). This clearly distinguishes it from text-entry siblings like type.

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 'non-text' qualifier implies this tool is for key chords and special keys rather than text entry, but it does not explicitly state when to prefer it over hold_key, perform_action, or type, nor does it mention any exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without explaining side effects (e.g., bringing app to foreground), prerequisites (e.g., accessibility permissions), or what happens when using coordinates versus elements. The 'background-safe' note implies a behavior but is not explicit about how it affects the click or system state.

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

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

The description is very short (two clauses) and front-loaded with the action, which is good for conciseness. However, it lacks structure that could help the agent quickly parse the key parameters. It is minimal but not overly verbose, so a 3 is appropriate.

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

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

Given the tool's complexity (4 parameters, nested target object, enums), the description is incomplete. It does not address how 'modifiers' are applied, what 'strategy' options mean, or what 'return_state' returns. There is no output schema, so the description should clarify expected results, but it does not.

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

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

Schema description coverage is 0%, so the description must compensate. It adds a small hint that element targets are preferred and background-safe, which helps interpret the 'target' parameter. However, it provides no explanation for 'strategy', 'modifiers', or 'return_state', leaving the agent to guess their meaning and impact.

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 action ('Left-click a target') with a specific verb and resource. It is distinguishable from siblings like double_click and right_click by the action itself, though it does not explicitly differentiate from similar click tools such as left_click_drag or left_mouse_down. The phrase 'Element target is preferred' hints at target handling but does not add much specificity to the core purpose.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention scenarios where a single left-click is appropriate versus double-click, drag, or other click variants. The only hint is 'background-safe' for element targets, which is more about parameter preference than tool selection, so usage context is largely absent.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Drag from one target to another' without explaining the sequence (press, move, release), how modifiers affect behavior, or any side effects. The same-app constraint is a behavioral limitation but not a disclosure of the action's mechanics. This is a significant gap for a mutating input 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 extremely concise (one sentence) and front-loads the action. However, it is under-specified for the tool's complexity. While it is not bloated, the brevity fails to cover essential details, making it structurally sparse rather than well-organized. It earns a middle score for conciseness but not for completeness.

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

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

Given the tool has nested object parameters, no output schema, and no annotations, the description is grossly inadequate. It does not explain the target types, the coordinate system, the role of state_id, or how modifiers are used. An agent would struggle to call this correctly without additional context from examples or docs.

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

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

Schema description coverage is 0%, so the description must compensate by explaining what from_target and to_target are. It merely uses the word 'target' without defining the object structure, coordinate formats, or how modifiers are applied. The description adds no semantic value beyond the schema, leaving the agent without guidance on how to fill these parameters.

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

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

The description clearly states the action (Drag) and the resource (from one target to another). It distinguishes from sibling tools like left_click and double_click by specifying a drag operation. The constraint that both endpoints must resolve to the same app adds specificity. However, it does not elaborate on what 'target' means beyond the schema, and it could be confused with mouse_down/up combinations, though the name clarifies.

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 one constraint (same app) but gives no guidance on when to choose this tool over alternatives like left_mouse_down/up or scroll. There is no mention of typical scenarios or exclusions. The 'same app' note is helpful but insufficient as usage guidance.

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

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

With no annotations, the description must carry the behavioral burden, and it does disclose the essential trait: the button remains held and must be released by a subsequent left_mouse_up. It does not describe side effects or return behavior, but for a low-level mouse action the core behavior is covered.

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

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

The description is one efficient sentence plus the critical follow-up constraint. Every word earns its place and the key behavior 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?

Despite the tool being simple, the nested target parameter is left entirely unexplained at 0% schema coverage, and there is no guidance on how target relates to sibling operations. An agent would likely need more detail to construct a valid 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?

The schema has 0% description coverage, and the description does not explain the target object or its type/index/state_id fields. 'At a target' merely restates the parameter name without specifying valid values or how to construct the object.

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 ('press and hold') and resource ('left mouse button at a target'), and the 'Must be followed by left_mouse_up' sentence distinguishes it from siblings like left_click and double_click. This is immediately identifiable.

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 clearly states the required follow-up action, left_mouse_up, which is important usage guidance. It does not explicitly contrast with alternatives such as left_click or left_click_drag, but the pairing instruction provides clear 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 provided, the description must carry the full behavioral burden. It only states the core action and does not disclose prerequisites (e.g., a prior press), side effects, or any state changes beyond the release. This is a significant gap for a mutation-like 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 a single sentence with no filler words, which is appropriately concise. The action is front-loaded. However, its brevity borders on under-specification, though that is more an issue of completeness than conciseness.

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

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

Given the tool has a nested object parameter and no annotations or output schema, the description is insufficiently complete. It does not explain the meaning of 'target', any preconditions, or how it interacts with other tools like left_mouse_down. An agent would struggle to call it correctly without additional context.

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

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

Schema description coverage is 0%, and the description provides no explanation of the 'target' parameter or its nested properties (type, index, state_id). The agent has to infer what 'target' refers to, which is a major omission for a required parameter. The description adds no semantic value beyond the schema's bare structure.

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: releasing a previously pressed left mouse button. This distinguishes it from siblings like left_mouse_down (press) and left_click (press and release), making the purpose unambiguous and specific.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The phrase 'previously pressed' implies a prior state, but it does not explicitly instruct to use it after left_mouse_down, nor does it mention when not to use it (e.g., for a single click). The usage context 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses the output fields (pid, name, bundle_id, active), which is useful, but it does not mention any potential side effects, permissions required, or behavior when no apps are running. It is not misleading, but it could add more context about the scope (e.g., all apps vs. visible apps) and the nature of the 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 a single, clear sentence that conveys the purpose and output fields without redundancy. It is front-loaded with the action and resource, and every phrase earns its place. It is appropriately concise.

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

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

Given the tool's simplicity (no params, no output schema), the description provides sufficient information for an agent to understand what it does and what it returns. It names the fields explicitly, which is helpful. However, it does not specify whether the list is sorted, limited to foreground apps, or if there are any edge cases. For a basic listing tool, this is generally adequate, hence a 4 rather than a 5.

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 is empty (100% coverage). With no parameters, the description does not need to explain parameter semantics. Per the baseline rule for 0 params, a score of 4 is appropriate; the description adds value by stating what the tool lists, even though params are moot.

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

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

The description clearly states the verb 'List' and the resource 'running applications', and explicitly enumerates the returned fields (pid, name, bundle_id, active). It is specific and unambiguous. However, it does not differentiate itself from sibling tools like get_app_state, which might also return similar info, so it loses one point for not distinguishing.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or contexts where another tool (e.g., get_app_state for a single app) would be more appropriate. The usage context is only implicit from the generic listing behavior.

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

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

No annotations are provided, so the description must carry the burden. 'List' implies a read-only operation, which is transparent. However, it does not disclose edge cases like what happens when no displays are connected or whether the operation could fail, but for a simple read operation this is acceptable.

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

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

The description is a single, efficient sentence that front-loads the action ('List all connected displays') and includes all essential details. There is no wasted words or redundant information.

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

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

For a simple, parameterless tool with no output schema, the description is sufficient. It tells the agent exactly what the tool returns (bounds and primary status) and is complete enough for an agent to decide when to call it and what to expect.

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 coverage is trivially 100%. There is nothing to explain beyond what the schema shows, and the baseline for no parameters is 4. The description adds no parameter-specific meaning, but none is needed.

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

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

The description clearly states the tool lists all connected displays, specifying the resource (displays) and the details provided (bounds and primary status). It distinguishes itself from sibling tools like list_apps and list_windows by focusing on displays.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. While the purpose is clear and the tool's role as a display-inspection operation is implied, it does not mention any conditions, exclusions, or comparisons to other listing 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, the description carries the behavioral burden. 'List' implies a read-only operation and the description discloses that bounds and focus info are returned, but it does not mention permission requirements, behavior for unknown applications, or potential errors.

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 with no filler. It names the action, the target, and the key output fields 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 tool with no annotations, no output schema, and a nested object parameter, the description is thin. It does not explain how to specify the application, whether all app_ref fields are needed, or what happens on failure, leaving important context to the agent.

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

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

Schema description coverage is 0%, and the description does not explain how to construct app_ref or which fields (pid, name, bundle_id) should be supplied. The schema itself provides property names and types, but the description adds no compensating semantic detail.

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

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

The description states a specific verb ('List'), a clear resource ('an application's windows'), and the kind of data returned ('bounds and focus info'). It is distinguishable from sibling tools like list_apps and list_displays, though it does not explicitly name them.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites such as getting an app reference first, and no stated exclusions. The intended usage must be inferred from the name and 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 carries the full burden of behavioral disclosure. It only restates the action without mentioning side effects, system requirements, accessibility implications, or what happens after the click.

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

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

The description is short and front-loaded, but it is under-specified rather than appropriately concise. It contains only a single sentence that restates the tool's basic action and omits almost all 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?

With four parameters, a nested target object, no output schema, no annotations, and many closely related sibling tools, this description is severely insufficient. An agent cannot reliably construct a correct call or distinguish middle-click behavior from other click 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 0%, and the description adds no meaning to any parameter. The nested target object, strategy, modifiers, and return_state fields are left completely unexplained.

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 ('Middle-click') and a resource ('a target'), and the tool name plus sibling list makes it clear this is the middle-click variant among left/right/double/triple click. However, it does not define what 'target' means or how it is specified, which slightly limits clarity.

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 about when to use middle_click versus triple_click, right_click, double_click, or other input tools. No context, exclusions, or alternatives are mentioned, so an agent must infer usage entirely from the name and schema.

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 key trait (no click occurs), but leaves critical behavior undisclosed: whether coordinates are absolute or relative, what the target.type field controls, how multi-display environments are handled, and what happens on out-of-bounds targets. For a tool with several display-related siblings, this is a notable gap.

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

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

A single front-loaded sentence with zero wasted words. The verb and resource lead, and the parenthetical 'hover' earns its place by disambiguating from the click operations.

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 the description covers the action, but correct invocation is blocked by the unexplained required target.type field, and there is no output schema or annotation to fill in behavior. The agent has enough to know what the tool does but not enough to call it confidently with a valid type value.

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

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

Schema description coverage is 0%, so the description must compensate. It adds the meaning 'coordinate' to the target parameter, but the required nested 'type' string field has no enum and is entirely unexplained, and the units/origin of x and y are unspecified. The agent still cannot correctly populate the required type field.

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

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

The description names a specific verb ('Move'), a specific resource ('virtual pointer'), and a coordinate target, with the qualifier 'without clicking (hover)' explicitly distinguishing it from the click-family siblings (left_click, right_click, double_click, left_click_drag). An agent can tell this is a hover-positioning operation at a glance.

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 hover qualifier implies when to use it — when the pointer must be positioned without activating a click — but no explicit when-not-to-use conditions or named alternatives are given. It does not, for example, tell the agent to prefer cursor_position when only reading the current pointer location.

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 to convey safety or side effects, so the description must carry that burden. It states the operation but does not disclose what happens when the app is already running, whether focus changes, whether permission is needed, or what the tool returns.

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 front-loads the action and target with no redundant words. The identification options are packed efficiently at the end.

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

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

With four optional parameters, no output schema, and no annotations, the description is under-specified. An agent still cannot tell whether it can call the tool with no arguments, which selector is preferred, how the `activate` boolean changes behavior, or what success looks like.

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

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

Schema description coverage is 0%, so the description must compensate. It names `name`, `pid`, and `bundle_id` as selectors, which helps, but it leaves `activate` completely unexplained and does not clarify precedence, optionality, or relationships among the 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 names a specific action ('Launch or activate'), a resource ('an application'), and the identifier options ('name, pid, or bundle_id'). This is clear and distinct from the mouse/window/display sibling tools, but the 'launch or activate' phrasing leaves the exact mode of operation ambiguous.

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

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

No guidance is given about when to use this tool versus alternatives like list_apps or get_app_state. There is no mention of why an agent might prefer one identifier over another, nor any exclusions.

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

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

With no annotations, the description carries the full burden, but it only says that an action is executed. It does not disclose side effects, permission requirements, error behavior, or what happens to the target, which matters for a mutation-style 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 a single front-loaded sentence with concrete examples and no filler. It is appropriately concise, although the brevity comes at the cost of substantive guidance.

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

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

The description is not sufficient for correct invocation. With no action enum, no parameter descriptions, no return schema, and a target object that has no documented properties, an agent cannot know what values to pass or what result to expect.

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

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

Schema description coverage is 0 percent, so the description must compensate. It clarifies that target refers to an element and action is a named semantic action, but it does not enumerate valid actions or define the target object shape, which has no documented properties.

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

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

The description states a clear verb and resource: execute a named semantic action on an element, with examples like press and show_menu. This helps distinguish the tool from the concrete sibling actions such as left_click or type, though it does not explicitly name those 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 explicit guidance about when to choose perform_action over the sibling tools. The word 'semantic' hints at higher-level actions, but the description does not state when to use it, when not to use it, or which alternatives are preferred.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only says 'Read' and does not explicitly state that the operation is non-destructive, what it returns, whether permissions are required, or how it handles an empty or non-text clipboard. The word 'Read' weakly implies no side effects, but this is not made explicit.

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, clear sentence that front-loads the action and resource. There is no unnecessary text, and the structure is optimally concise for a tool of this simplicity.

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, the description adequately states the function. It does not mention return format or edge cases, and there is no output schema to fill that gap, but the tool is simple enough that the description is largely sufficient for an agent to call it correctly.

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

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

The tool has zero parameters, so the description cannot add meaning to parameters. According to the rubric, a zero-parameter tool receives a baseline of 4 because there is no parameter documentation burden.

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 ('Read') and resource ('current clipboard text content'), which clearly identifies the operation. It is naturally distinct from siblings like write_clipboard and other action-oriented tools like left_click or type, so an agent can correctly tell it apart.

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

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

The intended use is implied by the description: call this tool when you need the text currently in the clipboard. However, there is no explicit guidance about when to prefer it over alternatives, no exclusions, and no context about prerequisites like clipboard permissions or empty clipboard handling.

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 only states that it requests permissions, but omits that this typically triggers a system prompt requiring user interaction, that it can fail if the user denies, and whether it is a blocking call. This is a significant gap for an agent deciding when to proceed with acting.

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

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

Two sentences with no filler: the purpose is front-loaded, and the usage instruction 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?

The description is sparse for a permission tool with no annotations or output schema. It doesn't explain that user approval may be required, that the call could return without granting permissions, or what happens if the user denies. An agent may incorrectly assume the call guarantees permission.

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 confirms this with 100% coverage. Per the rubric, a 0-parameter tool gets a baseline of 4, and the description correctly doesn't attempt to describe nonexistent parameters.

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

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

The description clearly states a specific verb ('request') and resource ('OS-level accessibility and screen recording permissions'). It distinguishes this tool from all siblings, which are action-oriented (click, type, list), by identifying it as the permission-granting prerequisite.

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 instruction 'Call once before acting' provides a clear temporal placement and frequency constraint, implying it should be used before any other tool. It doesn't explicitly name alternatives or conditions for skipping, but the 'before acting' context is sufficient for a permission request tool that is a prerequisite to the sibling actions.

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

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

With no annotations, the description must disclose behavioral traits, but it only states the primary effect (opening context menu). It omits any mention of prerequisites (e.g., accessibility permissions), error handling, side effects, or return behavior, leaving the agent without critical operational context.

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

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

The description is a single, short sentence, but it is under-specified rather than concise. It omits essential information about parameters and usage, making it insufficient for an agent to use correctly. The brevity is not a strength here; it is a deficiency.

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

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

Given the tool's complexity—4 parameters, one nested object, enums, and no output schema—the description is severely incomplete. It fails to explain the target specification, strategy options, modifiers usage, or return_state control, leaving most of the tool's behavior undocumented.

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

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

Schema description coverage is 0%, meaning the description explains none of the parameters. The description does not clarify the 'target' object structure, the meaning of 'strategy', 'modifiers', or 'return_state'. The description adds nothing beyond what the schema already provides, and it fails to compensate for the low coverage.

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

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

The description clearly states the action: right-click a target to open its context menu. This distinguishes it from sibling tools like left_click and double_click by specifying the exact mouse button and the expected result.

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 provided on when to use this tool versus alternatives (e.g., left_click, double_click, or context-menu alternatives). The description offers no context or conditions for selection.

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

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

With no annotations, the description carries full behavioral burden. It does not disclose prerequisites (e.g., screen recording permission), side effects, or the format of results (since there is no output schema). The description implies a read-only capture but never states what happens after capture (returns image? saves file?), which is a significant gap for a tool with no annotations.

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

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

The description is extremely concise—three short sentences, with the core action front-loaded and no superfluous content. It encodes the purpose and usage decision in minimal words, earning 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 tool with 2 optional parameters (one nested), no output schema, and no annotations, the description is incomplete. It lacks parameter explanations, return value details, and any prerequisites. While it gives clear usage guidance, the missing behavioral and parameter context prevents an agent from invoking it correctly in many scenarios.

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

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

Schema description coverage is 0%, and the description does not explain any parameters. The parameters app_ref and display_id are undocumented, leaving the agent to guess their meaning. The description only says 'full-display screenshot,' which does not clarify how display_id or app_ref influence the capture, so it fails to add value beyond the schema's bare property names.

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

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

The description states a clear verb-resource pair: 'Capture a full-display screenshot.' It also differentiates the tool from its sibling get_app_state by explicitly stating when it is appropriate ('when accessibility cannot express the target and pixel coordinates are needed'), which separates it from other UI tools like clicks and key presses.

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

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

The description provides explicit usage guidance: 'Prefer get_app_state' and 'Use this only when accessibility cannot express the target and pixel coordinates are needed.' This tells the agent when to use this tool versus the alternative, leaving no ambiguity.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the direction convention but fails to explain what target refers to, how the scroll is executed, what the strategy parameter does, or any side effects. This is insufficient for an unannotated 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 a single, tightly worded sentence with no redundant information. It front-loads the core action and direction, achieving maximum conciseness without sacrificing the primary message.

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

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

Given the tool's complexity—a nested target object, an enum strategy, and no output schema—the description is far too sparse. It omits essential details about target semantics and strategy selection, making it difficult for an agent to invoke the tool correctly without additional inference.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It only explains dx/dy via 'delta' and positive direction, leaving target's structure and strategy's enum values completely unexplained. The agent has no guidance on how to construct the target object or choose a strategy.

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), the resource (target), and the direction convention (positive = down/right). It is specific enough to distinguish from sibling mouse actions like click or move, leaving no ambiguity about its core purpose.

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

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

The description implies usage for scrolling but provides no explicit guidance on when to choose this tool over alternatives, nor does it mention any exclusions or prerequisites. The context of sibling tools makes it obvious, but the description itself lacks direct guidance.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does not state whether the selection is visual, requires focus, or has side effects. It only says 'select a text range', which is insufficient for a tool with a nested target object and multiple parameters.

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

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

The description is a single sentence, which is concise and easy to parse. However, it omits essential details about parameters and usage, and the brevity works against completeness. It is not front-loaded with the most important constraints beyond the basic purpose.

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

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

For a tool with three required parameters including a nested object, and no output schema or annotations, this description is severely lacking. It provides no information on how to construct the target, interpret start/end, or what the outcome is. An agent cannot reliably use this tool based solely on this description.

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

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

Schema description coverage is 0%, and the description provides no explanation of the parameters. It does not define what 'start' and 'end' represent (e.g., character offsets), nor does it clarify the structure or meaning of the 'target' object (type, index, state_id). This is a critical gap for correct invocation.

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

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

The description states a clear verb 'select' and resource 'text range within an editable element', which distinguishes it from click-based siblings and value-setting tools. However, it doesn't explicitly name or differentiate against other selection or editing tools, so it stops 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?

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites, when not to use it, or any alternative tools. The agent is left to infer its usage from the name and description alone.

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 adds a meaningful trait by saying the operation is 'atomic', which implies the value is set in one operation rather than through incremental typing. It does not mention permissions, failure modes, or what happens to existing content, leaving some behavioral gaps.

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

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

The description is one short sentence that front-loads the core action and then gives the sibling preference. There is no redundant content or wasted wording.

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

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

For a tool with two required parameters, one of which is a nested target object, and with no output schema or annotations, the description is too thin. It provides useful atomicity and preference hints, but it does not explain how to construct `target` or what constraints apply when setting a value, making correct invocation uncertain.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies that `value` is the value of an editable element. The nested `target` object with `type`, `index`, and `state_id` is completely unexplained, leaving the agent to guess how to address the element.

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 and resource: 'Atomically set the value of an editable element.' It also distinguishes itself from the sibling tool `type` by explicitly saying it is preferred over `type`, so an agent can identify the correct tool immediately.

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 routing guidance by naming `type` as the alternative and stating that `set_value` is preferred over it. However, it does not explain when `type` should be used instead or provide any exclusion conditions, so it stops short of full when-to-use/when-not-to-use coverage.

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 transparently discloses that the call is immediate and that pending actions are invalidated, which are meaningful side effects beyond the name alone. It does not mention whether the operation is idempotent or reversible, but for a stop command the key behaviors are stated.

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

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

Two short sentences deliver the purpose and the key behavioral consequence with no filler. The critical information is front-loaded 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 parameterless stop command with no output schema, the description covers what the tool does and what effect it has. It could add context about what happens if no active control session exists, but this is a minor gap given the low 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?

The tool has zero parameters, so the schema fully defines the interface. The description adds no parameter-specific meaning because none is needed. Baseline 4 is appropriate for a parameterless tool.

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 ('stop'), a specific resource ('active control session'), and an immediate effect. It clearly distinguishes this from siblings like request_access or perform_action, which are about initiating or executing actions rather than terminating them.

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

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

It clearly implies the intended use case—terminating an ongoing control session—but it does not explicitly state when to prefer this over alternatives, nor does it address scenarios such as repeated calls or sessions that are already inactive. Basic context is present but no exclusion guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but doesn't explain whether the switch is persistent, what happens to the previously active display, whether permissions are needed, or how invalid indices are handled.

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 with no filler and the action verb front-loaded. It is appropriately short, though it could afford a brief clause about the parameter without becoming verbose.

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, annotation-free tool, the missing explanation of 'index' is a critical gap. The description conveys the overall purpose but not enough for an agent to determine what value to pass or how to obtain valid ones.

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 provides only a bare 'index' field with 0% description coverage, and the description never mentions the parameter. The agent is left without any indication of what index means (zero-based? from list_displays? valid range?), making it impossible to invoke correctly without external knowledge.

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 ('Switch') and resource ('active display'), and explicitly scopes the tool to 'screenshot and coordinate operations,' which distinguishes it from siblings like list_displays and cursor_position. The action and its domain are immediately clear.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't mention list_displays as the way to discover valid indices, nor does it describe scenarios that would warrant switching the display.

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 only says 'Triple-click a target' and does not disclose what happens after the click, whether it requires accessibility permissions, how the target is resolved, or what the return value is. This is a significant gap for an input automation tool.

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

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

The description is extremely short and front-loaded, which is efficient, but it is under-specified rather than concise. A single sentence can be acceptable, but here it omits essential context that would justify its brevity.

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

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

Given the tool has 4 parameters, a nested target object, enums for strategy and return_state, and no output schema, the description is far from complete. It does not explain how to specify the target, what strategies are available, what modifiers do, or what return_state controls. An agent cannot reliably invoke this tool correctly based on the current definition.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain any parameter semantics. The schema shows a nested target object with x, y, type, index, and state_id, plus strategy, modifiers, and return_state, but the description adds no meaning beyond the field names. The agent must guess how target.type, strategy, and modifiers interact.

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 'Triple-click a target.' states a specific verb and resource, and the name triple_click makes the action clear. However, it does not distinguish itself from siblings like double_click, left_click, or perform_action, and it does not explain what a triple-click accomplishes or when it is useful.

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 triple_click versus alternatives such as double_click, left_click, or perform_action. The description does not mention context, prerequisites, or exclusions, leaving the agent to infer usage from the name alone.

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, but it only states the basic action. It does not disclose whether typed text replaces or appends content, whether accessibility permissions are required, what 'app-scoped target' means behaviorally, or how the 'strategy' modes affect 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 a single, front-loaded sentence with no filler. It earns its place by stating the action and target scope, though it is too terse to carry all necessary context.

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

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

The tool has a nested target object, an enum-based 'strategy' parameter, no output schema, and no annotations. The description does not explain how to construct a target, when 'strategy' matters, or what side effects typing may have, leaving an agent under-equipped for anything beyond the simplest 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 0%, so the description must compensate. It adds minimal meaning by identifying 'text' as the content to type and 'target' as an element or app-scoped target, but it leaves the nested target fields and 'strategy' enum entirely unexplained.

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 verb and resource: 'Type text into an element or app-scoped target.' This makes the core purpose understandable. However, it does not differentiate from sibling tools like 'key' or 'set_value', which could also be relevant for text-like input.

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 such as 'key', 'set_value', or 'write_clipboard'. The description also does not explain when to choose among the 'strategy' values or when a target should be 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, the description carries full behavioral disclosure. It clearly indicates the tool blocks/pauses execution for the provided duration and that the only effect is a time delay. This is accurate, though it omits details like valid range or potential timeouts.

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 that conveys the action, the unit, and the sequencing. No filler or repetition.

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

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

For a one-parameter sleep tool with no output schema, the description is nearly complete. It could add a brief note about return behavior or accepted ranges, but these are minor for an agent deciding to invoke it.

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 provides only a type for 'duration' with no description, so the description's clarification that the value is in milliseconds is valuable. It gives the agent the essential semantic needed to call the tool correctly.

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

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

The description uses an explicit verb ('Wait') with a specific resource/duration and states the unit. It is unambiguous and distinct from all listed siblings, none of which perform a delay.

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 'before proceeding' implies the tool is used as a pacing step, but the description does not explicitly state when to prefer it or mention any alternative/condition. This is adequate but leaves the when-to-use guidance 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates that the tool writes text and does not mention that existing clipboard contents are overwritten, whether any return value is produced, or whether system clipboard access is 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 a single, front-loaded sentence with no wasted words. It states the action and target immediately, making it easy to parse quickly.

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 with no output schema, this is a minimally viable description. However, it lacks behavioral context such as overwriting the clipboard, platform expectations, or any side effects, leaving an agent without full confidence about the operation's exact behavior.

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

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

Schema description coverage is 0%, so the description must compensate, but the single parameter is named 'text' and its purpose is obvious from the sentence 'Write text to the clipboard.' The description does not add meaningful detail beyond the schema, but the parameter is simple enough that this is not a major gap.

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

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

The description uses a specific verb ('Write') with a clear resource ('text to the clipboard'), so the core action is unambiguous. It is distinguishable from the sibling read_clipboard by its antonymic purpose, though it does not explicitly name or contrast that sibling.

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

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

The description provides no guidance about when to use this tool versus alternatives such as read_clipboard, set_value, or perform_action. It does not state prerequisites, exclusions, or conditions that should lead an agent to choose this tool.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says it zooms; it doesn't mention whether the zoom is view-only, whether it changes selection state, how to reset, or what 'current raster' means. This is a significant transparency gap for a tool without annotation support.

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

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

The description is a single front-loaded sentence with no filler. However, it is so brief that it omits essential context about the required 'target' parameter, making it more under-specified than genuinely concise.

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

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

The tool has a required nested 'target' object, an optional 'region', no output schema, and no annotations. The description doesn't clarify what 'target' is, how the zoom result is returned, or how this tool fits with sibling coordinate-select workflows. An agent cannot reliably construct a correct call beyond guessing required property names.

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

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

Schema description coverage is 0%, so the description must compensate. It ties 'region' to the zoom operation, but it says nothing about 'target'—which is the only required parameter—nor about coordinate units or the role of x/y/width/height. The required parameter is left completely unexplained.

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

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

The description states a clear verb-resource pair ('zoom into' + 'current raster') and adds the purpose ('precise coordinate selection'). It doesn't explicitly differentiate from siblings, but the operation is distinct enough in the context of click/drag/scroll 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 'for precise coordinate selection' implies when to use the tool, but the description doesn't say when not to use it or how it relates to siblings like mouse_move, cursor_position, or left_click. The intended context is conveyed only implicitly.

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