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

With no annotations, the description carries the burden of behavior disclosure. It explains the click action and optional movement, but does not clarify whether coordinates are absolute or relative, nor does it mention prerequisites or side effects. Basic behavior is clear, but some behavioral context is missing.

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

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

The description is concise, starting with the core purpose in one sentence, followed by a clear args list. No redundancy or filler; every sentence 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 simple 3-parameter tool with no annotations, the description covers core functionality and parameter semantics well. The main gap is the ambiguous coordinate system, but the presence of an output schema reduces the need to describe return values. Overall, it is reasonably complete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description compensates by explaining each parameter: button enum values, and x/y as optional coordinates to move to before clicking. It adds meaning beyond the schema (e.g., the optional move behavior), but lacks details on coordinate system/units.

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 'Click a mouse button, optionally at a specific position' with a specific verb and resource. It distinguishes from sibling tools like send_key (keyboard) and scroll by focusing on mouse click behavior.

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

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

Usage context is implied (use when you need to click a mouse button) but no explicit when-to-use or when-not-to-use guidance is given. It does not mention alternatives or exclusions, leaving the agent to infer from the tool name and description.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions that it returns a dictionary with hardware details, but does not explicitly state that it is read-only, has no side effects, or note any permissions or system impact. This is a minimal behavioral disclosure.

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

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

The description is extremely concise (two short sentences) and front-loaded with the primary purpose. The 'Returns:' line adds a clear output expectation. No wasted words.

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, the description is minimally adequate: it states the purpose and return type. However, given the existence of the sibling 'nanokvm_info' and the lack of an output schema, the description does not fully disambiguate the tool or provide enough detail about what 'hardware information' includes.

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

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

The tool has zero parameters, so the description does not need to explain them. The schema confirms no parameters, and the description adds no parameter-related information, which is acceptable for a parameterless tool.

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

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

The description clearly states the tool's action ('Get NanoKVM hardware information') with a specific verb and resource. It differentiates from most siblings (power, mount_iso, send_key, etc.) but not from 'nanokvm_info', which likely also provides information about the device.

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

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

No guidance is provided about when to use this tool versus alternatives like 'nanokvm_info'. The description does not state any prerequisites, exclusions, or context in which this tool should be preferred.

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

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

No annotations are present, so the description must carry the burden of behavioral disclosure. It only says 'reset', but does not mention potential side effects (e.g., temporary video loss, renegotiation time, or whether it is a soft/hard reset). This lacks the transparency needed for a hardware-affecting 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?

Two short sentences, front-loaded with the action, and no unnecessary information. Every word earns its place.

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

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

For a zero-parameter tool with an output schema present, the description covers the primary purpose and a concrete triggering condition. It is nearly complete, though it could briefly note that the reset may interrupt the current display session, but this is a minor gap.

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 there is nothing to explain. The baseline for 0 params is 4, and the description adds no unnecessary parameter details, which is appropriate.

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

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

The description clearly states the action ('Reset the HDMI connection') with a specific resource. It is unambiguous and distinct from sibling tools like 'nanokvm_hdmi_status' (status checking) and 'nanokvm_reset_hid' (different interface).

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 clear use case ('Useful if video is not displaying correctly') that tells the agent when to invoke it. However, it does not mention alternatives or explicitly state when not to use it, stopping short of a full 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states the return type (dictionary) and the key fields (connected, width, height), making the tool's read-only nature and output structure clear. However, it does not specify behavior when HDMI is disconnected (e.g., null values), which is a minor 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 concise and front-loaded with the core purpose in the first sentence. The return value breakdown adds necessary detail without fluff, making every sentence earn its place.

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

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

For a simple zero-parameter status tool with no output schema, the description is fully complete. It explains both the primary action and the exact structure of the return value, so an agent knows what to expect 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?

The tool has zero parameters and the input schema is empty, so no parameter documentation is needed. Per baseline, a zero-parameter tool gets a 4; the description adds value by explaining the returned data, which is more relevant than parameter details.

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

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

The description uses a specific verb ('Get') and resource ('HDMI connection status and resolution'), immediately clarifying what the tool does. It is clearly distinguished from siblings like nanokvm_hdmi_reset (an action) and nanokvm_led_status (different resource), making the purpose 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 for reading HDMI status but does not explicitly state when to use it versus alternatives. It does not mention that nanokvm_hdmi_reset is for resetting or that this tool is read-only, leaving context to be inferred from the tool name and sibling list.

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

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

The description states that it 'Returns' a dictionary with device info, which implies a read-only operation but does not explicitly confirm non-destructive behavior, permissions, or data freshness. With no annotations, the description carries the burden but provides only basic 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 extremely concise and well-structured: a single opening sentence stating the action followed by a brief return-value summary. No wasted words.

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 info tool without an output schema, the description provides adequate context by naming the return type (dictionary) and example fields (IP, firmware version). However, 'etc.' is somewhat vague, and it doesn't mention any potential caveats like network location or permissions.

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

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

The tool has zero parameters, and schema description coverage is trivially 100%. The baseline of 4 applies because there is nothing for the description to add beyond what the schema already demonstrates.

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

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

The description uses a specific verb and resource: 'Get NanoKVM device information' with example fields (IP, firmware version), making the core purpose clear. It is not explicitly differentiated from the sibling tool 'nanokvm_hardware', but the focus on device-level info distinguishes it enough.

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 like nanokvm_hardware or nanokvm_led_status. No exclusions or recommended contexts are provided, leaving the agent to infer usage.

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 burden of behavioral disclosure. It clearly explains the return format (a dictionary with 'pwr' and 'hdd' booleans) and the meaning of each field, which helps the agent understand what to expect. It also implies a read-only operation via 'Get,' though it does not explicitly state side-effect-free behavior or prerequisites.

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 and well-structured: a one-sentence purpose statement followed by a 'Returns:' section with clear bullet points. Every sentence adds value, with no fluff or repetition.

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

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

For a simple status tool with no parameters, no output schema, and no annotations, the description fully covers the essential context: what the tool does, what it returns, and how to interpret the result. It is self-contained and 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 tool has zero parameters, so the schema coverage is trivially 100%. The description does not need to add parameter information, and the baseline for zero-parameter tools is 4. There is nothing to clarify beyond what the empty schema already indicates.

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

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

The description uses a specific verb ('Get') and resource ('power and HDD LED status'), clearly stating the tool's function. It is distinct from sibling tools like nanokvm_power (which controls power) and nanokvm_hdmi_status (which checks HDMI), so it clearly differentiates its purpose.

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

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

The description implies usage for checking machine power and disk activity but does not explicitly state when to use this tool versus alternatives like nanokvm_info or nanokvm_power. There are no exclusions or alternative tool recommendations, leaving usage guidance implicit.

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 discloses the return content ('List of available images with file paths and metadata') but does not mention side effects, permissions, error behavior, or whether the listing reflects live device state. For a simple read-only list, 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?

The description is two short sentences with no redundant wording. It states the action and the output format immediately, making it highly scannable and appropriately sized.

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 no parameters, an output schema, and a straightforward single-purpose role, the description is complete. It tells the agent what the tool does and what it returns, and the sibling tools provide enough surrounding context for selection.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics because there are none, and it correctly omits any parameter-related detail.

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

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

The description clearly states the tool's function: 'List available ISO images on the NanoKVM device.' It uses a specific verb ('List') and resource ('ISO images'), and it distinguishes itself from sibling tools like nanokvm_mount_iso and nanokvm_unmount_iso 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?

The description does not explicitly state when to use this tool vs alternatives, nor does it provide exclusions. However, the verb 'List' implies it is the go-to for enumerating images before mounting, and the sibling set clarifies the distinction. Still, explicit guidance 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 of behavioral disclosure. It goes beyond a simple statement by disclosing that the tool returns a dictionary or None if nothing is mounted, which is valuable behavioral context. However, it does not mention whether the operation is read-only (though 'Get' implies it) or describe any side effects, which would have made it more 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 concise, using only two sentences with no filler. The first sentence states the tool's purpose, and the second briefly describes the return value. The structure is front-loaded and every word earns its place.

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

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

For a simple getter tool with no parameters and an output schema, the description is complete. It states what the tool does and what it returns, including the None case. The output schema likely provides detailed return fields, so the description need not elaborate further.

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

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

The tool has zero parameters, and the input schema confirms this. The baseline for no parameters is 4, and the description does not need to explain parameter semantics. It correctly does not introduce any misleading parameter-related information.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('currently mounted ISO image'), which distinguishes it from sibling tools like nanokvm_mount_iso, nanokvm_unmount_iso, and nanokvm_list_images. It precisely conveys that this tool is for querying the currently mounted ISO, not for mounting/unmounting or listing all images.

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

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

The description implies when to use this tool (when you need information about the currently mounted ISO), but it does not explicitly state when to use it over alternatives or mention any exclusions. No guidance is given about using nanokvm_list_images for available images or nanokvm_mount_iso for changing the mount, so the guidance is only implicit.

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. It explains the effect: the target will see the ISO as a CD-ROM or USB disk. However, it does not disclose potential side effects, such as overwriting a previously mounted image, or whether the mount persists until unmounted.

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 and well-structured. It leads with the main action, explains the user-visible effect, and lists arguments with brief, useful explanations. Every sentence contributes.

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

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

For a simple two-parameter mount tool, the description provides sufficient context: what it does, what the target sees, and parameter meanings. It does not mention prerequisites (e.g., ensuring the file exists) or that only one image may be mounted at a time, but these are minor 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?

The schema has 0% coverage, but the description compensates by explaining both parameters: 'file' is the path on the NanoKVM device, and 'as_cdrom' distinguishes between CD-ROM and USB disk modes. This adds meaning beyond the bare schema titles.

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

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

The description clearly states the action: 'Mount an ISO image for the target machine.' This uses a specific verb and resource, making it distinct from sibling tools like nanokvm_unmount_iso and nanokvm_list_images.

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 the tool: when you want to attach an ISO image to the target machine. It does not explicitly mention alternatives or when not to use it, but the context is clear enough given the sibling tools.

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

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

No annotations are provided, so the description must carry the burden. It does add useful context by defining the coordinate origin (0 = left edge, top edge), which clarifies the coordinate system. However, it does not disclose any potential side effects (e.g., whether the move is instantaneous, whether it affects the physical mouse, or whether there are any state changes beyond cursor position). For a simple operation, the absence of warnings is not critical, but the description could be more explicit about the behavior's scope.

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 exceptionally concise: a single active sentence followed by two parameter definitions. Every sentence earns its place, and the main action is front-loaded. No redundant wording or unnecessary details.

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

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

Given the tool's simplicity, the description is nearly complete. It covers the core operation and parameter semantics adequately. An output schema exists, so return values need not be explained. The only missing elements are edge-case behaviors (e.g., handling of out-of-range coordinates) and precise units, but these are not critical for a basic move operation. Overall, the description provides sufficient context for an agent to use the tool correctly.

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

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

The input schema lacks descriptions for x and y (0% coverage), and the description compensates by explaining that x is the X coordinate with 0 at the left edge and y is the Y coordinate with 0 at the top edge. This adds meaning beyond the bare schema. However, it does not specify units (e.g., pixels), valid ranges, or behavior when out of bounds, which limits the compensation.

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 function: 'Move mouse cursor to absolute screen position.' It specifies the verb (move), the resource (mouse cursor), and the scope (absolute screen position), which immediately distinguishes it from the sibling tool nanokvm_move_relative. There is no ambiguity about what action is performed.

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. While the phrase 'absolute screen position' hints at a contrast with relative movement, no explicit comparison is made, and there is no mention of when not to use it or which sibling tools to prefer in different contexts. The description relies entirely on the agent inferring usage from the operation name.

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 transparency burden. It discloses key behavioral traits: relative HID reports and splitting of deltas larger than one signed byte. It also explains why absolute moves fail on certain targets. No safety or auth concerns are noted, but none are expected for a mouse-move 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?

Description is front-loaded with its core purpose, followed by usage guidance, a behavior note, and an args list. Every sentence earns its place without redundancy - clear, concise, and well-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?

Given no annotations and minimal schema, the description is thoroughly complete: it covers the purpose, when to use vs. alternatives, parameter semantics, and a performance/behavior edge case. The presence of an output schema covers return values, so no additional explanation is needed.

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

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

Schema provides only titles with no descriptions (0% coverage). The description compensates fully by defining both parameters: 'dx: Horizontal delta in pixels, negative is left' and 'dy: Vertical delta in pixels, negative is up', plus the behavioral note about large deltas being split - adding meaning beyond the raw integer type.

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 'Move mouse cursor by a relative delta, rather than to an absolute position' with a specific verb and resource, explicitly distinguishing it from nanokvm_move's absolute-coordinate approach. This clearly differentiates it from sibling tools.

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

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

Explicitly instructs 'Use this when nanokvm_move() has no visible effect' and identifies target scenarios (embedded firmware with relative USB mouse), providing clear when-to-use guidance and naming the alternative.

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

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

Despite lacking annotations, the description discloses key behavioral details: press durations (800ms, 5000ms), the fact that reset is unsupported on Pi 5, and that power_long is a force-off. This meets the behavioral transparency burden without annotation support.

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

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

The description is concise and well-structured, with a one-sentence summary followed by an Arg list and a note. Every sentence adds value, and the format makes it easy to parse.

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

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

The tool has a single parameter with all values explained, including edge cases (Pi 5 reset). The note about power_cycle covers the sibling alternative, and the output schema exists, so return values need not be explained. It is complete for the tool's complexity.

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

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

The schema has 0% description coverage, but the description compensates by explaining each enum value in detail, including effects and timing. This adds significant meaning beyond the raw schema, giving a 5.

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 controls the target machine's power with specific actions (power, power_long, reset). It distinguishes itself from the sibling nanokvm_power_cycle by recommending that function for reset on Pi 5, making the purpose 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 provides explicit guidance for each action, including when to use power_long for force off. It explicitly warns against using 'reset' on Pi 5 and directs the user to nanokvm_power_cycle() as an alternative, satisfying when-not and alternatives requirements.

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

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

With no annotations provided, the description must disclose behavioral traits. It does so by outlining the exact sequence: force power off via a 5-second button hold, wait the specified duration, then power on with a short press. It also explains the default delay and its rationale. It does not, however, warn about potential data corruption or other consequences of a hard power cycle.

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 well-structured and front-loaded: a one-sentence summary, the recommended use case, a numbered sequence, and clearly labeled Args/Returns sections. Every sentence adds useful information, and the format makes it easy to scan. No filler or unnecessary repetition.

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

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

Despite its simple parameter set, the description covers all necessary context: what the tool does, why it exists, the exact button-hold behavior, the parameter with default and tuning advice, and the return type. The output schema also documents return values, but the description's 'Returns' line reinforces it. This is a complete, self-contained explanation.

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 only provides a type and default for off_duration_ms, with no description (0% schema coverage). The description fully compensates by explaining the parameter's meaning, default behavior (3000ms for clean power cycle), and guidance for longer values on slow storage. This adds substantial semantic value beyond the schema.

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

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

The description opens with a specific verb and resource: 'Power cycle the target machine (force off, wait, power on).' This clearly distinguishes it from sibling tools like nanokvm_power by describing a multi-step reset sequence rather than a simple on/off action. The phrase 'recommended way to reset a Raspberry Pi 5' further clarifies its unique purpose.

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

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

The description provides clear when-to-use context: 'recommended way to reset a Raspberry Pi 5 since it has no hardware reset button.' It also offers parameter guidance for slow storage (use 5000+ ms). However, it does not explicitly state when not to use it or mention alternative sibling tools such as nanokvm_power for simple on/off operations.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the action ('reset') but does not describe side effects, whether the reset is disruptive, prerequisites, or what the output means. This leaves significant uncertainty about the tool's behavior beyond the word 'reset'.

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 two sentences long. The first sentence directly states the action, and the second provides practical usage context. There is no redundancy or unnecessary detail.

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

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

Given the tool's simplicity (no parameters, output schema exists), the description provides the necessary purpose and usage guidance. It is complete for the tool's complexity, even though behavioral details are sparse (already accounted for in that dimension).

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

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

The tool has zero parameters and schema coverage is 100%, so there is no parameter information to add. The description correctly omits parameter details, and the baseline for 0 params is 4.

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

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

The description clearly states the action ('Reset') and the target resource ('HID (keyboard/mouse) devices'), making it distinct from sibling tools that send keys, move the cursor, or control power. The verb is specific and the resource is explicitly identified.

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 second sentence provides an explicit trigger condition: 'Use this if keyboard or mouse input stops working.' It clearly indicates when to use the tool, but does not mention alternatives or exclusions, so it is a 4 rather than a 5.

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

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

The description discloses key behavioral traits: default resizing from 4K to 1080p, JPEG output format, and parameter behaviors such as 'use 0 for no limit.' It does not mention potential side effects or permissions, but for a read-only screenshot tool, this is adequate.

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 well-structured with a concise purpose statement, followed by clear parameter details and a return-value description. Every sentence adds value, and the section headers (Args, Returns) facilitate quick comprehension.

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

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

The tool is simple, and the description covers all necessary aspects: what it does, how it behaves by default, what each parameter controls, and what the output is. Since there is no output schema, the description appropriately explains the JPEG return value.

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

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

Despite the input schema having 0% description coverage, the description's Args section thoroughly explains each parameter, including defaults, valid ranges (quality 1-100), and special values (0 for no limit). This fully compensates for the schema's lack of descriptions.

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

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

The description begins with a specific action and resource: "Capture a screenshot from the target machine's display." This clearly distinguishes the tool from its siblings, none of which capture screenshots.

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

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

The description does not provide explicit guidance on when to use this tool or compare it to alternatives. However, the tool's unique functionality among siblings implies its use case, but the context is not fully spelled out.

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

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

With no annotations provided, the description must disclose behavioral traits itself. It does add the meaningful detail that positive amounts scroll down and negative amounts scroll up, which is beyond the schema. However, it does not mention any limitations, side effects, or whether the scroll is relative to the current position.

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

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

The description is extremely concise yet effective. It leads with the core action and then immediately explains the only parameter. Every word adds value, with 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?

Given that the tool has only one parameter and an output schema exists, the description covers the essential parameter semantics. However, it lacks context about when to use this tool in favor of other input methods, and does not mention any prerequisites or device connectivity requirements. This leaves some gaps for an agent to fully determine appropriate usage.

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

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

The schema only specifies 'amount' as an integer. The description enriches this by explicitly defining the semantic meaning: 'Positive = scroll down, negative = scroll up.' This is essential information not present in the schema, making the parameter fully understandable.

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 'Scroll the mouse wheel' clearly states the tool's function with a specific verb and resource. It distinctly separates this tool from siblings like nanokvm_send_key, nanokvm_tap, and nanokvm_move, which handle other input 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?

No guidance is provided regarding when to use this tool versus alternative input tools such as nanokvm_click or nanokvm_tap. The description only states what the tool does, not the 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It explains that modifiers are 'Hold' flags, implying they are pressed alongside the key, and enumerates valid key values. It does not disclose potential side effects or timing, but for a simple key press operation, this is adequate. The behavior is transparent enough for an agent to expect a press with optional held modifiers.

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 appropriately sized and front-loaded with the primary action. It uses a clean bulleted list to categorize key types and a separate line for each modifier, making it scannable and easy to parse. Every sentence contributes useful 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 5 parameters, one required, and no annotations, the description fully covers the valid inputs and modifier semantics. It doesn't explain return values, but an output schema exists, so that information is available structurally. The description is complete for an agent to invoke the tool correctly, including edge cases like single-character keys and modifier combinations.

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 substantial meaning beyond the input schema, which provides only property names and types with zero descriptions. It fully defines valid input values for 'key' (named keys, function keys, arrow keys, navigation, single characters) and clarifies the boolean modifier parameters as 'Hold' actions. This is critical for correct parameter usage and far exceeds a baseline schema-only understanding.

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

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

The description clearly states the tool's function: 'Send a single key press to the target machine.' It specifies the exact action (send), the resource (key press to target machine), and correctly distinguishes it from sibling tools like send_text (for text input) and mouse-related tools (tap/click/move). No ambiguity exists about its core purpose.

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

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

The description provides clear context that this tool sends a single key press, with a comprehensive enumeration of supported key categories (named keys, function keys, arrow keys, navigation, single characters). It does not explicitly name alternatives or when-not-to-use scenarios, but the scope is clear from the phrasing 'single key press' and the detailed key list, which guides an agent to choose this tool for individual key events rather than text strings or mouse actions.

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

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

With no annotations provided, the description carries the full burden of disclosure. It reveals the paste API mechanism, the 1024-character limit, and the language parameter behavior. It does not mention error handling for oversized text or unsupported characters, but it provides solid transparency for a simple text input tool.

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

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

The description is brief and well-structured. It opens with the primary purpose, then adds the performance benefit, a critical limit, and a clear parameter list. Every sentence provides useful 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?

The tool is simple with 2 parameters and an output schema exists, so return values need no explanation. The description covers purpose, usage context, constraints, and parameters. It lacks edge-case details (e.g., what happens on text overflow) but is adequate for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must provide all parameter meaning. The Args section explicitly explains 'text' as 'The text to type (max 1024 characters)' and 'language' as 'Keyboard layout - "" for US QWERTY, "de" for German.' This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states 'Type text on the target machine via keyboard emulation.' This is a specific verb+resource combination that distinguishes it from sibling tools like nanokvm_send_key (individual keys) and nanokvm_tap (mouse). The mention of the paste API further clarifies the exact mechanism.

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 use cases by stating the paste API 'is faster than individual key presses,' which suggests using this instead of send_key for text input. However, it does not explicitly name alternative tools or provide exclusions, but the context is clear enough for selection.

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

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

With no annotations, the description carries the full burden. It usefully discloses that coordinates are screen pixels based on NANOKVM_SCREEN_WIDTH and NANOKVM_SCREEN_HEIGHT, but it omits details about the tap action itself (e.g., press-and-release sequence, pointer movement, or side effects).

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

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

The description is concise, front-loaded with the main purpose, and uses a clear Args section. Every sentence adds value with no 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?

For a simple two-parameter tool, the description covers the essential aspects: purpose, coordinate system, and parameter meaning. The presence of an output schema likely covers return values. It lacks usage guidelines and explicit side-effect disclosure, but overall is largely 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?

Despite 0% schema description coverage, the description provides complete parameter semantics: x and y are explained with origin (0 at left/top) and bounds derived from environment variables. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the tool performs a tap at a specific screen position and mentions touchscreen/mouse emulation, giving a specific verb and resource. It does not explicitly distinguish this from the sibling nanokvm_click, but the action is still 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?

No guidance is given on when to use this tool versus alternatives like nanokvm_click or nanokvm_move. The description does not provide context on prerequisites, exclusions, or scenarios where this tool is preferred.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool unmounts the mounted ISO but does not disclose what happens if no image is mounted, whether the action is reversible, or any side effects beyond the unmount operation itself.

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

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

The description is a single, front-loaded sentence with no redundant words. It states the operation and its scope efficiently, earning a maximum score for conciseness.

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

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

Given the tool's low complexity (zero parameters, simple operation, presence of an output schema), the one-sentence description is largely sufficient for basic usage. However, it omits edge-case behavior such as failure when nothing is mounted, which prevents 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?

The tool has zero parameters, and the description references 'the currently mounted ISO' as the implicit target. With no parameters to document, the baseline of 4 applies; the description does not need to add parameter-level semantics.

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

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

Description clearly states the action 'unmount' and the resource 'currently mounted ISO image', making the tool's purpose explicit. It is immediately distinguishable from the sibling nanokvm_mount_iso, which performs the inverse operation.

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

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

The description provides clear context: use this tool when there is a currently mounted ISO image to unmount. It does not explicitly mention exclusions or alternatives, but the verb 'unmount' and the scope 'currently mounted' convey the intended usage without ambiguity.

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