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

Without annotations, the description carries the full burden. It labels the operation as 'READ', indicating it is non-destructive. However, it does not disclose other behaviors such as authorization requirements, rate limits, or the exact format of the returned data. The basic safety profile is communicated, but depth is lacking.

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

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

The description is extremely concise: one line for the main action and a bullet list for parameters. Every sentence is necessary and informative. It is front-loaded with the key verb and resource, making it easy for an agent to quickly grasp the tool's function.

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

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

Given the tool has 4 parameters, no output schema, and no annotations, the description covers the basics of purpose and arguments. However, it lacks details on return format, pagination, error states, or ordering. While functional, it leaves gaps that an agent might need to infer or discover via trial.

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

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

The input schema has 0% description coverage, so the description must compensate. It provides brief but explicit meanings for each parameter (e.g., 'storage' as 'Storage id', 'node' as 'Node name; omit to use configured default node'). This adds value beyond the raw parameter names, though it could include more detail on constraints or formats.

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 'List backup archives on a storage' with optional filtering by vmid. It uses a specific verb (list) and resource (backup archives), and the sibling tools include related but distinct actions like vm_backup and backup_restore, 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 includes a '[READ]' prefix hinting at read-only use, but it provides no explicit guidance on when to use this tool versus alternatives (e.g., storage_content) or any conditions that would make it inappropriate. The context is implied but not structured.

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

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

With no annotations, the description carries full burden. It discloses destructive overwrite with force, safe inverse for free vmid, and dry_run effects. Does not mention auth or rate limits, but is otherwise 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?

Front-loaded with key info (WRITE, HIGH RISK), then explains behavior, then lists parameters. No unnecessary sentences.

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

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

Given 7 parameters, destructive nature, and no output schema, the description covers purpose, risks, and parameter details. Could add post-restore behavior or error conditions, but adequate.

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

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

Schema coverage is 0%, so description provides all parameter meaning. Each argument is explained in the Args section, adding context beyond type and title.

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

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

The description clearly states it restores a QEMU VM from a backup archive, with specific verbs and resource. It distinguishes from backup_list and other VM 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?

Provides explicit guidance: high risk, confirm with user, dry_run for preview, and explains force behavior. Lacks explicit alternatives or when-not-to-use, but context is clear enough.

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

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

The description indicates a read operation (no mutations), which is the primary behavioral trait. No annotations are provided, so the description carries the full burden; it does not disclose additional behaviors like authentication needs or return value structure. For a simple read tool this is adequate but minimal.

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

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

The description is very short (two sentences plus an Args line), front-loading the purpose with '[READ]'. Every word serves a purpose, making it efficient. However, the 'Args' block is informal and could be more structured.

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

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

Given no output schema, the description should indicate what the tool returns (e.g., a boolean or JSON object). It only mentions reading options 'notably whether it is enabled' but doesn't clarify the return format. For a single-parameter read tool, this is a significant 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?

With 0% schema description coverage, the description must compensate for parameter documentation. It explains that 'target' is a 'Proxmox target name from config', which provides some context but remains vague—no valid values, format, or source are given. This is insufficient for an agent to reliably populate the 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?

The description clearly states it reads 'cluster-wide firewall options', specifically noting whether the firewall is enabled. This distinguishes it from per-VM firewall tools like vm_firewall_rules_list, though it does not explicitly name siblings.

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

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

The description includes a '[READ]' prefix indicating read-only use, but it does not provide explicit guidance on when to use this tool versus alternatives or mention any prerequisites. Context from sibling tools implies cluster-level vs VM-level distinction, but this is not 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 burden. It discloses the tool is read-only via '[READ]' and its scope as cluster-wide inventory, but omits details such as return format, pagination, or authentication requirements.

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

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

The description is extremely concise: a summary line, a usage tip, and a two-parameter list. Every sentence adds value 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 simple read-only listing tool with two optional parameters, the description covers purpose, usage, and parameters well. It could mention the response structure, but this is not critical given the straightforward nature.

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 fully compensates by explaining resource_type as an optional filter with listed values ('vm', 'node', 'storage') and target as a Proxmox target name from config.

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

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

The description clearly states it provides an aggregated cluster-wide inventory of VMs, nodes, and storage, and distinguishes itself from sibling tools like vm_get and node_status by instructing to use this before drilling down.

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 explicit when-to-use context ('enumerate everything before drilling into vm_get / node_status'), but does not explicitly state when not to use it or mention other alternatives.

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 '[READ]' prefix explicitly indicates no destructive behavior, which is good given no annotations. However, it does not disclose authentication requirements, potential errors, or what happens if the target is invalid. Adds some context but lacks full 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?

Concise with two sentences plus an Args section. Front-loaded with purpose. The use of backticks for code formatting is acceptable but slightly reduces readability. 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?

Given the tool's simplicity (one optional parameter, no output schema), the description covers basic functionality and return fields. However, it lacks information on error conditions, return format structure, or when the 'type=cluster row' appears. Adequate but not thorough.

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

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

The description adds meaning to the single parameter 'target' by explaining it is a 'Proxmox target name from config', which is absent from the input schema (0% coverage). This provides crucial context beyond the schema.

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

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

The description clearly states it returns cluster membership and quorum status with a specific verb 'Return'. It mentions the 'quorate' field, adding detail. However, it could be more explicit about the cluster being a Proxmox VE cluster, but it is sufficiently clear.

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

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

No guidance on when to use this tool versus alternatives like cluster_firewall_status or ha_status. There is no mention of when-not to use or any prerequisites. The description is purely functional.

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 includes the '[READ]' prefix, indicating a read-only operation, and lists the return fields. However, it does not disclose other behavioral traits such as authentication requirements, rate limits, or potential side effects. Given no annotations, this is adequate but not thorough.

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: a single line for purpose plus two lines for parameters. It is front-loaded with the '[READ]' tag and straight to the point, with 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?

The description lacks details on return type structure, pagination, or error scenarios. While it lists the fields returned, it does not specify whether the list is complete or filtered. For a list tool, this is a moderate 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 input schema has 0% description coverage, so the description must compensate. It explains the two parameters ('target' and 'node') clearly, including their defaults and how omission behaves. This adds significant meaning beyond the schema's property names.

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

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

The description clearly states it lists LXC containers with specific fields (name, vmid, status, cpu, mem). The verb 'list' and resource 'LXC containers' are unambiguous, and it distinguishes itself from sibling tools like vm_list (VMs) and action-oriented tools like ct_start.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., vm_list for VMs). It only explains optional parameters but lacks context about when default values are appropriate or when to choose this over other listing tools.

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

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

Without annotations, the description carries the burden of disclosing behavior. It labels the tool as a write operation ('[WRITE]'), explains the dry_run preview mode, node auto-location, and the inverse relationship. No mention of permissions or side effects, but the core behavior is transparent.

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

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

The description is very concise: a one-line summary, a usage note, and a bulleted Args list. Every sentence is necessary and well-organized, front-loading the core purpose and return 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?

Given the tool's complexity (4 parameters, no output schema, no annotations), the description covers all parameters, the return value (UPID), and references a companion tool (ct_list). It is complete for an agent to invoke this tool correctly.

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

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

With 0% schema description coverage, the description adds essential meaning for all four parameters: vmid is numeric and links to ct_list, dry_run previews, target comes from config, and node can be omitted. This fully compensates for the schema gap.

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

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

The description clearly states the action ('Start an LXC container'), the resource type, and the return value ('Returns the task UPID'). It also explicitly names the inverse operation ('ct_stop'), distinguishing 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?

The description explains when to use the dry_run parameter and the behavior of node auto-location. While it does not explicitly contrast with alternatives, it references the inverse operation and associated tools like ct_list, providing sufficient context for an agent to decide.

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

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

With no annotations, the description carries full burden. It discloses the write operation, return type (UPID), and auto-location behavior. It could mention error handling or post-stop state, but the provided details are adequate for basic usage.

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

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

The description is concise, with a clear header, body, and args list. Every sentence adds value; no fluff. Front-loaded with main action and return 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?

Given 4 parameters, no annotations, and no output schema, the description covers the main action, return type, parameter semantics, and inverse. It could include error cases or performance notes, but is largely sufficient for a stop tool.

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

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

Schema coverage is 0%, so description adds meaning for all 4 parameters: vmid (numeric, see ct_list), dry_run (preview), target (config name), node (auto-locate). This explains purpose beyond the schema's type/default info.

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 stops an LXC container and returns a task UPID. It specifies the inverse operation ct_start, distinguishing it from sibling tools like ct_start and vm_stop. The verb 'stop' and resource 'LXC container' are precise.

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 guidance on when to use dry_run for preview, mentions the inverse ct_start, and explains the node parameter can be omitted for auto-location. However, it does not explicitly compare to other stop tools (e.g., vm_stop) or state when not to use it.

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

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

The description explicitly marks the tool as read-only with '[READ]' and describes the output format (worst-first findings with numbers and remediation, plus list of stopped guests). However, with no annotations provided, it could disclose more about authorization requirements or rate limits.

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, with a summary line followed by a brief explanation and parameter detail. It uses clear structure (args block) and front-loads the main purpose. No unnecessary 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?

Despite having no output schema, the description fully explains the return value: worst-first findings with measured numbers and remediation, plus a list of stopped guests. It also specifies the underlying data source ('/cluster/resources guest view'). This is complete for a simple health scan tool with one parameter.

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

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

There is only one parameter ('target') with 0% schema description coverage. The description explains it clearly: 'Proxmox target name from config; omit to use the default.' This adds meaningful context beyond the schema, which only lists type and 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?

Description starts with '[READ]' and clearly states the tool scans VMs and containers for stopped guests, memory saturation, and disks near full. It specifies pulling the guest view and reporting worst-first findings with remediation. This distinguishes it from siblings like node_pressure_rca, which focuses on node-level pressure.

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

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

The description implies this tool is for health diagnostics but does not explicitly state when to use it versus alternatives like vm_get or node_status. No exclusions or prerequisites are mentioned, leaving the agent to infer the use case.

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

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

No annotations are provided, so the description must convey behavioral traits. It states it is a read operation and returns empty if HA not configured, which is helpful. However, it lacks details on permissions, rate limits, or what 'resources' exactly includes beyond VMs/CTs.

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, using two sentences to convey purpose, scope, and a key behavioral note. The '[READ]' prefix front-loads the action type. No unnecessary 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?

Given the simple nature of the tool (list, one optional param, no output schema), the description covers the basics. However, it lacks information about return format, pagination, error handling, or what happens if target is omitted. It is minimally complete but could be more informative.

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

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

The schema has 0% description coverage, and the only parameter 'target' has no schema description. The description adds 'Proxmox target name from config', which clarifies the source of the parameter, adding value beyond the raw schema.

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

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

The description clearly states it lists HA-managed resources (VMs/CTs) and explicitly marks it as a read operation with '[READ]'. It distinguishes from siblings like ha_status (status) and vm_list (all VMs) by focusing on HA-managed resources.

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 mentions that the result is empty when HA is not configured, which implies when to use, but it does not explicitly state when to choose this over alternatives like ha_status or vm_list. There is no guidance on prerequisites or when not to use.

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 discloses the return format (the 'configured' boolean and entries list), explains that non-empty entries do not mean HA is configured, and notes that when 'configured' is false a message explains the rows describe the stack itself. It does not mention side effects, authorization, or rate limits, but the '[READ]' prefix and focus on status information make the read-only nature reasonably clear.

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 front-loaded with the core purpose and follows with the return format, the crucial caveat, and the parameter explanation. Each sentence earns its place; the caveat about not inferring HA setup is essential and well-phrased. The structure is logical and easy to scan, with no redundant or irrelevant content.

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

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

The tool has moderate complexity due to the non-obvious semantics of the 'configured' flag and entries list. Without an output schema, the description adequately explains the return structure and meaning. It covers the main edge case (non-empty entries when 'configured' is false) and the parameter. It could be more complete by describing potential error conditions or what the 'not-configured signal' precisely looks like, but the core behavior is well covered.

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 only one optional parameter, 'target,' with no description and 0% coverage. The description adds meaning by stating 'target: Proxmox target name from config.' This explains what the parameter represents and where the value comes from, which is useful beyond the bare schema. However, it doesn't elaborate on what happens if omitted or how the target is resolved, so it's not fully comprehensive.

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 '[READ] Current HA status entries, or a not-configured signal,' which clearly states the tool reads HA status and indicates when HA is not configured. It further distinguishes itself from sibling tools like ha_resource_list by explaining the 'configured' flag and warning against misinterpreting a non-empty entries list. The verb and resource are specific and 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 context that this tool reads HA status, and it includes an important interpretive caveat: 'Do NOT infer HA is set up from a non-empty entries list.' However, it does not explicitly state when to use this tool instead of alternatives like cluster_status or ha_resource_list, nor does it mention any exclusions. The usage guidance is implied rather than explicit, so it falls short of a clear selection guide.

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 indicates a read operation with '[READ]' and states it returns a free VMID. However, with no annotations, it does not disclose potential side effects, permissions, or error conditions, making transparency moderate.

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 with no unnecessary words. It front-loads the purpose with '[READ]' and provides the parameter in a clear format.

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 tool with one parameter and no output schema, the description covers the basic purpose and parameter. However, it does not specify the return type or format, leaving some ambiguity for an agent.

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

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

The schema has 0% description coverage, but the description explains the 'target' parameter as 'Proxmox target name from config', adding meaning beyond the schema. However, it lacks details on valid values, defaults, or behavior when null.

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 returns a free VMID for a new guest, using a specific verb and resource. It distinguishes itself from sibling tools that deal with existing VMs or other 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 does not provide explicit guidance on when to use this tool versus alternatives. It implies usage before creating a VM but lacks context, exclusions, or references to 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 carries the full burden. It indicates a read operation with [READ], and lists the output fields (status, cpu load, memory). However, it does not disclose authentication requirements, rate limits, or potential side effects (though for a read tool, few are expected).

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

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

The description is extremely concise: two sentences plus an argument line. The purpose is front-loaded with the [READ] tag. No redundant or unnecessary text.

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 a single optional parameter and no output schema, the description provides sufficient information: it lists nodes with status, CPU, and memory. No filtering or pagination are mentioned, but likely not needed for this tool. The description covers the basics well.

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

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

The input schema has 0% description coverage, and the parameter 'target' lacks any schema description. The tool description compensates by explaining the parameter's purpose: 'Proxmox target name from config; omit to use the default.' This adds meaning beyond the raw schema.

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

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

The description clearly states it lists Proxmox cluster nodes with specific metrics (status, cpu load, memory). The [READ] prefix indicates a read operation. It distinguishes from sibling tools like node_status (which is likely for a single node) by explicitly saying '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 explains the target parameter but provides no guidance on when to use this tool versus siblings such as node_status, cluster_status, or other node-related tools. There is no explicit when-not or alternative suggestion.

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

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

With no annotations provided, the description carries the full burden. It explicitly marks the tool as a read operation ('[READ]') and describes the analysis process: ranking nodes, flagging over-threshold ones, and providing percentages and actions. It does not mention caching or real-time behavior, but it sufficiently discloses the non-destructive, analytical nature of the 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 highly concise: a single line stating the purpose, followed by a brief paragraph explaining the process, and then a short parameter note. Every sentence adds necessary information without redundancy. It is front-loaded with the key verb and resource.

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 moderate complexity (one optional parameter, no output schema), the description provides sufficient context. It explains what the tool does, how it works (thresholds, ranking, actions), and the parameter. An AI agent can understand the input, operation, and expected output format.

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

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

The input schema has one optional parameter 'target' with no description. The description adds value by explaining it is a 'Proxmox target name from config' and that omitting uses the default. This provides context that the schema alone does not, compensating for the 0% schema description coverage.

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

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

The description clearly states the tool ranks cluster nodes by CPU, memory, and root-fs pressure, flagging those over specific thresholds. The verb 'rank' and specific resource 'cluster nodes' with concrete metrics (CPU 85%, memory 90%, disk 85%) make the purpose precise. Though sibling differentiation is not explicit, the output (worst-first with actions) distinguishes it from generic status or resource tools.

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

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

The description implies usage for checking node health under resource pressure. It describes the data source ('pulls /cluster/resources node view') and thresholds. However, it does not explicitly state when not to use it or provide alternatives among siblings like 'node_status' or 'cluster_resources', which could be complementary. The guidance is clear but lacks 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 provided, so description must convey behavior. It indicates read-only via '[READ]' and lists returned fields. However, it omits potential behaviors like error handling, rate limits, or authentication 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?

Description is concise, front-loaded with purpose and metrics. Two sentences effectively communicate the tool's function without unnecessary 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?

No output schema, but description clearly states what is returned (cpu, load, memory, uptime). For a status tool with two parameters, this is sufficiently complete to inform an agent's decision.

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

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

Schema description coverage is 0%, but description adds meaning for both parameters: node name lookup via node_list, and target sourced from config. This provides context beyond the schema's field names and types.

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

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

Description clearly states it's a read operation for detailed node status, listing specific metrics (cpu, load average, memory, uptime). Distinguishes from sibling node_list which only lists nodes.

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 guidance on when to use this tool vs alternatives. References node_list for node names but does not specify when to choose this over other node-related tools like node_pressure_rca.

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 full behavioral burden. It only states it's a read operation via the [READ] tag, but omits details like idempotency, error behavior, or permission requirements. Minimal beyond the obvious.

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

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

The description is short and front-loaded: one line for purpose, one line for the argument. No wasted words, efficient for the agent.

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, but the description doesn't cover return format or pagination. With no output schema, it leaves gaps. Adequate but not complete for full 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 schema has 0% description coverage, so the description must compensate. It clarifies the target parameter is from config, adding some meaning, but lacks details on format or allowed values. Partially compensates.

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

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

The description clearly states it lists resource pools with pool id and comment, using the prefix [READ] to indicate a read operation. It distinguishes from sibling tools like pool_members which list members of a pool.

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 only mentions the target argument requirement but provides no guidance on when to use this tool vs alternatives (e.g., pool_members, vm_list). No exclusions or context for selection among siblings.

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

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

[READ] prefix indicates read-only nature. No annotations provided; description lacks details on idempotency, permissions, or side effects beyond the read hint.

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?

Very concise with front-loaded read indicator. No unnecessary words, three lines cover purpose and args.

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 list tool, description is complete enough. No output schema, but return values are implied. Could mention error handling or default target behavior.

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

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

Schema has 0% description coverage; description adds basic parameter info (poolid refers to pool_list, target from config). Adds some value but not comprehensive.

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 explicitly states '[READ]' and lists resource types (VMs, CTs, storage). Clearly distinguishes from pool_list (list pools) and other list 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?

Provides cross-reference to pool_list for pool id and mentions target as config value. Implicitly suggests use when you need pool members, but no explicit when-not or alternatives.

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?

Labels the operation with '[READ]' indicating a safe, non-destructive action. With no annotations provided, the description effectively communicates the read-only nature and basic behavior, though it omits details like required permissions or error conditions.

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?

Extremely concise: one-line summary followed by clear parameter definitions. No wasted words; each sentence adds distinct value. Front-loaded with the core purpose.

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

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

Covers purpose, parameters, and a cross-reference to storage_list. Lacks description of return format or pagination, but given the tool's simplicity and no output schema, the description is sufficiently complete for basic 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?

With 0% schema description coverage, the description fully compensates by explaining all four parameters: storage (with cross-reference), content (with explicit filter values), target (config-based), and node (default behavior). This is essential for correct usage.

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

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

The description clearly states the tool lists volumes (ISOs, disk images, backups, templates) on a storage pool. It differentiates from sibling tool storage_list (which lists pools) by specifying the resource type and content filters.

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

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

Provides parameter context but no explicit when-to-use or when-not-to-use guidance. It references storage_list for the storage id, implying a prerequisite, but does not compare with other list tools or suggest alternatives.

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 [READ] tag indicates no side effects. The description discloses that it lists storage pools with specific fields. With no annotations provided, the description adequately conveys the read-only nature and basic behavior. However, it does not mention error conditions or access 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?

Extremely concise: two-line description with clear args. Every sentence serves a purpose. 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?

Given the tool's simplicity (lists storage pools) and lack of output schema, the description adequately covers what the tool does and the key output fields. It could mention whether the list is exhaustive or paginated, but that is minor.

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

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

Schema has 0% description coverage, so the description carries full burden. It explains both parameters: target is 'Proxmox target name from config; omit to use the default' and node is 'Node name; omit to use the target's configured default node.' This adds clarity beyond the bare schema types.

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

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

Description explicitly says 'List storage pools on a node' and details the output fields (id, type, total/used/avail bytes). The [READ] prefix clarifies operation type. This clearly distinguishes it from siblings like pool_list (likely cluster-level) and storage_content (lists content of a given storage).

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 guidance on when to use this tool versus alternatives. While the purpose is clear, there is no mention of exclusion criteria or when another tool (e.g., pool_list, storage_content) would be more appropriate. Usage context is implied but not 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?

No annotations are provided, so the description carries the full burden. It explicitly marks the tool as 'READ', describes the return structure, warns about truncation, and explains the node parameter behavior. This is transparent beyond the schema.

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

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

The description is multi-line but efficiently structured: a one-line summary, a code block for return format, and an Args list. It is front-loaded with the key purpose and return format, but could be slightly shorter without the code block example.

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 4 parameters and no output schema. The description covers the return format, the truncation handling, and parameter details. It is complete for an agent to understand how 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?

With 0% schema description coverage, the description compensates fully. The Args section explains each parameter: upid (required), limit (default 200), target (Proxmox target), and node (omit to parse from UPID). This adds significant meaning beyond the schema's type/default 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 begins with '[READ] Fetch the log lines of an async task by its UPID.' This clearly states the action (fetch) and resource (log lines), distinguishing it from sibling tools that focus on VMs, nodes, etc.

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

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

The description explains the return format and notes the 'truncated' field, advising to raise limit or narrow the query if truncated is true. It does not explicitly state when not to use this tool, but the context is clear given the variety of siblings.

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

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

With no annotations, description carries full burden. It discloses that the node can be parsed from UPID, but does not mention return format, potential errors, or rate limits. Adequate but could be more transparent about output 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?

Very concise with a clear title, single-purpose sentence, and compact parameter list. No fluff, 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 polling tool, the description covers inputs and usage context adequately. However, missing a hint about the response format (e.g., status or progress) slightly reduces completeness for an agent without 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?

Given 0% schema description coverage, the description fully compensates by explaining the 'upid' (returned by async write), 'target' (config name), and 'node' (parsed from UPID when omitted). Adds significant meaning beyond schema names.

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

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

Description clearly states the verb 'poll', the resource 'Proxmox async task', and the identifier 'UPID'. It distinguishes from siblings like task_log or vm_clone by specifically targeting async task status checking.

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 says to use after a write that returned a task UPID to check completion instead of re-issuing the operation. Provides clear context for when to use, though lacks explicit when-not-to-use or alternative 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?

The description discloses it is a write operation with medium risk, that it dispatches an inverse tool with its own risk audit, and that tokens are single-use. This is good given no annotations, but could mention return value 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 well-structured with a header, explanatory paragraph, and bulleted arg list. Every sentence adds value, no 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 description covers purpose, usage, and parameter behavior well. However, it lacks information about the return value or output structure, which is a minor gap given no 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?

The description provides clear explanations for all three parameters (undo_id, dry_run, target) beyond the input schema, which lacks descriptions. This fully compensates for the 0% schema coverage.

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

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

The description clearly states the tool applies a recorded undo by dispatching its inverse tool, with a specific verb and resource. It distinguishes from sibling undo_list (which lists tokens) by focusing on application.

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

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

The description explains use cases like preview with dry_run and the single-use constraint. It implicitly references undo_list for obtaining undo_id, but does not explicitly contrast with alternative 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 provided; description fully discloses read nature, return structure, truncated detection method (one extra row), and meaning of effectVerified. Transparent and thorough.

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?

Well-structured with clear sections, but slightly lengthy. Each sentence adds value, so appropriate for the detail needed.

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?

No output schema; description covers return format, fields, and interpretation. All necessary behavioral context is provided, making the tool fully understandable.

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 0%; description fully explains limit (default 50, cap 500) and target (unused, for CLI uniformity), adding meaning beyond 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?

Starts with '[READ] List recorded, not-yet-applied undo tokens (most recent first)' – specific verb and resource, clearly distinct from sibling undo_apply.

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 directs to use undoId with undo_apply, explains truncated behavior and effectVerified guidance. Could more clearly state when not to use, but given sibling context, adequate.

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 adds useful behavioral context (non-running agent returns responsive=False with explanation, not an error). Since no annotations are provided, this is valuable, but it does not disclose other traits like required permissions 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 and well-structured: a brief purpose header, a behavioral note, and parameter descriptions. Every sentence serves a purpose 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?

The tool is simple and the description covers its purpose, behavior on failure, and parameter semantics. It does not detail response format, but for a ping check with no output schema, this is sufficient.

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

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

Schema coverage is 0%, but the description includes an 'Args:' section that explains each parameter: vmid is numeric, target is from config, node can be omitted for auto-location. This adds meaning beyond the schema's property names and types.

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

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

The description clearly states it is a read operation ('[READ]') that pings a VM's QEMU guest agent to check responsiveness. This distinguishes it from sibling tools like vm_config or vm_start, which perform different actions.

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

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

The description provides context about when to use the tool (to check agent installation and responsiveness) and explains behavior when the agent is absent. However, it does not explicitly compare to alternatives or state when not to use it.

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

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

Discloses it is a write operation, returns a UPID, and explains mode effects on downtime. Without annotations, it covers key behavioral traits but lacks details on permissions or performance impact.

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

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

The description is very concise: a one-line summary followed by bullet-point argument explanations. Every sentence adds value, and it is front-loaded with the WRITE tag and core purpose.

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

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

Covers all 5 parameters and provides useful defaults and references. Lacks error conditions or return format beyond 'UPID', but overall complete for a backup creation tool given no 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?

With 0% schema coverage, the description compensates fully by explaining each parameter: vmid (numeric ID), storage (backup-capable), mode (snapshot/suspend/stop with default), target (from config), node (optional, auto-locate). Adds significant meaning beyond the schema.

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

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

The description explicitly states it creates a vzdump backup of a VM/CT to storage, with a [WRITE] prefix and returns a task UPID. This clearly distinguishes it from siblings like backup_list or backup_restore.

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

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

Provides context on arguments (e.g., mode options, node auto-location) and references related tools (storage_list, storage_content). Does not explicitly state when not to use or compare directly to alternatives, but the context is sufficient for typical use.

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 provided, so description carries full burden. Discloses write operation, async nature, and return value (UPID). Dry_run behavior is explained.

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?

Concise and well-structured: header line, async warning, dry_run note, then clear bulleted parameter list. No unnecessary text.

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 clone operation with no output schema, the description covers purpose, async behavior, parameter details, and return value (UPID). Complete and actionable.

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

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

Schema has 0% description coverage. Description includes an Args section explaining each parameter's purpose (vmid, newid, name, dry_run, target, node). This fully compensates for missing schema 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 it clones a VM to a new vmid, returns a UPID, and mentions the inverse operation (vm_delete). This distinguishes it from other VM 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?

Explicitly notes cloning is asynchronous, advises polling with task_status, and warns not to re-issue. Also mentions dry_run for preview.

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 [READ] tag indicates a read-only operation, but without annotations the description carries full burden. It could be more explicit about safety or permission requirements. It does not disclose any side effects or additional behavioral traits.

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 with a front-loaded purpose sentence and a clear parameter list. It is efficient with no wasted words, though it could be slightly more structured for readability.

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?

Considering no output schema and no annotations, the description adequately explains what the tool returns and the purpose of each parameter. It does not cover error cases or return format but is sufficient for a straightforward read operation.

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 clear and detailed meaning to all three parameters beyond the raw schema. It explains vmid as numeric ID, target as config name, and node location logic. This fully compensates for 0% schema coverage.

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

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

The description clearly states it returns a VM's config with specific fields (cores, memory, ostype, boot order). The [READ] prefix adds clarity. However, it does not distinguish itself from the sibling tool 'vm_get', which may have overlapping functionality.

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

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

No guidance is provided on when to use this tool versus alternatives like 'vm_get' or 'vm_list'. The description explains parameters but lacks when/when-not usage context.

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

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

Full disclosure: marks as [WRITE], states permanent destruction, no undo token, mentions audit trail to ~/.proxmox-aiops/audit.db, and explains dry_run preview. Since no annotations provided, description carries full burden and meets it.

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

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

Efficiently structured: summary line, critical warnings, usage instruction, then parameter list. No redundant text, all sentences earn their 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?

Covers all needed aspects for a destructive 4-parameter tool: what it does, safety warnings, preview option, audit logging, parameter roles. No 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?

Adds detailed meaning for all 4 parameters beyond the schema (which has 0% coverage): vmid is numeric ID, dry_run previews without destroying, target is from config, node can be auto-located.

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?

Clearly states 'Permanently destroy a VM' with explicit [WRITE] tag and 'IRREVERSIBLE' warning, distinguishing it from sibling tools like vm_start, vm_stop, vm_shutdown, etc.

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 to 'Confirm with the user before calling' and suggests using dry_run=True to preview. Lacks explicit when-not-to-use or comparisons to alternatives, but context of irreversibility is clear.

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 starts with '[READ]', indicating a safe read operation, and lists parameters. However, it does not disclose output format, pagination, permissions, or prerequisites beyond the parameters.

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

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

The description is very concise, with clear front-loading of purpose ('[READ] List the firewall rules...') followed by a structured argument list. Every sentence adds value 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?

Given no output schema, the description should explain the return value (e.g., format of rules list). It only describes input parameters. For a list operation, this is a significant gap. Also lacks prerequisites (e.g., VM must exist).

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%, yet the description explains all three parameters: vmid ('Numeric Proxmox VM id'), target ('Proxmox target name from config'), and node ('Node name; omit to auto-locate the VM'). This adds significant meaning beyond the schema's type-only definitions.

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 'List the firewall rules attached to a VM.' This is a specific verb ('list') and resource ('firewall rules of a VM'), which distinguishes it from sibling tools like cluster_firewall_status (cluster-level) and vm_config (VM configuration).

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 listing firewall rules of a specific VM, and '[READ]' indicates it's a read operation. However, it does not explicitly state when to use this tool versus alternatives like cluster_firewall_status or when not to use it.

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

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

No annotations are provided, so the description must disclose behavior. It includes a '[READ]' tag indicating no side effects, and describes auto-location behavior for the node parameter. However, it does not describe the return format or fields, nor any auth requirements. Since a read operation is generally safe, a score of 3 is appropriate.

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 with a clear structure: a heading tag '[READ]', a one-line purpose statement, and a bulleted argument list. Every sentence adds value, with no fluff. The front-loaded action and parameter descriptions are 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?

Given the tool's simplicity (3 params, no nested objects, no output schema), the description covers purpose, parameters, and a behavioral note (auto-location). It also cross-references vm_list for obtaining a vmid. A minor gap is the lack of detail on what the returned status includes, but overall it is fairly complete.

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

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

Schema description coverage is 0%, so the description must add meaning. It describes each parameter: vmid as numeric Proxmox VM id (with reference to vm_list), target as target name from config, and node as node name with optional auto-locate. This provides semantic context beyond the schema's type and default values.

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 '[READ]' and states 'Return current status detail for a single VM by vmid.', clearly indicating the verb and resource. It distinguishes from sibling tools like vm_list (list all VMs) and vm_config (likely configuration) by focusing on a single VM status.

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 specifies the context: retrieving status for a single VM. It does not explicitly state when not to use or list alternatives, but the parameter guidance (e.g., 'node: Node name; omit to auto-locate') provides implicit usage context. A slightly higher score would require explicit exclusions or alternative tool mentions.

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 that it is a read operation ([READ]) and explains how it scans nodes (given node, default node, or all cluster nodes). This is good transparency, though it does not mention authentication or rate limits, which are not critical for a list 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 concise (~100 words) and well-structured: first sentence captures the core, then expands on scope, then lists parameters. No superfluous information; 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?

Given no annotations, no output schema, and low schema coverage, the description adequately covers the tool's input and behavior. It mentions return fields but lacks details on error handling or edge cases, which is acceptable for a list 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?

With 0% schema coverage, the description provides meaningful explanations for both parameters: target (Proxmox target name) and node (node name), including their defaults and interaction. This fully compensates for the missing schema 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 it lists QEMU VMs with specific fields (name, vmid, status, cpu, mem). It distinguishes from vm_get, which provides full status of a single VM, making the purpose specific and 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?

Explicitly tells when to use this tool (for listing VMs in a node/cluster) and when to use the alternative vm_get (for full status of a single VM). It also explains the scanning behavior across nodes, providing clear context for 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?

No annotations are provided, so the description must fully disclose behavioral traits. It only states the tool returns snapshot names and descriptions, and that it is a read operation. It does not mention whether it lists all snapshots, if it requires the VM to exist, or any side effects. The description is minimal and lacks important behavioral context.

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

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

The description is very concise, consisting of a one-line summary followed by a bulleted list of args. It wastes no words and front-loads the purpose with '[READ]'. Every sentence serves a clear role.

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 three parameters and no output schema, the description covers the basics: what the tool does, its parameters, and their meanings. However, it lacks guidance on when to use it among siblings, error handling, or what else the output might contain beyond name and description. For a simple list tool, it is adequate but not thorough.

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

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

The input schema has 0% description coverage, so the description adds value by explaining each parameter: vmid is a numeric Proxmox VM ID, target is a Proxmox target name, and node can be omitted for auto-location. This provides meaningful context beyond the schema's type information, though the explanations are brief and could be more detailed.

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

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

The description clearly states the tool's purpose: listing snapshots for a VM, and it begins with '[READ]' to indicate a read operation. The verb 'list' and resource 'snapshots for a VM' are specific. However, it does not explicitly distinguish from sibling snapshot tools like vm_snapshot_create or vm_snapshot_delete, but the name and description alone sufficiently convey its role.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, contexts, or exclusions. For example, it could state 'Use this to view existing snapshots before creating or reverting' or contrast with sibling tools, but it does not.

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 provided, so description bears full weight. It identifies as a WRITE operation, asynchronous, and explains dry_run preview. Could add more on safety or prerequisites, but covers key behavioral aspects.

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

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

Efficiently structured: one-line summary, usage notes, then parameter list. No wasted words, all sentences add 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?

Covers main aspects: purpose, async nature, parameters, return value (task UPID). Lacks details on error handling or node capacity requirements, but sufficient for agent understanding given tool 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?

With 0% schema coverage, the description compensates fully by explaining each parameter in Arg format, including defaults and behavior (e.g., online for live vs. stopped migration). Adds significant meaning beyond 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 tool performs VM migration, returns a task UPID, and notes the inverse operation. It distinguishes effectively from sibling tools like vm_start or vm_stop.

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

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

Provides clear context: asynchronous operation requiring task_status polling, and dry_run for preview. However, it lacks explicit when-not-to-use guidance or comparison with alternatives.

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?

Discloses async execution, undo token recording, and dry_run behavior. No annotations provided, so the description carries the full burden; it covers essential behavioral traits without omissions.

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?

Efficiently structured with a header, a core sentence, and a clean list of parameter descriptions. No redundant or irrelevant 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?

Covers all 7 parameters, describes async behavior and return type, explains undo token and dry_run preview. No output schema exists, but 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?

With 0% schema coverage, the description fully compensates by explaining each parameter with examples and context (e.g., disk key format, auto-locate for node), adding significant 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?

Clearly states the action ('Move a VM disk to another storage'), identifies the return type ('task UPID'), and distinguishes from sibling operations like vm_migrate or vm_clone.

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 marks as [WRITE] and describes dry_run for preview, but does not provide explicit when-to-use or when-not-to-use comparisons with siblings. Still clear enough for appropriate invocation.

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?

Discloses the operation is a write ('[WRITE]') and 'graceful', but with no annotations, fails to detail permission requirements, whether the reboot is synchronous or asynchronous, or any side effects on VM state beyond reboot.

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

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

Two concise paragraphs with no fluff. Front-loaded with purpose and key behavioral note. Parameter list is minimal and clear.

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 reboot operation with 3 simple parameters and no output schema, the description covers the main points. Omits details like 'graceful' semantics, idempotency, or cooldown, but these are minor for a typical reboot.

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?

Without schema descriptions (0% coverage), the description explains all three parameters: vmid (numeric id), target (Proxmox target name from config), and node (optional, auto-locate if omitted). This adds crucial meaning beyond types.

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

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

Clearly states 'Reboot a VM (graceful)' with a specific verb and resource. The '[WRITE]' prefix adds context. Distinguishes from sibling tools like vm_shutdown and vm_stop by implying a restart (not stop or shutdown).

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 notes 'No undo token — reboot has no inverse', warning agents about irreversibility. However, does not explicitly compare to alternatives like vm_shutdown or vm_stop for when a reboot is preferred over a shutdown/start sequence.

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?

Discloses write operation, undo capture mechanism, and dry_run preview. Without annotations, the description carries the burden and adequately covers key behaviors, though return values are omitted.

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?

Very concise: one-line action tag, a short paragraph, then bulleted args. Front-loaded with key info, no wasted words, 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?

Covers main usage and undo behavior, but lacks description of return values and error conditions. For a 6-parameter tool without output schema, more detail on expected output would improve completeness.

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

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

Each parameter is explained: vmid as numeric ID, cores/memory as optional new values, dry_run as preview, target as Proxmox target, node as optional. Some parameters like 'target' could be more detailed, but overall adds value beyond schema.

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

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

The description clearly states it changes a VM's cores and/or memory, with explicit verb and resource. It distinguishes from sibling tools like vm_resize_disk and vm_config by focusing on core/memory reconfiguration.

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

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

Provides clear instructions: provide at least one of cores/memory, use dry_run to preview. Lacks explicit comparison to alternatives or when not to use, but gives sufficient context for typical 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, the description fully discloses that this is a write operation, is destructive and irreversible for growth, and offers a preview mechanism via dry_run. This is comprehensive for a mutation 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 well-organized with a header, warning, and an Args list, but the details could be slightly more compact. However, it remains efficient and front-loaded with key 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?

Given no output schema and no annotations, the description covers the action, constraints, and all parameters adequately. It omits return value details but is otherwise complete for a disk resize 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?

Despite 0% schema description coverage, the description explains each parameter with examples and context (e.g., 'size: '+<N>G' increment', 'disk: Disk key, e.g. ''scsi0'''), adding significant value beyond the schema's type and title.

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 starts with '[WRITE] Grow a VM disk. GROW-ONLY — shrink requests are refused.' which clearly states the action and a critical constraint, distinguishing it from other disk-related tools like vm_move_disk or vm_reconfigure.

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 guidance on irreversible nature ('No undo token'), preview option ('Pass dry_run=True'), and growth-only constraint. However, it does not explicitly compare with sibling tools like vm_move_disk, leaving implicit differentiation.

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 provided, so description carries full burden. It discloses graceful shutdown behavior and dry_run option, but does not detail side effects like whether the VM fully powers off or remains in a stop state. Adequate but not thorough.

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 key purpose and distinction. The Args section lists parameters efficiently, though it lengthens the description. Good structure but could be slightly more 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?

Covers core function and parameter usage. Lacks details on expected output or behavior when VM is already off, but given no output schema and sibling tools, it is minimally complete.

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

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

Schema coverage is 0%, so description must compensate. It explains each parameter's meaning (vmid as numeric ID, dry_run as preview, target as config name, node as auto-locatable). Adds value beyond the schema types.

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

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

The description clearly states it performs a graceful ACPI shutdown, distinguishes from 'hard vm_stop', and notes the inverse operation 'vm_start'. The purpose is specific and easily understood.

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

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

Provides comparative guidance against vm_stop and mentions dry_run for testing. Could be more explicit about when not to use (e.g., for emergency stops), but the sibling reference gives clear context.

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

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

With no annotations provided, the description carries full burden. It marks the operation as [WRITE] and describes parameters, but does not disclose side effects (e.g., VM pause, disk I/O), required permissions, or whether the VM must be running. The dry_run preview is helpful but incomplete for full behavioral understanding.

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: a one-line purpose, a hint about dry_run, and a bulleted parameter list. Every sentence provides necessary information without redundancy or filler. The structure front-loads the core action and then details parameters efficiently.

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

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

Given the complexity of a VM snapshot creation tool and the absence of an output schema, the description omits important execution context: what is returned (success message, snapshot ID?), whether it is synchronous, prerequisites (VM must exist, must be running?), and potential errors. The dry_run preview is mentioned but not explained in terms of 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?

The input schema has 0% description coverage, so the description's parameter explanations add critical meaning. It clarifies vmid as 'Numeric Proxmox VM id', name as 'Snapshot name (must be unique for the VM)', dry_run as preview toggle, and node as auto-locate. The 'target' parameter is somewhat vague ('Proxmox target name from config'), but overall adds substantial value.

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 'Create a named snapshot of a VM' with the verb 'Create' and resource 'snapshot of a VM'. The '[WRITE]' tag and inverse reference to 'vm_snapshot_delete' immediately distinguish it from sibling snapshot tools like listing or rollback.

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 mentions the inverse tool 'vm_snapshot_delete' and suggests using 'dry_run=True to preview', providing context for safe usage. However, it lacks explicit when-not-to-use guidance or comparisons to related tools like vm_list_snapshots or vm_snapshot_rollback, though the inverse hint partially compensates.

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 explicitly labels the tool as '[WRITE]' and warns 'Destroys a rollback point — no undo', fully disclosing its destructive nature.

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 purpose. The Args section adds structure, but could be slightly tighter without losing clarity.

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 destructive tool with no output schema, the description lacks explicit mention of return values or success/failure indicators. This is a notable gap given the 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 coverage is 0%, but the description explains all five parameters with practical details: vmid type, name source, dry_run preview, target config reference, and node auto-location behavior.

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 'Delete a named snapshot from a VM', identifying the action and resource. It distinguishes from sibling snapshot tools (create, list, rollback) and warns about destruction.

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 explains dry_run for preview and references vm_snapshot_list for available names. However, it does not explicitly mention when to prefer alternatives or avoid this tool (e.g., irreversible action).

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

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

With no annotations, the description carries full burden. It discloses irreversibility, that changes are discarded, no undo token, and the need for confirmation. Could mention resulting VM state but is sufficient.

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?

Highly concise: a clear header, warning, dry_run note, and bulleted args list. Every sentence adds value, 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?

Covers purpose, behavior, parameters, and usage guidance. Could be slightly more complete with post-rollback state, but given no output schema, it is sufficiently informative for an agent.

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

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

Schema coverage is 0%, so description fully compensates. Explains each parameter: vmid is numeric Proxmox ID, name references vm_list_snapshots, dry_run preview, target from config, node auto-locate. Adds meaningful context beyond schema.

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

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

The description clearly states 'Roll a VM back to a snapshot' with an explicit verb and resource. It distinguishes from sibling tools like vm_snapshot_create and vm_snapshot_delete by focusing on rollback.

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

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

Provides strong usage guidance: warns of irreversibility, requires user confirmation, suggests dry_run preview, and references vm_list_snapshots for valid snapshot names. Lacks explicit 'when not to use' but implies caution.

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 labels the operation as a write, indicates the return value, and explains the optional node parameter with auto-location behavior. However, it does not discuss permissions, side effects, or behavior when the VM is already started.

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 header line and an Args section that lists parameters and their meanings. 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?

Given no annotations or output schema, the description provides a good overview. It could mention that the VM should be in a stopped state to start and explain the UPID return format, but it is sufficiently complete for a simple operation.

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

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

With 0% schema description coverage, the description adds essential semantics: vmid is numeric, target comes from config, node is optional with auto-location. This compensates well for the empty schema 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 action 'Start a VM' with '[WRITE]' and specifies the return type 'Proxmox task UPID'. It distinguishes the tool from its siblings by naming the inverse 'vm_stop'.

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 mentions only the inverse tool vm_stop, but does not provide guidance on when to use this tool over other related sibling tools like vm_reboot or vm_shutdown. No prerequisites or context for use are given.

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 no annotations, the description discloses the destructive nature (hard stop, dirty filesystem), audit trail, and dry-run capability. It does not explicitly mention permission requirements, but the behavioral disclosure is strong.

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, well-structured with a summary paragraph and an Args section. No redundant sentences; every line 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?

Given no output schema, the description explains the return value (UPID) and effectively differentiates from sibling tools like vm_shutdown. It fully addresses the tool's purpose, usage, and behavior with no 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?

With 0% schema description coverage, the description adds essential meaning for all four parameters: vmid is numeric, dry_run is for preview, target from config, node auto-located if omitted. This compensates well.

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 hard-stop (power off) of a VM and returns the task UPID, distinguishing it from the inverse vm_start and from graceful shutdown via vm_shutdown.

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

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

It explicitly notes that this is an immediate power-off, not a graceful shutdown, and warns about possible filesystem issues, guiding the agent on when to use this vs alternative tools. It also mentions the dry_run option for preview.

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