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

With no annotations, the description carries the full burden and falls short: it does not say whether this is a real input event, what happens at screen edges, or whether a prior screenshot is required. Only the count=2 double-click behavior is 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 tight sentences, front-loaded with the core action and coordinate basis, with the optional double-click convention appended. 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?

An output schema exists so return values need no explanation, and the description covers the essential call semantics. However, for a gesture tool it omits coordination details such as needing a screenshot first or how coordinates relate to the sibling screenshot output.

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

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

Schema coverage is 0%, so the description must compensate. It usefully clarifies that x/y are screenshot pixel coordinates (not normalized or window-relative) and that count=2 means double click, but the button parameter is left entirely to the enum/default.

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

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

States a specific verb (Click) plus the coordinate basis (screenshot pixel coordinates), which is more informative than a bare 'click'. It implicitly differentiates from siblings like move_mouse and drag, though it never names them.

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

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

There is no statement of when to use this versus move_mouse, drag, or press_keys, nor when clicking is inappropriate. Usage is only inferable from the tool name itself.

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

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

With no annotations, the description carries the full behavioral burden. It helpfully decomposes the gesture into press, move, and release, which is genuine behavioral detail beyond the name 'drag'. But it omits the button parameter, coordinate space, timing/interpolation, and whether a session must already exist.

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

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

A single front-loaded sentence with no wasted words, and the operation order is clear. It is arguably too terse for a five-parameter tool, but structurally efficient.

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

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

An output schema exists so return values need not be explained, but with 0% schema coverage and no annotations the description leaves the button parameter, coordinate system, and session prerequisites undocumented. It is incomplete for a five-parameter input 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% and only titles (X1, X2, Y1, Y2, Button) exist. The description maps x1/y1 to the press point and x2/y2 to the release point, adding some meaning, but it never mentions the button parameter at all despite right/middle options existing.

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 operation with named coordinates: press at (x1, y1), move to (x2, y2), release. An agent can tell this is a drag gesture, distinct from click or move_mouse by the press-move-release sequence. However, it does not explicitly name or differentiate itself from siblings like click or move_mouse.

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 when-to-use guidance, no mention of alternatives (e.g., use click instead for a simple press), and no prerequisites or context such as needing an active session. The agent must infer all of this.

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. 'List' implies a harmless read, but it states nothing about read-only guarantees, permissions, or whether the operation has side effects; it only expands on the returned data shape.

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 front-loaded sentence with no filler; the resource is identified before the returned fields. Slightly loose phrasing ('and what is mounted now') but every clause contributes information.

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

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

An output schema exists, so return values need not be documented here, and the zero-parameter signature makes the description nearly complete. The remaining gap is the unexplained relationship to the mount/unmount siblings, i.e., whether newly mounted media shows up in this listing.

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 takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond what the empty schema already conveys.

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?

A specific verb ('List') plus a precisely scoped resource ('images stored on the KVM's internal storage'), and it enumerates the three things returned: images, free space, and current mounts. It is distinguishable from the sibling usb_drive_list by the 'internal storage' scoping, though it never names that sibling to sharpen the contrast.

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 explicit when-to-use statement or named alternatives, but the listing scope ('what is mounted now') implies its role as the discovery step preceding mount_media_url/mount_media_storage/unmount_media. Usage is inferable rather than stated.

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

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

With no annotations, the description carries the full behavioral burden; it does disclose the key trait that the attached device is 'read-only'. However it says nothing about state effects such as what happens if a drive is already mounted, whether attach is reversible, or what detach_usb_drive actually destroys, leaving mutation behavior largely opaque by offloading it to a sibling.

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 tight sentences with the action and resource front-loaded and no filler. Compression comes at the cost of offloading real content to sibling tools, but structurally there is no 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?

An output schema exists so return values need not be described, and the read-only nature plus sibling cross-references are covered. The gap is the undocumented 3-parameter surface and unstated mount-state side effects, which are material for a tool that changes VM device state.

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 and largely does not: mode and detach_usb_drive are both punted to mount_media_url rather than explained. The phrase 'CD-ROM or disk' loosely mirrors the cdrom/disk enum, and 'see list_media' hints at filename sourcing, but no parameter is actually documented here.

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

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

States a specific verb and resource: 'Attach an image stored on the KVM ... as a read-only virtual USB CD-ROM or disk.' The contrast with mount_media_url is only implied by the way it delegates 'mode semantics', so an agent must infer the source difference rather than being told it outright.

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?

Points the agent to list_media to find the filename and to mount_media_url for mode and detach semantics, which gives practical routing context. It never explicitly says when to choose this tool over mount_media_url (stored image vs URL), so the guidance is contextual rather than 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, the description carries the full burden and does well: it discloses the read-only nature of the mounted media, the USB re-enumeration side effect of changing mode, and the host-side detachment behavior of detach_usb_drive. It omits auth/prerequisite and error conditions (e.g., unreachable URL, existing mounted media being replaced).

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?

Front-loaded with the core action, followed by mode tradeoffs and the detach escape hatch. Every sentence earns its place, though the mode paragraph is somewhat dense and could be marginally tighter.

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?

An output schema exists, so return values need not be explained; the description covers the action, mode selection, and a non-obvious side effect. It would be complete with a note on prerequisites (URL accessibility) and whether an existing mount is replaced.

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, and it does for all three parameters: URL is constrained to HTTP(S) ISO/IMG sources, both mode enum values are explained with concrete tradeoffs, and detach_usb_drive is described with the exact blocking scenario it solves.

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

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

States a specific verb and resource ('Attach an ISO/IMG reachable over HTTP(S) as a read-only virtual USB CD-ROM or disk'), and the HTTP(S) qualifier implicitly distinguishes it from the sibling mount_media_storage. Siblings are not named explicitly, so it stops short of a 5.

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?

Gives clear situational guidance for choosing between the two modes ('most compatible in BIOS/UEFI and for Windows installers' vs 'faster, suits Linux/modern installers') and when to set detach_usb_drive. However, it never states when to prefer this tool over mount_media_storage or unmount_media first.

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 does disclose the coordinate reference frame (screenshot pixels), which is useful, but says nothing about whether motion is instant or smooth, whether the pointer is clamped to screen bounds, or error behavior for out-of-range coordinates.

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

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

A single well-formed sentence with no filler, and the coordinate meaning is front-loaded. It is appropriately sized for a simple two-parameter tool.

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

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

An output schema exists, so return values need not be explained. However, for a tool with 0% schema coverage and no annotations, the description is minimal; it omits any usage context relative to siblings and any behavioral details about motion or error handling.

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 both parameters are undocumented in the schema. The description partially compensates by clarifying that x and y are in screenshot pixel coordinates, which is meaningful but not complete (e.g., origin, rounding behavior for non-integer values remain unstated).

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?

Specific verb (Move) and resource (mouse pointer) with an explicit coordinate convention (screenshot pixel coordinates). This clearly distinguishes it from siblings like click and drag.

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

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

The description states what the tool does but gives no guidance on when to use it versus alternatives such as click (which typically includes movement) or drag. No conditions or exclusions are mentioned.

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

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

With no annotations, the description carries the behavioral burden and does reasonably well: it discloses the hardware prerequisite (ArkKVM ATX board wired to the mainboard) and the forcefulness of each action, including that power-long is a ~5 s hold producing a hard power off. It does not mention permissions, idempotency, or what happens if the host is already in the requested state.

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

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

Purpose and hardware precondition are front-loaded, followed by a compact one-line-per-action breakdown. Every clause carries information; there is no filler or repetition of the schema.

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 hardware control tool with an output schema present, the description covers everything an agent needs: the hardware requirement, and the duration/effect of each action. Return values are appropriately left to the output schema.

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

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

Schema description coverage is 0%, so the description must supply the meaning of the single parameter, and it does: every enum value ('power-short', 'power-long', 'reset') is explained in terms of press duration and effect. That is real added meaning beyond the bare enum list in the schema.

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

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

States a specific verb and resource ('Press the target's ATX buttons') and enumerates the three discrete actions with their physical semantics. This is clearly distinguished from keyboard-oriented siblings like press_keys or press_keys/type_text, since it operates on motherboard ATX headers rather than the input layer.

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?

Each enum value is mapped to an operator intent ('power on / ACPI shutdown', 'hard power off', 'reset'), so an agent knows which action to pick for a given goal. It gives no exclusions or named alternatives, however — notably it does not say when to prefer the sibling wake_on_lan for powering a machine on.

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, and it does add real behavioral context: keys map to US physical positions, repeat sends the combination N times, and hold_ms keeps keys depressed. It omits what happens on unrecognized key names, whether input targets the focused window, whether an active session is required, and any error 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?

Front-loaded with the core action and input format, then one compact line per optional parameter, each earning its place with a concrete example. No filler, no restatement 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?

An output schema exists, so return values need not be explained, and the parameter semantics are fully covered. The remaining gap is environmental context, such as focus/session requirements and invalid-key handling, which would round out a no-annotation tool but is not essential for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all three parameters: keys with a format example list, repeat with its multiplier semantics and a boot-menu example, and hold_ms with its timing purpose and a POST example. That is full semantic coverage of every parameter.

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

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

States a specific verb (press) and resource (key/key combination) and illustrates the input vocabulary with concrete examples ('ctrl+alt+delete', 'super+r', 'shift+tab') that implicitly separate it from type_text and click. It does not name a sibling tool explicitly, so differentiation is inferential rather than stated.

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 embedded in the parameter notes ('down x5 in a boot menu', 'hold F12 during POST'), which gives the agent realistic scenarios for repeat and hold_ms. There is no explicit guidance on when to choose this over type_text or click, so routing must be inferred from the key-name examples.

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 does disclose the key effect: the session disconnects and the web UI becomes usable by others, which flags that control is being handed off. It omits whether the disconnect is reversible, whether it can be re-taken, and any auth/permission requirement, though the output schema covers return values.

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

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

A single front-loaded sentence beginning with the action 'Disconnect from the KVM'. It is efficient, though the trailing 'so the web UI can be used without being taken over' is slightly wordy for the point it makes. No filler or repetition.

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

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

For a zero-parameter action with an output schema and no annotations, the description conveys the action and its main consequence (freeing the KVM/web UI for others). The main remaining gap is any note on re-acquiring the session or persistence of the disconnect, but this is minor for a simple release action.

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

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

The tool takes zero parameters, so there is no parameter semantics to explain. Schema coverage is reported at 100% and the empty object leaves nothing ambiguous. Baseline 4 applies 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?

States a specific verb and resource ('Disconnect from the KVM'), so an agent knows this ends the current KVM control session. The trailing clause about the web UI explains why, but the phrase 'without being taken over' is slightly indirect rather than crisply naming the session/lock being released. It is distinct from all siblings (which are input/peripheral actions), so no sibling confusion arises.

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 word 'now' implies the session should be released when done, and the description hints at the condition (wanting the web UI usable). However, it never states explicit when-to-use/when-not or names an alternative for re-acquiring control. Usage is implied rather than prescribed.

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, and it does disclose a real behavioral constraint: destructive/configuration methods are blocked unless ARKKVM_ALLOW_DANGEROUS_RPC=1. It does not explain what happens on an unknown method, how blocked calls fail, or which methods count as 'configuration', but the safety gate is the key trait and it is surfaced up front.

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 dense sentences with zero waste: the capability and its risk gate. The example list is load-bearing rather than padding, and the blocking constraint is placed where it will be read before invocation.

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?

An output schema exists, so return values need not be described, and the description covers the capability, examples, and the safety gate. The remaining gap is the opaque params object and the absence of any note on error/unknown-method behavior for a generic dispatcher.

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

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

Schema description coverage is 0% and the two params (method, params) have no descriptions at all. The example method names give the agent a sense of valid method values, partially compensating, but the params object's shape and per-method requirements are entirely undocumented in both schema and description.

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

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

States a specific verb and resource ('call any ArkKVM JSON-RPC method') and immediately bounds it with concrete examples (getNetworkState, getEDID, setJigglerState). The 'Advanced' framing plus the generic-method nature differentiates it from every typed sibling (screenshot, click, power, usb_drive_*), which are single-operation wrappers.

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 'Advanced:' prefix and concrete method examples imply this is the escape hatch for capabilities with no dedicated sibling tool, and the description states the governing condition for the dangerous-method gate. It never explicitly says 'prefer the dedicated tool when one exists', leaving the agent to infer the fallback relationship.

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 and does substantial work: it discloses the capture source (HDMI input), the encoding (JPEG), the internal settle-until-stable behavior bounded by ARKKVM_SETTLE_MAX_MS, and the side effect that mouse coordinates are tied to the latest screenshot. Gaps remain around failure modes (no signal / disconnected HDMI) and whether the capture is blocking.

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?

Front-loaded one-line purpose followed by two tight parameter notes, each of which adds decision-relevant information rather than restating the schema. No filler.

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

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

For a two-parameter tool with no output schema, the description covers capture semantics, output format, parameter behavior, and the coordinate-space contract. What's missing is error/edge behavior (no HDMI signal, timeouts) and any explicit statement of how mouse coordinates relate to a downscaled max_width.

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 and it does: max_width is explained (downscale target, 0 = native resolution — critical since the schema default is 1280), and wait_ms is explained as an extra pre-capture delay that is rarely needed because the tool already waits for the picture to stabilize.

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

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

States a specific verb and resource ('Capture the target computer's screen (HDMI input)') plus the output format (JPEG). It also implicitly distinguishes itself from the mouse/input siblings by declaring that they operate in the coordinate space of the most recent screenshot.

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?

Gives clear operational context: the coordinate-space dependency tells the agent a screenshot must precede mouse actions, and it explicitly advises that wait_ms is 'rarely needed' because of built-in settling. It stops short of naming when not to use the tool or listing explicit alternatives, but the usage picture is unambiguous.

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 mentions direction semantics but omits whether a session is required, whether it's a blocking/interactive action, or any side effects. For an input-injection tool with zero annotation coverage, this is a significant 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?

Two short sentences, front-loaded with the action and location. Efficient, though the parenthetical direction hints are slightly terse.

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?

An output schema exists, so return values needn't be explained. But with 4 parameters, 0% schema coverage, and no annotations, the description leaves the agent guessing about the 'horizontal' flag and session prerequisites.

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 partially by explaining the sign convention for 'amount'. But it never mentions the 'horizontal' parameter, which defaults to false, leaving half the parameters undocumented in both schema and prose.

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

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

States a specific verb (scroll) and the coordinates where it happens, distinguishing it from siblings like move_mouse or click. However it doesn't clarify that this is a UI/computer-control action in the context of the broader toolset.

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

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

No guidance on when to use this versus alternatives such as move_mouse. No mention of prerequisites (e.g., an active session) or when-not-to-use conditions.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the categories of state returned, but says nothing about whether the call is read-only/side-effect free, whether it requires an active session, or whether it can fail when the host is powered off. Read-only nature is strongly implied by 'Report' but not declared.

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

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

A single front-loaded sentence with no filler; the enumerated fields are informative rather than redundant. The list is slightly long but each item earns its place by telling the agent what state is available.

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?

An output schema exists, so return format need not be explained, and there are no parameters to document. The description adequately covers scope for a simple read tool; only the session/read-only behavioral context is missing.

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

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

Zero parameters, so the baseline of 4 applies. The description correctly adds no parameter discussion, and none is needed.

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

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

States a specific verb (Report) and resource (KVM status), then enumerates exactly what is reported: firmware, HDMI/video signal, USB attachment, virtual media, keyboard LEDs, ATX LED state. This is clearly broader than the sibling usb_drive_status, though that differentiation is left implicit rather than stated.

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 when-to-use guidance and no mention of alternatives such as usb_drive_status for narrower USB-only queries. The agent can infer that 'status' is a general health check, but nothing in the text routes it against siblings or states preconditions.

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 does disclose valuable behavior: how escape sequences are interpreted, the layout default (ARKKVM_KEYBOARD_LAYOUT), and the BIOS/UEFI caveat. It does not address preconditions such as target focus, error behavior, or whether typing is interruptible.

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?

Purpose is front-loaded in the first sentence, followed by escape semantics, then param guidance. Every line is informative with no filler, though the multi-line layout block is slightly dense.

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

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

This is a low-complexity 2-parameter tool with an output schema, so return values need no explanation. Both parameters are meaningfully covered and the layout caveat rounds out what an agent needs to call it correctly.

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

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

Schema coverage is 0%, so the description must compensate, and it largely does: the 'layout' parameter is explained with its accepted values ('us'/'de'), its default env var, and the BIOS/UEFI recommendation, while 'text' gains meaning through the documented escape sequences.

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 concrete verb+resource ('Type text on the target as keystrokes') and immediately clarifies escape-sequence behavior for '\n' and '\t'. It is clearly distinct from navigation siblings like move_mouse or click, though it never explicitly contrasts with press_keys.

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 is implied: this is the tool for entering literal text, with escape sequences covering Enter/Tab. However, it never says when to prefer this over the sibling press_keys or what conditions make it unsuitable (e.g., no focused input field).

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 discloses one behavioral fact — that it acts on already-mounted media rather than anything else — but says nothing about failure behavior when nothing is mounted, permission requirements, or whether the underlying media/image stays intact.

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 nine-word sentence with the action front-loaded and zero filler. It is appropriately sized for a zero-argument operation, though it is too sparse to earn a top mark for structure.

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

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

For a parameterless tool with an output schema already covering return values, the description is close to sufficient, but with no annotations it leaves the state preconditions and error behavior unaddressed, which is the minimum an agent needs to decide whether to call it now.

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 takes zero parameters, so per the baseline there is no parameter semantics to explain and the description cannot be faulted here. Nothing in the schema is left ambiguous by the description.

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

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

States a specific verb (detach/unmount) and resource (virtual media), which is enough to separate it from the mount_media_url/mount_media_storage siblings and from the usb_drive_* family. It does not, however, explicitly name any sibling or clarify how it relates to usb_drive_attach, so it falls short of the differentiation a 5 requires.

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 "currently mounted" implies the tool is used to reverse a prior mount, so usage is inferable but never stated. There is no explicit when-to-use, when-not-to-use, or alternative tool guidance despite several closely related media/USB siblings in the 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?

With no annotations, the description carries the full behavioral burden and does disclose two non-obvious traits: the drive can only be attached to one side at a time, and after attaching to the host the OS needs a few seconds and drive letters may change. It does not mention permission/auth requirements or what happens if the drive is already attached, leaving some gaps.

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

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

Three sentences that are front-loaded with the core action and value meanings, with the timing caveat placed last. Slightly dense in the first sentence but every clause carries useful information.

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

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

An output schema exists, so return-value documentation is not needed, and the description covers targets, exclusivity, and post-attach timing. It omits edge-case behavior (e.g., re-attaching while already attached, error conditions), which keeps it just short of fully complete for a state-changing 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% and the single parameter only has bare enum values, so the description must compensate. It does explain the meaning of all three values ('host' appears as a USB stick, 'kvm' enables the other USB tools, 'none' detaches), which is materially more than the schema offers.

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

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

States a specific verb (attach/detach) and resource (Virtual USB Drive) and enumerates the three target modes inline. It clearly distinguishes itself from the nearby usb_drive_list/upload/download/delete siblings by explaining that those require the 'kvm' attachment first.

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 maps each enum value to a use case: 'host' to expose the drive to the target OS, 'kvm' when the drive needs to be managed via usb_drive_list/upload/download/delete, and 'none' to detach. The agent gets a direct routing rule rather than having to infer one.

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, and it does disclose the destructive semantics of recursive deletion (folders and their contents are removed by firmware). However, it never states whether deletion is permanent/irreversible, what permissions or mounted-state prerequisites apply, or how errors surface, which are important for an irreversible operation.

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

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

Two tight sentences: the first front-loads the core verb and resource, the second adds only the conditional constraint that changes how the call must be made. No filler or restated metadata.

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?

An output schema exists, so return values need not be described, and the recursive constraint is covered. For an irreversible delete tool with zero annotations and a 0%-documented schema, the missing information about permanence, prerequisites, and the switch_to_kvm parameter leaves real gaps.

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

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

Schema description coverage is 0%, so the description must fill the gap for all three parameters. It explains 'recursive' well (including firmware behavior on non-empty folders) but says nothing about 'remote_path' format or the non-obvious 'switch_to_kvm' flag, leaving two of three parameters undocumented anywhere.

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 ('Delete') on a specific resource ('a file or folder on the Virtual USB Drive'), which is unambiguous and clearly distinct from the upload/download/list siblings. It stops short of naming an alternative tool or scoping the operation further, so it is clear but not maximally differentiating.

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

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

It gives a concrete usage rule for the recursive case: non-empty folders require recursive=true, and explains what the firmware does in that mode. There is no explicit when-not-to-use guidance or named alternative (e.g., unmount before deleting), so it is clear context rather than full routing 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 usefully discloses that local_path writes to the machine running the MCP server and that inline returns are capped at 100 KB for text files. It omits important behavior: what happens for binary or oversized files without local_path, whether an existing local file is overwritten, and any auth/permission requirements.

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

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

Two sentences, front-loaded with the core action and then the mode split; no filler and every clause carries information the agent needs.

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?

An output schema exists, so return-value detail is not required, and the local vs inline distinction is covered. However, the unexplained switch_to_kvm parameter and the unstated behavior for large/binary downloads leave real gaps for a 3-parameter 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% and title-only fields convey nothing. The description meaningfully explains local_path (and its dual mode), but remote_path is never described and switch_to_kvm is entirely undocumented in both the description and the schema, leaving a hidden parameter whose effect an agent cannot infer.

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

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

States a specific verb (read/download) and resource (a file from the Virtual USB Drive), which cleanly separates it from usb_drive_upload, usb_drive_list, and usb_drive_delete in the sibling set. An agent knows exactly what the tool produces 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?

Explains the two operating modes clearly: pass local_path to save to disk on the MCP host, omit it to get small text files returned inline. It stops short of saying when this tool is preferable to alternatives (e.g., checking usb_drive_list first, or that binary/large files require local_path), so there is context but no explicit alternatives or exclusions.

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

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

With no annotations, the description carries the full behavioral burden. 'List' implies a read-only operation and the attachment requirement is useful context, but the description does not disclose the effect of switch_to_kvm, whether the operation is safe, or any side effects. This is a significant gap for a tool with no annotation coverage.

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

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

The description is two compact sentences with no wasted wording. The core purpose is front-loaded, followed immediately by the critical prerequisite.

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?

An output schema exists, so return values need not be described. However, the description leaves key parameter semantics and the side-effect behavior of switch_to_kvm unaddressed. Given no annotations and 0% schema description coverage, the definition is incomplete for correct invocation.

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

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

Schema description coverage is 0% and the description does not mention either parameter. 'List a directory' weakly implies a path argument, but switch_to_kvm is entirely unexplained. For two undocumented parameters, this fails to compensate for the schema gaps.

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: 'List a directory on the Virtual USB Drive.' This clearly distinguishes it from sibling operations like upload, download, delete, and status. It does not explicitly name or contrast with an alternative tool, so it falls just short of a 5.

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 one explicit prerequisite: the drive must be attached to the KVM. However, it gives no guidance on when to choose this tool versus siblings such as usb_drive_status, nor does it describe exclusions or alternative listing methods.

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 does disclose meaningful behavior: the three possible attachment states ('host', 'kvm', 'none') and that capacity is only populated when attached to the KVM. It is silent on whether this is purely read-only, any prerequisites, or refresh/latency characteristics, which leaves gaps for a zero-annotation 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 front-loaded sentence that leads with the resource and then enumerates the reported fields. The parenthetical definitions are the only expansion and they earn their space, though the sentence runs slightly long for such a simple query.

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?

A zero-parameter read tool with an output schema present needs little else. The description goes further by interpreting the returned attachment enum values and the capacity condition, so an agent can act on the result without external knowledge.

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 takes zero parameters, so there are no parameter semantics to document; the baseline for a parameterless schema applies. Nothing in the description misrepresents the empty argument object.

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

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

States a specific resource (the KVM's Virtual USB Drive) and the exact facts it reports: enabled state, attachment location, and capacity. It implies a distinction from usb_drive_list (which lists files) by describing the attachment locus, but never names the sibling, so it stops short of an explicit differentiation.

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

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

There is no when-to-use guidance, no indication of what precedes it (e.g., call before usb_drive_attach or usb_drive_upload), and no exclusions. With siblings like usb_drive_list, usb_drive_attach, and status, an explicit routing hint would be valuable; usage is only inferred from the 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 must carry the full behavioral burden. It usefully discloses that content is written as UTF-8 and that missing parent folders are auto-created (a meaningful side effect). But it omits whether an existing file is overwritten, any auth/permission requirements, and what switch_to_kvm does, leaving important mutation behavior unexplained.

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?

Tight and front-loaded: the primary action comes first, followed by the source distinction and the side-effect note. Every sentence adds something, though the parenthetical asides slightly interrupt the flow.

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?

An output schema exists, so return values need not be described. For a mutation tool with zero annotations and 0% schema coverage, the definition is adequate but leaves gaps: overwrite semantics, the undocumented switch_to_kvm flag, and permission requirements are all unaddressed.

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 effectively clarifies three of the four params: remote_path (with example), local_path (file on the MCP server machine), and content (UTF-8 text). It says nothing about switch_to_kvm, so the compensation is incomplete.

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

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

States a specific verb ('Copy a file onto') plus the target resource ('Virtual USB Drive'), and the e.g. remote_path example makes the operation concrete. It is clearly distinguishable from siblings like usb_drive_download, usb_drive_delete, and usb_drive_list.

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

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

The description gives implied usage context by explaining that the source is either local_path or content, which helps the agent pick a mode. However, it never states when to choose this tool over alternatives (e.g. mount_media_url or usb_drive_attach) or any prerequisites/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 full behavioral burden. It states the action and direction (from KVM to MAC) but does not disclose network prerequisites, expected side effects, whether the call is fire-and-forget, or what happens on invalid/unreachable MAC.

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 tight sentence with no redundant or filler content, front-loading the action and target.

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 one parameter and an output schema, so return-value documentation is unnecessary. However, with no annotations and no usage/prerequisite details, the description is only minimally sufficient for reliable invocation (e.g., MAC format and WoL network requirements are left implicit).

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

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

Schema description coverage is 0% and the single mac_address parameter is undocumented in the schema. The description names it as 'the given MAC address' but adds no format, validation, or accepted delimiter semantics beyond the parameter name.

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

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

States a specific verb (Send) and resource (Wake-on-LAN magic packet), plus the source (KVM) and target (MAC address). This distinguishes it from sibling KVM input/control tools and from generic power operations.

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 usage scenario (waking a machine via Wake-on-LAN) but offers no explicit when/when-not guidance or alternatives such as power or mount_media_* tools. For a single-purpose network action this is mostly self-evident, but it leaves prerequisites such as WoL support unstated.

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