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

With no annotations, the description carries the behavioral burden and does a good job: it discloses the safe close mechanism, the verification step, and the 409 refusal condition. It could further clarify what 'verification' checks exactly and what success/failure responses look like, but the core behavior is transparent.

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

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

The description is compact, front-loaded, and every sentence earns its place: the first sentence states the action and mechanism, the second explains the safety parameters. No filler 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 simple 3-parameter tool with an output schema, the description is nearly complete: it covers the action, the safe method, and the guard parameters. Minor gaps include not stating what happens when no expect_* params are passed or how success is indicated, but these are acceptable 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?

Schema description coverage is 0%, so the description must compensate. It explains the purpose of expect_title and expect_process (safety guards that trigger a 409 on window change), adding real meaning beyond the schema. hwnd is not described, but its role as a window handle is reasonably inferable from the tool name and 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 a specific verb and resource ('Close a window safely') and provides the exact mechanism (WM_CLOSE after verification, never blind Alt+F4), which clearly distinguishes it from sibling tools like window_post or keyboard-based closing.

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 actionable usage guidance: pass expect_title/expect_process to refuse if the window changed, and explicitly warns against blind Alt+F4. It does not name alternative tools or state when not to use this tool, but the context is clear enough for an agent to recognize when to invoke it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the intended effect without mentioning potential side effects, failure conditions (e.g., if the window is minimized or unresponsive), or whether it requires special permissions. This leaves the agent without knowledge of how the operation might behave beyond the basic action.

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

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

The description is a single, well-structured sentence that immediately states the purpose with no redundant words. It is appropriately concise for a simple operation and front-loads the key 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?

Given that the tool has a required parameter (hwnd) that is undocumented, and no behavioral details are provided, the description is incomplete. The existence of an output schema (per context) is noted, but the description does not clarify what the tool returns (e.g., success/failure), leaving gaps in the agent's understanding of how to call and interpret the tool.

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

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

The sole parameter 'hwnd' has no description in the schema (coverage 0%), and the tool description does not explain it at all. An agent cannot infer that 'hwnd' is a window handle or how to obtain it, making parameter usage opaque. The description fails to compensate for the schema's lack of parameter documentation.

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

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

The description 'Bring a window to the foreground (focus it)' clearly states the action (bring/focus) on a specific resource (a window), distinguishing it from siblings like close_window or window_children. It is unambiguous and immediately tells an agent what the tool does.

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

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

The description implies the tool is used when you want to focus a window, but it provides no explicit guidance on when to prefer it over alternatives or any exclusions. There is no mention of conditions like 'use only when the window is not already focused' or when to avoid it.

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

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

No annotations are provided, so the description carries the burden. It discloses that 'start' clips cursor to center, 'move' does relative camera look by dx,dy pixels * sensitivity, and 'heartbeat' is a keep-alive during long holds. However, it doesn't disclose side effects like cursor visibility changes, whether stop restores the cursor, or what happens on 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 compact and front-loaded with the tool's purpose. The action list is dense but efficient. The pipe-separated format is a bit terse but saves space. It earns its place by covering purpose, actions, and usage in two sentences.

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 an output schema (though not shown in detail) and 4 parameters. The description covers the core actions and how to combine with keyboard/mouse, but lacks details like what the output looks like, whether sensitivity applies only to move, and edge cases like what happens if start is called twice. For a game-control tool, this is adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains dx/dy as relative camera look pixels and sensitivity as a multiplier, but it doesn't explain the 'action' parameter's allowed values beyond listing them in the description (start, move, stop, heartbeat) — which is helpful but not mapped to the schema. The 'action' parameter has no enum in the schema, so the description's list is the only guidance, but it's not structured as parameter documentation.

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

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

The description clearly identifies the tool as a game mode for FPS-style control and enumerates the specific actions (start, move, stop, heartbeat). It distinguishes itself from siblings like mouse and keyboard by framing it as a mode that combines with them, though it doesn't explicitly name a sibling alternative.

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

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

The description explains when to use the tool: for FPS-style control, and it instructs combining with keyboard() down/up for WASD and mouse(action='down'/'up') for shooting/building. It implies this is the alternative to direct mouse/keyboard for game contexts, but doesn't explicitly state when not to use it.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It states the tool lists items, implying a non-destructive read operation, but offers no details on side effects, error behavior, or what 'watchdog status' entails. For a simple getter, this is minimally transparent 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, direct sentence with no padding. It efficiently conveys the core function without irrelevant detail, achieving maximum conciseness for the tool's 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?

Given the tool has zero parameters and an output schema (assumed to document return structure), the description is sufficient for an agent to call it. The mention of 'watchdog status' adds context beyond the name, though it could elaborate on what that status means. Overall, nothing critical is missing for a straightforward query tool.

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

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

The tool has zero parameters, so the schema already fully describes the interface. The description adds no parameter semantics because none exist; a baseline of 4 is appropriate when there are no parameters to document.

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 ('List') and a specific resource ('currently held keys/buttons and watchdog status'). It distinguishes this from sibling tools like 'release_all' and 'keyboard' by implying a read-only state query, though it doesn't explicitly name alternatives. The purpose is clear and not tautological.

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 siblings. It doesn't mention scenarios where 'get_held' is preferred, nor does it state any exclusions. The tool name itself is suggestive, but the description leaves all usage context 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 what data is reported, which is the core behavioral trait for a status query, but it does not explicitly state that the tool is non-destructive or that it does not alter state beyond reading.

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

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

A single efficient sentence that front-loads the purpose ('Server/PC status:') and then packs the returned field list compactly. Every word earns its place; there is no filler or repetition of the tool name.

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

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

For a stateless zero-parameter query tool with a provided output schema, the description fully covers what the agent needs to know. The schema handles return-value structure, and the description enumerates the reported categories, leaving nothing missing for correct invocation.

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

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

With zero parameters, the baseline is 4. There is nothing for the description to clarify about arguments; instead, it properly explains what the tool's output means, which is the only relevant semantic information given no schema to compensate for.

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

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

States a specific implicit verb (retrieve/query) over a concrete resource (server/PC status) and enumerates the exact data fields returned: screen size, monitors, OCR availability, failsafe, and game-mode state. This clearly distinguishes it from siblings like screenshot and ocr_screen, which capture images or extract text, and from get_held, which reports keyboard state.

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 listed fields (OCR availability, failsafe, game-mode) imply a pre-flight environment-status use case, so usage is plausibly inferred. However, the description never explicitly says when to call this tool versus alternatives, nor states any exclusions or prerequisites.

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

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

The description discloses a key behavioral trait: expect_hwnd causes a 409 refusal if the foreground window differs, and notes that type is Unicode-safe. Since no annotations are provided, the description carries the full burden, but it omits other behaviors such as whether actions are synchronous, error handling beyond 409, or any permission requirements. It covers some but not all behavioral aspects.

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, two sentences long, and front-loads the core purpose and actions. It includes practical examples and a caution note without any fluff, making it highly readable and immediately actionable.

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 6 parameters and no annotations, the description covers the main actions and key parameters but omits details about the interval parameter and the return value (though an output schema exists). For a simple keyboard tool, this may be sufficient for basic use, but it leaves some aspects undocumented, making it not fully complete.

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

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

With 0% schema description coverage, the description compensates well by explaining the action values and giving examples for key (press), keys (hotkey), and text (type), and clarifies the purpose of expect_hwnd. It does not explain interval or the exact format of key names beyond the examples, but it provides enough to use the primary parameters effectively.

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 controls the keyboard and enumerates the actions (press, hotkey, type, down, up) with concrete examples for each, making its purpose unmistakable and distinguishing it from mouse and other input tools. It is a specific verb+resource definition without any tautology.

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 provides a usage guideline for the expect_hwnd parameter, advising to use it to avoid typing into the wrong app. However, it does not explicitly discuss when to use this tool versus sibling tools like mouse or get_held, or any exclusions. The guidance is present but not comprehensive.

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 present, the description carries the burden of explaining side effects and filtering. It clearly states the tool lists only visible top-level windows (no hidden or child windows), and the word 'List' implies a non-mutating read operation. It does not mention ordering or enumeration caveats, but these are minor for a zero-parameter read 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?

A single sentence conveys the action, scope, and output fields with no filler. The key scoping terms ('visible', 'top-level') appear up front.

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 that no parameters are required and an output schema exists, the description supplies the essential identifying fields and the central filter. An agent can call this tool correctly without needing 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?

There are zero parameters, so there is nothing to document beyond the schema's empty properties object. The description adds value by specifying what the returned rows contain (hwnd, title, process name, pid), which the schema cannot show.

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 ('List') and resource ('visible top-level windows'), then enumerates the exact fields returned. It distinguishes itself from sibling tools like window_children by narrowing scope to top-level windows and from screenshot by being an enumeration rather than a capture.

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 for when to use this tool instead of related window tools such as window_children, focus_window, or close_window. There are no exclusions, prerequisites, or alternative references, leaving the agent to infer the intended use case.

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 mentions 'text-only' and 'without OCR/vision' but does not disclose how snapshots are obtained (e.g., whether it captures them internally), potential side effects, or performance implications. This ambiguity leaves the agent uncertain about the tool's execution model.

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, front-loaded sentences pack the core purpose and usage into minimal space. No redundancy; every clause 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?

The description covers the what and when but leaves a critical gap: the mechanism of 'two snapshots' is vague. Since the tool only accepts an optional region, it's unclear whether the agent must supply snapshots or if the tool manages them internally. The output schema exists, so return format is covered, but this ambiguity undermines completeness.

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

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

The schema description coverage is 0% and the description does not mention the 'region' parameter at all. The parameter is left completely unexplained, forcing the agent to guess whether it restricts detection to a screen area or serves another purpose.

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 (detect), the resource (screen changes between two snapshots), and the output (changed tiles and clickable centers). It explicitly contrasts with OCR/vision, distinguishing it from sibling tools like ocr_screen.

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 concrete use cases ('verify an action had an effect' or 'spot movement') and explicitly frames it as an alternative to OCR/vision. It doesn't name specific sibling tools, but the context is sufficient for an agent to decide when to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses meaningful traits: physical-pixel coordinates, optional current-position click, and negative clicks for downward scroll. However, it does not mention side effects (e.g., moving the actual system cursor, affecting other applications), permissions, or reversibility. Some behavioral info is present, but gaps remain.

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 only three short sentences, front-loading the core purpose and then compactly enumerating action semantics. Every phrase earns its place, using terse notation that is easy to scan. No redundancy or filler.

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

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

The tool has 8 parameters, no annotations, and an output schema that likely documents return values. The description covers the most important parameter semantics but omits button and duration, and does not explain the effect of each action beyond coordinate mechanics. It is adequate for basic use but not complete for all parameters and possible edge 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 description coverage is 0%, so the description must compensate. It explains the meaning of action values, x/y as click coordinates (optional), x1/y1 for drag start, and clicks for scroll amount. It does not describe the button or duration parameters, leaving parts of the parameter space undocumented. Still, it adds substantial meaning beyond the raw schema.

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

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

The description states 'Control the mouse' and lists the supported actions (move, click, scroll, drag, down, up), giving a clear verb+resource statement. It doesn't explicitly distinguish from sibling tools, but the action list makes it self-evident compared to keyboard, screenshot, or window controls.

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 the mouse tool versus alternatives like keyboard or screenshot. It explains how to perform specific actions (e.g., 'click uses x,y', 'scroll uses clicks'), but not when this tool should be preferred or avoided. There is no mention of context 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?

No annotations are provided, so the description carries the behavioral burden. It usefully discloses the return shape (lines plus per-item centers for clicking) and the optional crop, and 'Read' implies a non-destructive operation. But it leaves scan_focus behavior unexplained and does not mention permission requirements or performance characteristics (OCR latency), which are material for an agent deciding whether to call 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?

Three sentences with zero waste: purpose is front-loaded, usage guidance follows, and behavior plus parameter semantics are packed into one efficient sentence. Every clause 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?

With an output schema present, return-value detail is already covered, and the description's mention of 'lines plus per-item centers' aligns with it. The main gaps are the unexplained scan_focus parameter and lack of explicit differentiation from window_capture_ocr among a large sibling list — both are things an agent needs to invoke this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains 'region' (format 'x,y,w,h' and optional crop semantics), but scan_focus is entirely undocumented in both the schema and the description — the agent cannot know what focusing behavior it toggles. With half the parameters unexplained, a 2 is appropriate.

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

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

Description states a specific verb+resource ('Read the screen as text with coordinates (OCR)') and differentiates from siblings: 'best for menus, dialogs, editors, chat — anything text-heavy' distinguishes it from screenshot (visual capture) and the sibling window_capture_ocr (window-scoped OCR). An agent can tell what this does without opening the schema.

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

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

Provides clear when-to-use context ('text-heavy' interfaces such as menus, dialogs, editors, chat). However, it does not name the alternative window_capture_ocr or state when to prefer that sibling over whole-screen OCR, so exclusions are only implied, not 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 the burden of disclosing behavior. It does state that the operation is an emergency reset and safe to call anytime, which is useful context, but it does not explain potential side effects, whether it affects the OS-level key state or only the tool's internal state, or what the response will be.

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

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

The description is two short, front-loaded sentences with no filler. The core action and emergency-reset intent come first, and the safety reassurance is appended 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 zero-parameter tool with an output schema, the description is complete: it names the action, the scope, the emergency-reset intent, and the safety profile. An agent has everything needed to invoke it correctly.

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

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

The input schema is empty and there are zero parameters, so the description does not need to explain parameter semantics. The phrase 'every held key and button' also conveys the scope of the operation.

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 ('Release') and a precise resource ('every held key and button'), and adds the clarifying parenthetical 'emergency reset'. This makes the tool's purpose unmistakable and distinguishes it from siblings like get_held, which queries held state rather than clearing it.

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

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

The phrase 'emergency reset' implies the intended use case, and 'Safe to call anytime' provides clear, unconditional context for when it can be used. However, it does not explicitly name alternatives or state when not to use it.

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

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

No annotations are present, so the description carries the full burden. It does explain parameter behavior (scale shrinks to save bandwidth, quality range, region format), which is useful. However, it does not explicitly state that the operation is read-only, nor does it disclose output format, permission requirements, or multi-monitor behavior.

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

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

Two sentences with zero filler. The main purpose is front-loaded, and the parameter hints are compact and actionable. Nothing extraneous is included.

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 no output schema, no annotations, and 0% schema description coverage, the description should handle all context. It misses the meaning of the 'monitor' parameter and fails to state the output format (e.g., base64, URL, path), making it incomplete for an agent to call correctly in multi-monitor or output-sensitive 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%, so the description must compensate. It clearly defines region as 'x,y,w,h', scale as 0-1, and quality as 1-100, adding meaning to three of four parameters. It entirely omits the 'monitor' parameter, leaving it 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 verb and resource: 'Capture the screen as an image'. 'For vision-capable models' further clarifies the intended use case, and the plain-image capture distinguishes it from OCR siblings like ocr_screen and window_capture_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 phrase 'for vision-capable models' implies a use case, but there is no explicit guidance on when to use this tool versus alternatives like ocr_screen or window_capture_ocr. No exclusions or when-not-to-use conditions 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?

The description discloses a key behavioral trait: it does NOT focus the window, which is a significant side-effect avoidance. It also explains the default ocr behavior. With no annotations provided, this is valuable behavioral 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?

One sentence, front-loaded with the most important behavior (no focus), and the ocr default is explained inline. Zero waste.

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 an output schema, so return values are covered. The description explains the core behavior and default. It could mention what happens when ocr=0, but the output schema likely covers that. Overall adequate for a 2-param 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 description coverage is 0%, so the description must compensate. It explains the ocr parameter's default and effect (returns text directly), but doesn't explain hwnd beyond the schema's integer type. The description adds some meaning but not full parameter 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 tool captures a background window without focusing it, and with ocr=1 (default) returns its text directly. This distinguishes it from siblings like screenshot, ocr_screen, and focus_window.

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

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

The description implies when to use it: when you need to read another app's content without disrupting the user's work. It doesn't explicitly name alternatives or exclusions, but the context is clear enough.

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. It clearly signals a non-mutating list operation and adds a useful platform caveat about WinUI/UWP apps having no classic children. It does not discuss edge cases like direct-versus-recursive enumeration, but for a read-only inspection tool the core behavior is sufficiently disclosed.

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

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

Two sentences with no filler. The first sentence states the core action and output fields; the second adds usage context and an alternative. Every clause 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 single-parameter tool with an output schema, the description is complete enough. It explains the target scenario, the practical follow-up action (window_post), and the main exception (modern apps). No critical calling information is missing.

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

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

Schema coverage is 0%, and the description only mentions hwnd incidentally as the child handle to pass to window_post. It does not explicitly state that the input hwnd is the parent window handle or where it should come from, though the tool name makes this mostly inferable. The description partially compensates for the missing schema detail but could be more explicit.

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 ('List') and a clear resource ('child controls of a window'), and it names the returned attributes (class name, title, hwnd). It also distinguishes the tool from siblings by framing it as the Win32 child-enumeration tool versus window_input_mode for modern apps.

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 explicitly says when this tool is useful ('classic Win32 apps with real child controls'), what to do with the results ('target the child hwnd in window_post'), and which alternative to use for modern apps ('use window_input_mode to detect them'). This is clear when-to-use and when-not-to-use 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. It discloses the output categories, including the 'invalid (dead window)' case, and implies a read-only operation ('Classify') with no side effects. However, it does not explicitly state that it performs no mutation or that it requires a valid handle, though the 'invalid' output suggests handling of dead windows. This is adequate but not rich in behavioral 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, well-structured line with line breaks separating the classification options. It contains zero filler and front-loads the purpose and timing. 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?

Given the tool's simplicity (one parameter, an output schema presumably describing the classification results), the description covers the essential context: when to use, what it returns, and edge cases (invalid). It could mention that it is read-only or requires a valid handle, but these are minor gaps for a classification 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 description coverage is 0%, so the description must compensate. It implies that 'hwnd' refers to the window being classified, but does not explicitly define the parameter or its format. Since the tool name and description make the role of hwnd obvious, a 3 is appropriate, but explicit clarification would improve it.

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 ('Classify') with a clear resource ('how a window receives input') and explicitly lists the four possible classification values. This makes the tool's purpose unambiguous and distinguishes it from siblings like window_post (which posts input) and focus_window (which focuses).

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 posting to it' provides clear temporal context, indicating this tool should be called before window_post. The classification values also imply decision logic, but no explicit exclusions or alternatives are mentioned. Still, the guidance is sufficiently clear for an agent to know when to use it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose that 'uia' routing focuses the window, which is a key side effect. It also implies background operation, but it does not explain what 'background' means in terms of window visibility or input capture, nor does it describe side effects for actions like click or scroll. The behavior is partially transparent but lacks detail on edge cases or requirements.

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

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

The description is a single, compact paragraph that front-loads the core purpose and then lists the key enums. It uses a clear 'action: ...' and 'mode: ...' format, and the note about uia routing is placed at the end as an important caveat. The structure is logical and efficient, with no filler.

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

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

The tool has 8 parameters, 2 required, and an output schema exists, but the description is insufficient for an agent to use it correctly. It omits parameter meanings, prerequisites (e.g., whether the window must be visible or minimized), and concrete examples. The note about uia routing is helpful but not enough. While the output schema may describe return values, the input side is under-specified.

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

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

The schema description coverage is 0%, so the description must compensate for the 8 parameters. It explains the 'action' and 'mode' enums, but leaves x, y, key, keys, text, and hwnd entirely unexplained. For instance, x and y are likely coordinates for click/scroll, and key/keys/text are input payloads, but the description provides no such meaning. This is a significant gap that forces the agent to guess or inspect the schema further.

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: 'Send input to a window in the background.' It lists the supported action types (type, key, hotkey, click, scroll), giving a concrete sense of what the tool does. However, it does not explicitly differentiate itself from sibling tools like mouse, keyboard, or focus_window, so an agent must infer that this is specifically for targeting a window handle (hwnd) rather than global 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?

The description provides some usage guidance by explaining mode options and recommending 'auto' for WinUI/UWP apps, and notes that 'uia' routing forces focus. However, it does not explicitly state when to use this tool versus alternatives like mouse or keyboard, nor does it clarify the trade-offs between background and focused modes beyond the note. The guidance is partial, leaving the agent to infer the appropriate context.

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