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

With no annotations provided, the description carries the full burden of disclosure. It does disclose the key behavioral detail that the cursor is moved first when x/y are provided, which is valuable. However, it doesn't mention whether coordinates are absolute or relative to the display, whether there's any delay, or what happens with multiple clicks (click interval).

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, both useful. The first states the action and defaults; the second clarifies the x/y cursor-moving behavior. Zero filler or redundancy. Front-loaded with the primary function.

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

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

With 4 optional parameters, no annotations, and no output schema, the description is brief but covers defaults. For what is fundamentally a simple click action, the description addresses the essentials. Gaps remain: coordinate system semantics, behavior of back/forward buttons, and interaction with specific displays are undocumented, but the tool is 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?

Schema description coverage is 0%, meaning the description must compensate. The description partly does: it explains that button defaults to 'left', count defaults to 1, and x/y trigger a cursor move. However, it doesn't explain the meaning of 'back'/'forward' buttons, the coordinate system (screen vs window), or clarify that x and y may be independently optional. Partial compensation, not full.

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

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

The description clearly states it clicks a mouse button with defaults (left, count 1) and explains the x/y cursor-move behavior. This distinguishes it from sibling tools like da_double_click (which is specifically a double-click) and sufficiently conveys the primary function, though it doesn't explicitly contrast with 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?

There is no explicit when-to-use vs alternatives guidance. It doesn't say when to prefer da_click over da_double_click or da_drag, nor mention any prerequisites (e.g., display must be active, coordinates must be valid for current display). The usage context is only implied by the tool's nature.

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 underlying mechanism (OCR + classification), click location (center of bbox), return values (coordinates, bbox, recognized text), and error behavior (throws NOT_FOUND). This is comprehensive and goes well beyond minimal transparency.

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

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

The description is four concise sentences, each contributing unique information: action, method, optional setting, return values, and error. It is front-loaded with the primary action and contains no redundant or filler content.

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 lacking annotations, output schema, and parameter descriptions, the description covers the core purpose, method, return values, and error conditions. The missing `displayId` parameter and lack of return format details prevent a perfect score, but overall it is complete enough for most use cases.

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

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

Schema has 0% description coverage, so the description must compensate. It explains `text` (the label) and `fuzzy` (case-insensitive matching with whitespace normalization), but completely omits `displayId`, leaving that parameter ambiguous. Partial compensation—two of three parameters are meaningfully described, but one is left 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 clearly states a specific action ('Click the on-screen element whose text label matches ‘text’'), method (OCR + UI-element classification), and result (clicks center of bounding box). It distinguishes itself from siblings like da_click (coordinate-based) and da_find_text (find-only) by combining text matching with clicking.

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 clear: click an element identified by its text label. The description gives a condition for enabling fuzzy matching but does not explicitly state when to use this tool over alternatives like da_click or da_find_text. It provides clear context but lacks formal exclusions or alternative recommendations.

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 destructive-ish action (double-click) and the optional move-to-first behavior, but doesn't disclose what the move behavior implies (e.g., does it click at current position if no x/y given?), return values, or whether coordinates are required. For a mouse-input tool, more behavioral detail would help.

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

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

Two sentences, zero waste. The description front-loads the primary action and adds the coordinate behavior succinctly. 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 two-coordinate mouse action with no output schema, this is reasonably complete. However, the description is thin on edge cases (e.g., coordinate range behavior, what happens when no x/y supplied). Given the tool's simplicity and clear schema, it's adequate but has room to add a brief usage note.

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

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

Schema description coverage is 0%, but the description notes that x/y are used for moving before double-clicking. With only 2 optional integer coordinates whose meaning is self-evident (position), and the description adding the 'moves first' behavioral note, this provides baseline useful semantics. It doesn't detail coordinate interpretation beyond 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 states a specific verb+resource ('Double-click the left mouse button') and clearly distinguishes itself from siblings like da_click (single click). The optional coordinate movement is noted. However, it doesn't explicitly frame the use case (e.g., launching an app or selecting), but the purpose is adequately clear for a mouse-action tool.

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 (double-click at a location) but provides no when-to-use vs alternatives guidance. It doesn't explicitly contrast with da_click, da_drag, or other siblings. No prerequisites or context are given, though the sibling set makes the distinction fairly intuitive.

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

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

No annotations are provided, so the description carries the burden. It discloses a critical behavioral trait: non-left buttons are accepted but ignored. This is genuinely useful transparency about a subtle gotcha. However, it doesn't mention whether dragging involves holding the button down and releasing, potential timing/duration behavior, or whether this is a press-drag-release operation.

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

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

Two sentences, zero waste. The critical button gotcha is included efficiently. Could arguably be one sentence but is appropriately concise and front-loaded with the main 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 5-parameter tool with no output schema and no annotations, the description is thin on behavioral details like drag duration, button hold behavior, and coordinate reference frame. The button caveat is a strong addition, but the lack of context about how the drag executes (speed, press-and-hold, release) leaves meaningful gaps for an agent deciding how to use 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?

Schema coverage is 0%, so the description must compensate for all 5 parameters. It explains the button parameter partially (defaults to left, non-left ignored) but provides no meaning for x1, y1, x2, y2 beyond what's implied by 'drag from/to' — coordinates, units, or screen-relative vs absolute positioning aren't specified. The button gotcha is helpful but the coordinate parameters are largely 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 clearly states the verb (drag) and resource (coordinates x1,y1 to x2,y2). It's a specific action that distinguishes itself from siblings like da_click or da_move_mouse, though it doesn't explicitly name alternatives. The purpose is clear and actionable.

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

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

The description does not state when to use this tool versus alternatives. It doesn't mention that this is for drag-and-drop interactions, or contrast it with move_mouse (which moves without clicking) or click. No exclusions or prerequisites are provided.

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

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

With no annotations, the description carries full burden. It discloses that the button is held, modifiers are held for the duration, and strict modifier pairing is enforced even on errors. It does not describe return values, coordinate system, or other side effects, leaving some 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 sentences long, front-loaded with the primary action and followed by examples and behavioral notes. Every sentence contributes meaningful information without redundancy.

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

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

For a tool with four parameters, no annotations, and no output schema, the description provides a clear overview but misses key details like the meaning of durationMs, the coordinate system for points, and any return/error behavior. The strict modifier pairing note is helpful, but overall completeness is moderate.

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 adds meaning to three of four parameters: it explains points as the path to trace, modifiers as held keys with an example, and button as the held button. However, durationMs is not mentioned at all, and the structure of points is only minimally described; schema coverage is 0%, so this partial compensation is modest.

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

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

The description clearly states the tool's action: drawing a multi-point path by tracing through points with the mouse while holding a button. It provides specific use cases (freeform shapes, signatures, circles) that distinguish it from simpler mouse tools, though it doesn't explicitly contrast with sibling tools like da_drag.

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 use cases (freeform shapes, signatures, circles as N points) and explains the modifier behavior with an example. However, it does not mention alternatives or when not to use the tool, so there's 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?

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states the tool does NOT click, throws NOT_FOUND, and explains the fuzzy matching behavior (case-insensitive with whitespace normalization). While it could add more about displayId behavior, the critical side effects and error cases are disclosed.

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

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

The description is efficiently structured: it starts with the main purpose, lists return values, notes the non-click behavior, explains the option, mentions the error condition, and ends with usage guidance against an alternative. Every sentence adds value and there is no filler.

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

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

Despite having no output schema or annotations, the description provides a good amount of context: what it returns, that it does not click, the fuzzy option, and the NOT_FOUND error. It is moderately complete, but the lack of any explanation of `displayId` and the vague 'UI-element classification' phrase leave some gaps for a tool of this 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 0%, so the description must compensate for all parameters. It explains `text` (text label to match) and `fuzzy` (case-insensitive matching with whitespace normalization), but `displayId` is not mentioned anywhere. With 3 parameters, missing one is a notable gap, making the parameter guidance adequate but incomplete.

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: 'Locate the on-screen element whose text label matches `text`'. It clearly states the return values (bounding box, center coordinates, recognized text, OCR confidence) and explicitly distinguishes itself from sibling tool `da_click_text` by noting it 'does NOT 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 provides explicit guidance: 'Use this when you need to decide an action (click vs. drag vs. type-into) based on element position; use `da_click_text` when you already know the action is "click the center"'. This gives a clear when-to-use and names the alternative tool, making the decision straightforward.

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

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

No annotations are provided, so the description carries the burden. It discloses that it returns screen coordinates (not relative or element-local coordinates), which is useful. It implies read-only behavior implicitly. However, it doesn't mention error conditions, whether the position reflects a real OS-level query, or performance characteristics. For a zero-parameter read tool, this is adequate but not rich.

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

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

A single, tight sentence that conveys purpose and return shape with zero waste. Every word adds value.

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 query tool with no output schema, the description is essentially complete. It tells the agent what it returns and in what coordinate space. There's little else a simple getter tool needs to convey. The description fully compensates for the absence of an output schema by stating the return type.

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?

There are 0 parameters, so schema does nothing. Baseline is 4 for 0-param tools since there's nothing to document. The description correctly focuses on what is returned (the { x, y } coordinate pair) rather than inputs, which 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?

Clear verb+resource: 'Return the current cursor position as { x, y } in screen coordinates.' It states what it returns and the coordinate space. It's a simple, singular tool (get position), so it naturally differs from sibling tools like da_move_mouse or da_click without needing explicit 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?

The description implies usage context (querying cursor position) but doesn't explicitly state when to use this vs alternatives. However, since it's a read-only query tool with no real alternatives among siblings (none retrieve position), the usage context is reasonably clear. No exclusions or alternative guidance provided.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The description does explain the holdMs behavior ('holdMs > 0 issues a press-hold-release'), which is useful. However, it does not disclose what happens with a plain press (does it release immediately?), whether the tool blocks until the key event completes, or what the return value is. The description adds some behavioral context beyond the bare schema.

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

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

The description is a single efficient sentence that covers the purpose, modifiers usage with a concrete example, and the holdMs behavior. No wasted words, front-loaded with the core verb+resource. Could arguably be slightly fuller but is appropriately concise for a simple key-press 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?

This is a relatively simple 3-parameter tool with no output schema and no annotations. The description explains modifiers and holdMs behavior via the example and the holdMs sentence. It doesn't explain the default behavior when holdMs is absent (0), whether repeated presses are supported, or what the return value contains. For a simple tool it's mostly adequate but leaves some ambiguity about default press 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 carry the weight for parameter meaning. The description names all three parameters ('key', 'modifiers', 'holdMs') and explains two of them in prose. The modifiers example (Ctrl+C mapping) adds practical meaning, and the holdMs semantics are explicit. Only the exact 'key' naming convention (e.g., how special keys like Enter or arrows are referenced) is left underspecified.

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 action clearly: 'Press a key by name, optionally with modifiers.' The verb+resource is specific and understandable. It doesn't explicitly differentiate from sibling tools like da_type (which types text vs presses keys), but given the sibling set includes da_click, da_double_click, da_drag, da_scroll, da_type, the distinct purpose of pressing a key by name is reasonably evident from context.

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 its usage context (press individual keys, shortcuts with modifiers) and gives a concrete example. However, it doesn't explicitly say when NOT to use it versus da_type (which presumably types strings of characters) or when a modifier combination is preferred over separate presses. The when-versus-alternatives guidance is implied rather than explicit.

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

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

Annotations are not provided, so the description carries the full burden. It mentions that argv[0] is required and that cwd, env, timeoutMs, and detached are optional, which adds some behavioral context. However, it does not disclose what happens on launch failure, whether the process is awaited or returns immediately, what the return value is (no output schema), whether timeoutMs default behavior is meaningful, or how detached mode affects the returned result. For a process-launch tool this is a notable transparency gap.

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

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

The description is a single, efficient sentence that front-loads the core purpose and then lists parameter requirements. It wastes no words and is appropriately sized for the 5-parameter tool. It could arguably add a sentence on failure behavior, but as written, it 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 lacks essential context for a process-launch tool: no output schema exists, so return behavior is undocumented. It doesn't explain whether launch is synchronous or asynchronous, what happens on exit code non-zero, whether timeoutMs causes process kill, or how detached affects the process lifetime. While the schema and complexity are moderate (5 params, 1 required, nested env object), the description doesn't cover behavioral expectations that an agent would need to interpret results correctly.

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

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

Schema description coverage is 0%, so the description must compensate. The description does mention argv, cwd, env, timeoutMs, and detached by name and notes that argv is required while others are optional. This adds meaning beyond the bare schema of required/properties. However, it provides no detail on semantics of related parameters (e.g., how env interacts with inherited environment, what detached means behaviorally, what timeoutMs default is). With nested objects present (env) and no per-parameter docs, this is only marginal compensation over a 0% coverage schema.

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

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

The description states the purpose clearly: 'Launch a program by name or absolute path.' It uses a specific verb (launch) and resource (program), and distinguishes from siblings like da_move_mouse, da_type, etc. which are all desktop automation actions. However, it doesn't explicitly name alternative tools for process management (none exist among siblings), so it doesn't differentiate at a sibling level, but the distinction from the listed action tools is obvious.

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 says when to use it ('Launch a program by name or absolute path'), which gives a clear context. However, it provides no guidance on when NOT to use it or any alternatives. It doesn't mention prerequisites (e.g., if the program must exist in PATH), behavior when the program is already running, or whether the tool waits for process completion. The guidance is implied but there are no explicit exclusions or alternative tool references.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description clearly implies a non-destructive read operation by listing metadata (id, bounds, scale, rotation, primary). It doesn't state whether it requires system permissions or how it handles multiple displays, but the read-only nature is reasonably clear from context. Since it's a listing operation with no schema hints, this is adequate if not rich.

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

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

One clean, single sentence that lists the exact data fields returned. Zero waste, no fluff, and front-loaded with the verb and resource. 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?

This is a simple, zero-parameter, no-output-schema listing tool. The description enumerating the return fields (id, bounds, scale, rotation, primary flag) is sufficient for a tool of this complexity. While there's no output schema to provide structure, the description covers the essential return value shape adequately. Could mention return format details but for a simple listing tool this is complete enough.

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

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

With 0 parameters, there's nothing for the description to explain about parameter semantics. The schema is empty and needs no compensation. The description does describe the return fields, which serves as useful semantic context for what the agent will get back. A baseline 4 is appropriate since no 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?

The description uses specific language ('List connected displays') with a clear verb and resource, and enumerates the exact data fields returned (id, bounds, scale factor, rotation, primary flag). It clearly distinguishes from siblings like da_move_mouse and da_get_mouse_position since it deals with displays rather than mouse actions.

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 this is a discovery/listing tool used to gather display metadata, which would precede operations like moving the mouse (da_move_mouse) or taking screenshots (da_screenshot). However, it doesn't explicitly state when to use it vs alternatives or mention any prerequisites. The application context is reasonable but implied rather than explicit.

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

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

No annotations are provided, so the description carries full burden of behavioral disclosure. It states it moves the cursor but doesn't disclose whether coordinates are primary-monitor-relative vs global multi-monitor, whether the move is instant (given durationMs is optional), or any OS-level quirks. For a physical-action tool with zero annotation coverage, more disclosure is expected.

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

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

Single sentence, zero waste, gets to the point immediately. The key qualifiers (absolute, screen coordinates) are front-loaded. Not verbose but appropriately brief for the simplicity of the operation.

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?

Contextual signals show a 3-parameter tool with no output schema, no enum constraints, and 0% schema coverage. durationMs is entirely unexplained. The description doesn't address coordinate system ambiguity (primary vs. virtual desktop), which is a common real-world concern for multi-monitor setups. Given the tool's simplicity, this is acceptable but leaves meaningful gaps.

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

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

Schema coverage is 0%, so the description must compensate, but it only explains what x/y mean generically ('absolute screen coordinates'). It gives no explanation of durationMs (the optional third parameter), which is completely undocumented. The description adds minimal meaning beyond what the schema property names already convey.

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

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

Description states the specific verb 'Move' + resource 'cursor' with clear scope: absolute (x,y) screen coordinates. It's distinct from siblings like da_get_mouse_position (which reads), and the absolute-coordinates qualifier differentiates from relative movements. However, it doesn't name sibling tools for disambiguation beyond the inherent 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?

No guidance on when to use this tool vs alternatives like da_drag (which also moves) or da_click. It doesn't state prerequisites (e.g., multi-monitor coordinate implications) or when this is preferred over other movement approaches. Context is implied but no exclusions or alternates are named.

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 disclosure burden. It describes the tool as a read operation (running OCR) but doesn't disclose that it depends on the Tesseract engine being installed, whether it captures a fresh screenshot internally or operates on existing data, the latency implications of running OCR, or error conditions (e.g., what happens if Tesseract is unavailable). These are meaningful behavioral considerations the agent would benefit from knowing.

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 conveys the core purpose without waste. It is front-loaded with the key action (Run OCR on a display) and output expectation. It earns its place but could ideally include more usage detail without being 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?

The tool has 2 parameters with 0% schema coverage, no annotations, no output schema, and no usage guidance. For what appears to be a computer-use/automation tool with 11 siblings, the description is materially incomplete: it doesn't cover parameter meaning, return structure beyond 'recognized text plus classified UI elements', error behaviors, or when to prefer it over da_screenshot. The description does only the bare minimum of stating the action.

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

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

Schema description coverage is 0%, so the description must compensate for the two undocumented parameters (lang, displayId). It does not explain what 'lang' represents (language code? format?) or what 'displayId' refers to (which display to run OCR on, and the null meaning). The description adds no per-parameter meaning beyond what the bare schema shows. This is a meaningful gap for a tool with zero schema coverage.

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

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

The description states a specific verb+resource ('Run OCR (Tesseract) on a display') and its output ('recognized text plus classified UI elements'). This distinguishes it from sibling tools like da_screenshot (capture image) and da_list_displays (list displays). However, it doesn't explicitly name a sibling alternative for comparison, slightly reducing differentiation 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 on when to use this tool versus alternatives such as da_screenshot for visual inspection, nor when OCR is preferable. The description implies the context (running OCR on a display for text recognition) but provides no exclusions, prerequisites, or when-not-to-use guidance. With 11 sibling tools, some usage guidance would significantly help 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?

Without annotations, the description carries the full transparency burden. It discloses the PNG format and display selection behavior, but fails to mention what happens with the captured screenshot (e.g., returned as binary, saved to file, or returned as path). This leaves a significant gap for agent reasoning.

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 covers the tool's purpose and the key parameter behavior. There is no wasted wording, and the content is efficiently organized.

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

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

For a simple one-parameter tool with no annotations and no output schema, the description covers the input semantics well but omits any information about the return value or output handling. Since no output schema exists, the description should have disclosed what happens after capture to be 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 provides only type and range for displayId, with zero description coverage. The description fully explains the meaning: null/undefined targets the primary display, while an integer targets a specific display. This adds essential 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 clearly states the tool captures a PNG screenshot, naming the exact resource and output format. It distinguishes between primary display and specific display id, which uniquely identifies this tool among siblings like da_verify_pixels and da_ocr.

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

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

The description explains when displayId should be null vs. a specific integer, giving clear usage context for the parameter. It doesn't explicitly mention alternatives, but no sibling tool provides screenshot functionality, so this is acceptable.

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 behavioral burden. It clarifies the delta semantics (positive/negative direction mapping), which is a key behavioral detail. It also explains the 'current or given cursor position' behavior, which is a meaningful behavioral disclosure. It doesn't mention stepPx behavior or any side effects, but the direction mapping is the most critical semantic detail.

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

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

The description is a single sentence that conveys the core purpose and direction semantics efficiently. It front-loads the primary action and provides the most critical disambiguation (direction mapping) inline. Could arguably have mentioned stepPx, but overall it's tight and scannable.

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 5 parameters with 0% schema coverage and no output schema, the description covers dx/dy semantics but leaves stepPx completely unexplained. For a tool with optional parameters that aren't self-explanatory from names alone (x, y, stepPx), the description should elaborate more. However, the core function is adequately specified for basic use.

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

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

Schema description coverage is 0%, so the description must compensate. It explains dx and dy semantics (pixel deltas, direction mapping) which is valuable. However, it provides no explanation of the optional x/y (cursor position) or stepPx parameters — stepPx in particular is cryptic from the schema alone (5 params, only 2 required) and the description does not clarify what it does.

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 (scroll) and resource (wheel at cursor position), and specifies the coordinate semantics (positive dy = down, positive dx = right). It distinguishes itself from sibling mouse tools (move, click, drag) by focusing specifically on wheel scrolling. It doesn't explicitly name a sibling alternative, but the purpose is unambiguous.

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

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

The description implies usage context (scrolling within a UI) and mentions it works at current or given cursor position, which is helpful. However, it doesn't explain when to prefer this over other input methods or mention any exclusions (e.g., not for canvas-panning scenarios, or when da_key/da_drag would be more 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?

No annotations are provided, so the description carries full burden. It discloses useful behaviors: empty string is a no-op, and the optional per-char delay. However, it does not mention whether typing is fast by default, whether it waits for focus to be settled, whether it fails if no focus exists, or how it handles special characters/keystrokes embedded in the string.

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

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

Two concise sentences with zero waste. Every element earns its place: the core action, the no-op edge case, and the delay parameter. Highly front-loaded and efficient.

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 relatively simple 2-parameter tool with no output schema, the description covers the essentials. However, given no annotations and 0% schema coverage, a bit more would help—for instance, whether the tool returns a success/error status, what happens when there's no active focus, and the default delay. These gaps are notable but not critical for a straightforward typing tool.

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

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

Schema coverage is 0%, so the description must compensate. It explains 'text' implicitly (the string to type) and 'perCharDelayMs' explicitly ('Optional per-char delay (ms)'). It also adds the no-op behavior for empty text. Minor gap: doesn't explicitly state that perCharDelayMs defaults to some value when omitted, though 'optional' implies a default.

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

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

The description uses a specific verb ('Type') with a specific resource ('a string at the current keyboard focus'), making the purpose unambiguous. It also distinguishes itself from the sibling da_key (which presumably presses individual keys) by specifying it types a string at the current focus, not at a coordinate or 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 implies the tool requires a pre-existing keyboard focus ('at the current keyboard focus') rather than establishing one, giving some implicit context. However, it does not explicitly state when to use this over da_key (for keystrokes/modifiers) or da_click (for focus establishment), nor does it name alternatives or 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 fully carries the behavioral disclosure burden. It transparently explains polling behavior, default timeout and max, interval, error thrown (NOT_FOUND), and the exact semantics of both predicate types (color count and diff threshold). It also mentions optional region clipping, leaving little hidden 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 dense but well-structured. It front-loads the core blocking behavior, then methodically explains the predicate types, parameters, defaults, and error behavior. Every sentence adds value, and the example cements understanding. No fluff or redundancy.

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

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

For a complex verification tool with no annotations and no output schema, the description is remarkably complete. It covers the predicate grammar, all relevant parameters (except displayId), timing behavior, and error handling. The usage example and explicit conditions for success make it sufficient for an agent to invoke the tool correctly.

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

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

The description thoroughly explains the key parameters: predicate structure (with required fields, tolerance, minCount, threshold, baseline), region, timeoutMs, and intervalMs. However, displayId is not mentioned in the description, leaving a gap for one of the five parameters. Given the schema offers no descriptions, this omission is a minor but notable issue.

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

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

The description clearly states the tool's purpose: 'Block until a pixel-level predicate holds on the next screenshot'. It uses a specific verb ('Block') and resource ('pixel-level predicate'), and distinguishes from siblings like da_wait_for_text by focusing on pixel conditions. The example 'wait until 200+ red pixels appear on the canvas' further clarifies its intent.

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: 'Use this to verify visual state after an action'. It gives a concrete example and explains the blocking behavior with timeout. While it doesn't name alternative tools, the sibling list and the pixel-specific framing imply when to choose this over text-based wait 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 provided, the description fully carries the burden of disclosing behavioral traits. It details blocking behavior, timeout defaults and max, polling interval defaults and bounds, the NOT_FOUND error on timeout, and matching semantics (substring, fuzzy). This is comprehensive and goes beyond typical descriptions for wait tools.

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

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

The description is concise but information-dense: three sentences that cover the core behavior, key parameters with defaults, error semantics, and a concrete usage example. Every sentence contributes value without unnecessary 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?

The description covers most essential aspects: purpose, matching strategy, polling, timeout, error, and intended usage. However, with no output schema, it does not state what the tool returns on success, and displayId's role is not clarified. These are minor gaps given the tool's simplicity, but they prevent a perfect 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?

Schema description coverage is 0%, so the description must compensate. It explains text (target), fuzzy (case-insensitive + whitespace-normalized), timeoutMs (default 5000, max 60000), and intervalMs (default 200, min 50, max 5000). However, displayId is not mentioned in the description, leaving its meaning dependent on reader familiarity with sibling tools or the schema.

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

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

The description clearly states the tool's purpose: it blocks until a specified text appears on the screen, using OCR and UI-element classification. It mentions timeout behavior, and by comparing match strategy to da_click_text and da_find_text, it distinguishes itself as a waiting variant rather than a find/click tool.

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 context: 'Use this after a click / key / dialog-open to confirm the new state is painted before continuing.' It also notes that the match strategy is identical to other tools, implying consistent behavior. However, it does not explicitly state when NOT to use it (e.g., for non-blocking checks), so a clear exclusion is missing.

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 excels: it discloses blocking behavior, timeout defaults/max, match strategies (case-insensitive substring, exact, regex full match), polling interval defaults/bounds, and NOT_FOUND error 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 four sentences, front-loaded with the core purpose, then parameter details, then error/usage. Each sentence adds unique, non-redundant information without unnecessary length.

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

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

For a blocking wait tool with no output schema, the description is fully self-contained: it explains behavior, defaults, error conditions, and usage context (after da_launch) while referencing da_window_list. No critical gaps remain.

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

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

Schema coverage is 0%, but the description adds critical meaning for every parameter: title matching, match strategy semantics, timeout/interval defaults and bounds, and error behavior. This goes well beyond the raw schema 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 uses a specific verb+resource formulation: 'Block until a window with a matching title appears in da_window_list'. This clearly distinguishes it from siblings like da_wait_for_text and da_window_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?

Provides explicit contextual guidance: 'use this after da_launch to wait for a newly-spawned app to finish painting before clicking inside it.' However, it does not explicitly mention when not to use the tool or name alternative tools for exclusion cases.

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 fully discloses behavioral traits: use of SetWindowPos, foreground failure indication via the `foreground` flag, NOT_FOUND error, and OS-specific dependencies (wmctrl, osascript, PowerShell). This exceeds the minimum needed for safe usage.

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 dense but every sentence earns its place: purpose, resolution, default, return value, error, and OS notes. It is well-structured and appropriately sized for the tool's complexity.

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

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

The tool has no output schema, but the description explicitly includes the return object shape and key semantics. Combined with error and environment details, the agent has everything needed to invoke and interpret the result.

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

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

Schema coverage is 0%, but the description compensates fully by explaining how each parameter is used: hwnd exact match, title case-insensitive substring, pid as optional narrowing, and bringToTop default behavior. This gives agents critical semantic understanding beyond raw types.

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

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

The description clearly states the tool's verb and resource: 'Bring a top-level OS window to the foreground' with an explicit purpose of directing subsequent da_click/da_type/da_key. It also distinguishes itself from sibling tools like da_window_list by focusing on bringing to foreground rather than enumerating windows.

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 this tool (before input actions) and explains resolution by hwnd/title/pid. It does not explicitly mention alternatives or when not to use, but the usage scenario is strongly implied, qualifying as 'clear context, no 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 load of behavioral disclosure. It reveals platform-specific dependencies (wmctrl, osascript, PowerShell), the return structure (WindowInfo with fields), and the fact that it lists only visible top-level windows. It does not discuss error cases or performance, but the core behavior is well described.

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 efficiently structured: it states the primary action first, then details return fields and platform requirements. Three sentences cover all necessary information without redundancy. Each sentence earns its place, and the format is 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 simple enumeration tool with no output schema or annotations, the description is quite complete. It specifies the output fields, platform dependencies, and a relevant usage pattern (passing `hwnd` to `da_window_focus`). It could mention edge cases like no visible windows or permission errors, but given the tool's simplicity, current coverage is adequate.

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

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

The input schema has zero parameters, so schema coverage is trivially 100%. The baseline for 0-parameter tools is 4. The description adds value by explaining how the `hwnd` field can be used downstream, but since there are no parameters to document, 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 opens with a specific verb+resource: 'List all visible top-level OS windows.' This clearly states the tool's function and distinguishes it from siblings like da_window_focus (which brings a window to the foreground) by focusing on enumeration rather than manipulation.

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?

While no explicit 'use when' or alternative exclusions are stated, the description provides context for a primary use case: obtaining an `hwnd` to pass to `da_window_focus`. It also notes platform-specific prerequisites (wmctrl, osascript, PowerShell), giving practical guidance for when the tool can be invoked. There is no clear statement of when not to use it, but the main context is implied.

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