proxmox-mcps

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

Annotations already mark destructiveHint: true. The description adds context that the service will be restarted on failure, which explains the destructive nature. No contradiction. It provides useful behavioral insight beyond annotations.

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

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

Two concise sentences: first defines purpose, second adds risk and action requirement. No wasted words, 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?

Covers purpose, risk, and confirmation requirement. However, with 7 parameters and no output schema, it lacks information about return values or asynchronous behavior. Adequate but leaves gaps.

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

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

Schema description coverage is high (71-86%), so the schema already explains most parameters. The description adds value by linking the confirm parameter to the usage guideline ('Ask the user to confirm'), but doesn't add significant meaning to other params.

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 makes a VM or container HA-managed, matching the name 'add_ha_resource'. It doesn't explicitly differentiate from siblings like list_ha_resources or migrate_ha_resource, but the purpose is distinct enough.

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

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

The description explicitly advises high risk and requiring user confirmation before invocation, which is a strong usage guideline. It doesn't mention when not to use or alternatives, but the confirmation condition is a clear directive.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds context that the tool rebuilds config and reloads daemons, and reinforces the high-risk nature, providing value beyond the structured annotations. No contradiction.

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

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

Two sentences with no wasted words. The action and risk warning are front-loaded, making it easy to parse quickly.

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, risk, and basic mechanism. For a mutation tool with no output schema and one parameter, it is mostly complete. Could mention reversibility or failure modes, but the destructive hint covers the risk aspect.

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 100% coverage with one parameter (confirm). The description indirectly refers to the need for user confirmation but does not explicitly describe the parameter's semantics. Given high schema coverage, baseline 3 is appropriate.

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

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

The description clearly states the tool pushes pending SDN changes to the cluster, with specific actions (rebuilds config and reloads daemons). The verb 'Push' and resource 'pending SDN changes' provide a specific purpose that distinguishes it from sibling tools like create_sdn_* or delete_sdn_*.

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 explicitly advises 'HIGH RISK — ask the user to confirm before invoking,' providing a clear usage directive. While it does not explicitly mention when not to use or list alternatives, the risk warning implies appropriate conditions for 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?

Annotations provide idempotentHint and non-destructive hint. Description adds direct call to task-stop endpoint and the caveat that some operations may not cancel cleanly, offering useful behavioral context beyond annotations.

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 efficient sentences with no redundant information. Every sentence provides 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 single-parameter tool without output schema, description covers purpose, mechanism, and a limitation. Could mention polling for status, but overall 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 100% with description 'Job identifier' for job_id. Description adds no extra parameter semantics beyond schema, so baseline of 3 is appropriate.

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

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

Description clearly states the tool 'request[s] cancellation of a tracked job' and mentions the endpoint, distinguishing it from sibling tools like get_job, list_jobs, or retry_job.

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

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

No guidance on when to use this tool vs alternatives (e.g., retry_job, poll_job). Only a warning about clean cancellation, but no explicit usage contexts.

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

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

Annotations already indicate mutation (readOnlyHint=false) and non-destructive nature. The description adds the ability to clone to different nodes but lacks details on other behaviors like default full clone.

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

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

The description is a single, well-structured sentence that delivers the core purpose without any superfluous 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 complex tool with 9 parameters and no output schema, the description is too minimal; it fails to explain key aspects like return values, parameter meanings, or the full clone default.

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 and no parameter explanations in the description, the agent receives no guidance on the meaning or usage of the nine parameters.

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 (clone), the resource (container), and the scope (same or different node), distinguishing it from similar tools like clone_vm.

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 cloning containers but provides no explicit guidance on when to use this tool versus alternatives or any prerequisites/conditions.

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

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

Description adds minimal behavioral context beyond annotations. Annotations already indicate mutability (readOnlyHint=false) and non-destructiveness. However, description does not disclose important details like whether source VM must be stopped, how clone is created, or success/failure 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?

Single sentence, no wasted words. Could be slightly more informative without becoming verbose, but it's efficiently 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?

For a tool with 9 parameters and no output schema, the description is too brief. It does not explain the difference between full and linked clones, constraints, or what the operation entails. Incomplete for a complex 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?

Schema description coverage is 100% (all 9 parameters documented in schema). Description does not add any additional parameter information beyond what's in schema. Baseline score of 3 is appropriate.

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

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

Description clearly states 'Full or linked clone of an existing VM', specifying both the action (clone) and the resource (VM), and distinguishes between clone types. This differentiates it from sibling tools like 'clone_container' or 'create_vm'.

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 (e.g., migrate_vm, create_vm). Does not mention prerequisites like VM state or permissions, nor when to choose full vs linked clone.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, indicating a safe read operation. The description adds no extra behavioral context beyond the annotation coverage.

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

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

The description is a single sentence of four words, very concise. Every word is meaningful, but it could include additional key information without becoming verbose.

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

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

Given no output schema and the presence of sibling tools, the description is incomplete. It does not explain what the returned options look like, nor does it provide context about typical usage or scope.

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 should explain the purpose of 'node' and 'vmid' parameters. However, it does not mention them at all, leaving the agent without semantic context for the required inputs.

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 'Return container firewall options' clearly states a get/read operation on a specific resource. It distinguishes from siblings such as 'container_firewall_rules' and 'vm_firewall_options' via the resource name, though it does not explicitly differentiate them.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'container_firewall_rules' or 'vm_firewall_options'. No context or scenarios are mentioned.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the description adds no extra behavioral context. It does not mention return format, pagination, or authentication needs.

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

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

A single concise sentence, but it lacks important details that could be included without sacrificing brevity.

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 and minimal description; the tool returns firewall rules, but the structure or content of those rules is not described, leaving the agent without enough context for parsing the result.

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

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

With 0% schema description coverage, the description should explain the parameters (node and vmid). It only says 'for an LXC container', leaving the agent to infer parameter semantics from the tool name.

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

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

The description clearly states the action (Return) and the resource (firewall rules for LXC container), distinguishing it from sibling tools like vm_firewall_rules and container_firewall_options.

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, such as container_firewall_options or vm_firewall_rules. No prerequisites or context provided.

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

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

Annotations indicate non-read-only and non-idempotent behavior, but the description fails to disclose details such as ticket expiration or side effects. Without an output schema, more clarity on the return value would be helpful.

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

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

The description is a single sentence of 8 words with no fluff, making it highly concise and front-loaded.

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 (2 required params, no output schema) and context of sibling remote access tools, the description lacks critical details like return value, prerequisites, and usage 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?

Schema description coverage is 0%, and the description does not explain the parameters 'node' and 'vmid', leaving the agent to infer their meaning from context.

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

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

The description clearly states the verb 'generate' and the resource 'SPICE ticket for an LXC container', effectively distinguishing it from similar tools like container_vncproxy and container_termproxy.

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 container_termproxy or vm_spiceproxy, nor are prerequisites or conditions mentioned.

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

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

Annotations indicate readOnlyHint=false, idempotentHint=false, destructihint=false, which align with generating a ticket (a stateful, non-idempotent, non-destructive operation). The description does not add further behavioral context such as authentication requirements or ticket expiration, but it does not contradict annotations.

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

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

The description is a single concise sentence of 7 words with no fluff. It is appropriately front-loaded with the core action.

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

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

The description is too brief for a tool with no output schema and 0% parameter coverage. It does not explain what a terminal proxy ticket is, how to use the result, or any side effects. Sibling tools exist, but no differentiation is provided.

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% parameter description coverage, and the description adds no meaning for the two parameters ('node' and 'vmid'). It does not explain that 'node' refers to the Proxmox node or that 'vmid' is the container ID, leaving the agent without guidance on required 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 clearly states the verb 'generate' and the resource 'terminal proxy ticket' for 'an LXC container'. It distinguishes from sibling tools like container_spiceproxy and container_vncproxy by specifying 'terminal proxy' rather than SPICE or VNC.

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 such as container_spiceproxy or container_vncproxy. The description does not mention prerequisites, use cases, or exclusions.

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

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

The description says 'Generate' implying a write operation, consistent with readOnlyHint=false. However, it does not disclose behavioral details like ticket expiration, temporary nature, or that the ticket is typically used for immediate connection. No contradiction with annotations.

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

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

The description is a single sentence and concise, but it omits critical information. For a tool with three parameters and no output schema, brevity comes at the cost of completeness.

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 (3 parameters, no output schema) and the presence of sibling tools, the description is insufficient. It does not explain the return value (the ticket), how to use the ticket, or the role of the websocket parameter. The description fails to compensate for missing schema descriptions and annotations.

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 no meaning to the parameters (node, vmid, websocket). It fails to explain that 'websocket' is a boolean indicating whether a WebSocket connection is requested, leaving the agent to rely solely on the schema.

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

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

The description clearly states the tool generates a VNC ticket for an LXC container console, specifying the resource type (container) and output (ticket). However, it does not differentiate from sibling tools like container_spiceproxy or container_termproxy, which target different console protocols.

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 (e.g., SPICE or terminal proxy). The description does not mention prerequisites, such as the container needing a VNC console enabled, or that this ticket is typically used with a WebSocket connection.

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 high risk and the side effect that the original becomes read-only, going beyond the annotations which only mark it as destructive. It also instructs on user confirmation, adding 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 two sentences with no wasted words. It front-loads the purpose and immediately adds risk and user instruction. Every sentence contributes 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 destructive nature and lack of output schema, the description provides enough context for safe invocation: it explains the action, risk, and need for confirmation. It could mention what happens to the container after conversion, but the core context is there.

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 does not explain any of the three parameters (node, vmid, confirm). With schema description coverage at only 33%, the description should compensate but fails to do so, leaving the agent to infer from parameter names alone.

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: converting an LXC container to a template, and it distinguishes from the sibling 'convert_vm_to_template' by specifying 'LXC container'. The verb 'Convert' and resource 'container' are specific.

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 ask user for confirmation before invoking, providing clear context for when it's appropriate. However, it does not explicitly compare with alternatives like 'convert_vm_to_template' or mention when not to use this tool.

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 that the original VM becomes read-only and emphasizes high risk, adding value beyond annotations (destructiveHint=true).

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

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

Two concise sentences that efficiently convey purpose, risk, and action needed without 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 and lack of output schema, the description covers the core purpose, side effects, and user actions adequately.

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 only 33% schema description coverage, the description fails to explain the 'node' and 'vmid' parameters, which are not self-explanatory to all users.

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 'Convert a VM into a Proxmox template' with a specific verb and resource, distinguishing it from sibling tools like convert_container_to_template.

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?

Indicates high risk and requires user confirmation, but does not explicitly state when to use vs. alternatives like cloning.

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

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

Annotations indicate non-destructive and non-idempotent behavior, but the description adds no context about permissions, execution time, or side effects beyond triggering backup. Does not add value over annotations.

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

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

Single sentence is highly concise and front-loaded with the action, 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?

Lacks information about return values (e.g., task ID) since no output schema is provided. Also missing prerequisites or behavior details for a tool with 6 parameters.

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 covers all 6 parameters with descriptions, so the tool description does not need to add extra meaning. Baseline 3 applies.

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 triggers a vzdump backup for a VM or container to a storage pool, specifying the verb, resource, and target, distinguishing it from sibling tools like clone_vm or create_backup_job.

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 create_backup_job or run_backup_job. Does not mention prerequisites or exclusions.

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

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

Annotations already indicate write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds no additional behavioral context, such as side effects or state changes.

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 too concise (one sentence) and under-specified. It fails to provide enough information to be genuinely helpful, sacrificing substance for brevity.

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 high complexity (22 parameters, no output schema, many siblings), the description is completely inadequate. It omits return values, prerequisites, and scheduling details.

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 22 parameters and only 45% schema description coverage, the description adds no parameter information. Required parameters like schedule and storage are not explained beyond what the schema provides.

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 ('schedule') and resource ('recurring vzdump backup job'), distinguishing it from siblings like create_backup (immediate backup) and run_backup_job (run existing job).

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 such as run_backup_job or update_backup_job. No exclusions or context 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?

While the description matches the readOnlyHint=false annotation, it fails to disclose potential side effects (e.g., ID conflicts, template resolution failure) or any needed permissions. The openWorldHint=true suggests side effects, but the description does not elaborate.

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

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

The description is a single, clear sentence with no redundant information. It efficiently conveys 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?

Given the tool's complexity (16 parameters, no output schema), the description is too sparse. It does not explain return values, failure scenarios, or dependencies, leaving the agent ill-equipped to handle edge cases.

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

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

With 88% schema description coverage, the schema already documents most parameters well. The description adds no additional parameter-specific information, staying at the baseline for high-coverage cases.

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 (create), the resource (LXC container), and the source (vztmpl template). It effectively distinguishes the tool from sibling tools like clone_container or create_vm.

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, lacks prerequisites or context about required parameters, and does not mention any constraints like ID uniqueness or template availability.

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

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

Annotations already declare destructiveHint=true, and the description adds 'HIGH RISK' and a request for user confirmation, which goes beyond the annotation and provides actionable behavioral guidance without contradiction.

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

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

Two sentences front-load the purpose and a critical warning. Every sentence adds value with no redundancy or fluff.

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

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

The description is adequate for a creation tool given the annotations, but it lacks details on return values, side effects beyond destruction, or explanation of the failover/restart policy flags, which 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?

Schema description coverage is 50% (3 of 6 params have descriptions). The description mentions 'preferred nodes' and 'failover/restart policy' but does not fully document all parameters, leaving comment, nofailback, and restricted undefined.

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 creates an HA group with preferred nodes and a failover/restart policy. The verb 'Create' and resource 'HA group' are specific, and it distinguishes from sibling tools like update_ha_group and delete_ha_group.

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 warns 'HIGH RISK — ask the user to confirm before invoking,' providing a clear usage constraint. However, it does not explicitly contrast with alternative tools like update_ha_group or list_ha_groups.

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

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

The description states 'HIGH RISK — wrong config can disconnect the node,' which aligns with the destructiveHint annotation (true) and adds context about the potential impact. It does not contradict annotations and adds valuable behavioral insight beyond the annotation flags.

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

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

The description is two short sentences, front-loading the purpose and the critical warning. Every word adds value with 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?

Given 14 parameters, no output schema, and annotations indicating destructive behavior, the description is insufficient. It provides a crucial risk warning but fails to explain the role of many parameters, return values, or expected behavior. Important context like prerequisites or the confirm parameter is only mentioned in the schema, not in the description.

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 only 14% (only iface and confirm have descriptions). The description adds no additional parameter details beyond mentioning interface types (bond, bridge, VLAN, physical), which partially maps to the 'type' parameter. Other critical parameters like address, gateway, slaves, etc., are left unexplained, so the description does not adequately compensate for the low 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 explicitly states 'Create a network interface (bond, bridge, VLAN, or physical).' This clearly identifies the action (create) and the resource (network interface), with specific types, distinguishing it from sibling tools like delete_node_network or update_node_network.

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 warns 'HIGH RISK — wrong config can disconnect the node. Ask the user to confirm before invoking.' This provides clear when-to-use (creating network interfaces) and a strong caution, including an instruction to get user confirmation. However, it does not explicitly state when not to use or compare 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 destructive behavior and disk wiping, which goes beyond the destructiveHint annotation. Provides clear behavioral context for agent decision-making.

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

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

Two sentences, front-loaded with purpose, immediately followed by critical warning. No redundancy or 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?

Adequate for a destructive creation tool but lacks description of return value or behavior beyond creation. Missing parameter details reduce completeness for parameter-heavy tool.

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

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

Schema description coverage is only 43% (3 of 7 params have descriptions). Description adds no extra parameter information, leaving ashift, raidlevel, compression, and node undocumented. Fails to compensate for low 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?

Description clearly states it creates a ZFS pool across disks. Distinguishes from sibling create_pool by name but lacks explicit differentiation. However, verb+resource is 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?

Includes destructive warning and user confirmation instruction, but no guidance on when to use this tool vs alternatives like create_pool or init_node_disk. Context for when not to use is missing.

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

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

Annotations already indicate mutation (readOnlyHint=false) and non-destructiveness. The description adds 'Optionally assign VMs/CTs' which is not in annotations, but this is also captured in the schema. No other behavioral context provided.

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

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

Two sentences, 14 words, no redundant information. Efficient and front-loaded.

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?

Adequate for a creation tool with 4 parameters and no output schema. Missing information about uniqueness constraints, return values, or error conditions.

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 75%. The description clarifies that VMs/CTs assignment is optional, aligning with the schema not marking it required. No additional meaning for other parameters 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 the verb 'Create' and the resource 'resource pool', with an optional assignment capability. It distinguishes from siblings like delete_pool, get_pool, update_pool, list_pools.

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, no prerequisites, no exclusions mentioned.

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

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

Annotations already indicate this is not read-only (readOnlyHint=false) and not idempotent (idempotentHint=false). The description adds the requirement of matching storage but does not discuss side effects like network usage or whether creation triggers immediate replication. With openWorldHint=true, more behavioral context would be beneficial.

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 sentence for the primary action and one for a critical requirement. Every word serves a purpose, and there is no fluff. It is appropriately front-loaded.

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 (8 parameters, 4 required, no output schema), the description is incomplete. It omits details about the schedule format, the difference between local and remote types, error handling (e.g., duplicate job IDs), return values, and immediate effects. The agent would need to infer too much from the schema alone.

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 63%, but the tool description provides no additional explanation for any parameters beyond what is in the schema. For example, the schedule format is only hinted at in the schema's example, and the type enum (local/remote) is not explained. The description adds no value for parameter understanding.

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

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

The description clearly states the verb 'Create' and the resource 'ZFS replication job' for a VM or container, distinguishing it from siblings like update_replication_job and delete_replication_job. It also includes a key requirement (target storage must match), which aids in correct usage.

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 a prerequisite ('Target must have a matching storage') but lacks explicit guidance on when to use this tool versus alternatives like update_replication_job. It does not mention that the job is scheduled or that the same job ID should not be duplicated. The context is adequate but not comprehensive.

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

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

Adds context beyond annotations by explicitly stating the high risk and dependency on network connectivity. Annotations already indicate destructiveHint=true, but the description reinforces the need for caution.

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

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

Two sentences with no extraneous text. First sentence states purpose and supported protocols, second sentence highlights risk and required confirmation. Front-loaded and efficient.

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

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

Adequate for a high-risk tool with 9 parameters and no output schema. The description covers the risk aspect and confirmation requirement, but does not explain return values, prerequisites, or how parameters interact.

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 only 44% schema description coverage, the description does little to clarify parameters beyond the schema. It mentions 'evpn', 'isis', 'bgp' types but does not explain other critical parameters like node, peers, loopback, or ebgp_multihop.

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 tool creates an SDN controller and lists supported protocols (EVPN/ISIS/bgp). Distinguishes from sibling tools like update_sdn_controller and delete_sdn_controller by naming the action, but could be more explicit about what an SDN controller is versus other SDN components.

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 no guidance on when to use this tool versus alternatives (e.g., update_sdn_controller, create_sdn_subnet). Only instructs to ask user for confirmation, which is a safety measure but not a usage criterion.

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

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

Annotations indicate destructiveHint=false and readOnlyHint=false, which the description does not contradict. However, the description adds no behavioral details beyond annotations, such as failure modes on duplicate subnets or required permissions.

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

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

The description is a single sentence and front-loaded, but it is too brief to convey necessary details. While concise, it sacrifices completeness.

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 7 parameters, no output schema, and no behavioral info, the description is severely lacking. It does not explain return values, error conditions, or the effect of optional parameters.

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 only 14% (only the 'subnet' parameter has a description). The tool description does not explain any parameter, leaving the agent to rely solely on the schema, which is insufficient for the 7 parameters.

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 ('Create'), the resource ('IP subnet'), and the context ('inside an SDN vnet'). It distinguishes this tool from related sibling tools like create_sdn_vnet and create_sdn_zone.

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 (e.g., updating or deleting subnets) or prerequisites (e.g., the vnet must exist). The usage context is only implied.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false) and possibly open-world. The description adds no extra behavioral context (e.g., side effects, permission requirements, or what happens to resources). It simply restates the tool's purpose.

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 (one short sentence) and front-loaded with the key purpose. However, it is so minimal that it omits potentially useful details, though it avoids verbosity.

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

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

Given the tool has 6 parameters (2 required) and no output schema, the description is too brief to fully guide the agent. It fails to explain constraints, return values, or how this tool fits into the broader SDN workflow among many siblings.

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 only 17% schema description coverage, the description does not explain any parameters beyond what the schema provides. The schema itself lacks descriptions for most parameters (name, tag, alias, comment, vlanaware), and the tool description does not compensate.

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 ('Create') and the resource ('SDN virtual network'), and specifies 'zone-scoped', which helps distinguish it from related tools like create_sdn_subnet or create_sdn_zone.

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 (e.g., create_sdn_subnet). The zone-scoping hint is implicit, but there are no when-not-to-use conditions or prerequisites mentioned.

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

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

Description adds the behavioral trait of high risk and confirmation requirement, consistent with annotations (destructiveHint: true). Could elaborate on effects but adequate.

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

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

Two sentences, zero waste. First sentence states purpose, second adds critical risk warning. Highly 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?

Adequate for a creation tool with risk warning, but given 9 parameters and no output schema, more context on parameter usage 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?

With only 22% schema description coverage, description adds little parameter meaning beyond listing types. Most parameters (mtu, peers, bridge, vxlan_port, vlan_protocol) lack any explanation.

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 (create) and resource (SDN zone), listing supported types (vxlan/evpn/simple/qinq/vlan). Distinguishes from siblings like create_sdn_controller or create_sdn_subnet.

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 'HIGH RISK — ask the user to confirm before invoking', providing clear usage guidance. Does not contrast with specific alternatives but context is sufficient.

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

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

Annotations declare readOnlyHint=false (write) and destructiveHint=false (non-destructive). Description adds behavior about optional RAM state and its limitation to QEMU. However, it omits important behavioral traits like prerequisites (VM running for RAM snapshot), storage impact, or that creating a snapshot may temporarily pause I/O.

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

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

Single sentence conveying the core purpose efficiently. No redundant or filler words.

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

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

For a write tool with 6 parameters and no output schema, the description lacks critical context: when to include RAM state (VM must be running?), any requirements on the node, what happens after creation (success/error response), and the relationship with other snapshot tools. Annotations cover safety but not 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?

Schema coverage is high (83%), so baseline is 3. Description 'optionally including RAM state' implicitly relates to the vmstate parameter but does not add new meaning beyond schema descriptions. No additional constraints or contexts are given for parameters.

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

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

Description clearly states the action ('Take a snapshot'), the resource ('QEMU VM or LXC container'), and a distinctive feature ('optionally including RAM state'). This differentiates it from sibling tools like delete_snapshot and list_snapshots.

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

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

Usage is implied ('take a snapshot'), but no explicit guidance is given on when to use this tool vs alternatives (e.g., rollback_snapshot, backup tools). No exclusions or prerequisites are mentioned.

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

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

Annotations already indicate destructiveHint=true, but the description adds specific context about potential data loss, which goes beyond the annotation. It also alerts the agent to require user confirmation. This adds behavioral 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?

Three concise sentences: purpose, risk warning, and action instruction. No wasted words, well-structured for quick comprehension.

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

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

Given the tool's high complexity (24 params, no output schema, destructive), the description is too brief. It lacks prerequisite conditions, parameter dependencies, result expectations, and error handling. The risk warning is present but incomplete for safe 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 24 parameters and only 13% schema description coverage, the description should clarify parameter usage but completely omits any parameter-level semantics. It relies solely on the sparse schema descriptions, which is insufficient for an agent to invoke correctly.

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 'Create a new storage pool' with types, but the vague 'etc.' and lack of precise definition of 'storage pool' in context slightly reduce clarity. It distinguishes from siblings like create_pool and other create_* 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 includes a warning about high risk and instructs to ask user confirmation, which is helpful, but it does not provide guidance on when to use this tool vs. alternative creation tools, such as create_pool for HA pools.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds auto-detection of default storage, but does not discuss permissions, side effects, or other traits not captured by annotations.

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

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

Two sentences, zero wasted words. The information is front-loaded and every sentence provides 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 high parameter count and no output schema, the description is brief. It does not explain prerequisites (e.g., node existence, vmid uniqueness) or default behavior for omitted parameters. Adequate but could be more complete.

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

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

The input schema has 100% coverage of parameter descriptions. The description adds no additional parameter semantics beyond noting auto-detection of storage, which is not a parameter. Baseline score of 3 applies.

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 ('Create a new QEMU VM') and the resource, and distinguishes from a sibling tool ('Use clone_vm to duplicate from a template').

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 an explicit alternative (clone_vm for duplication), indicating when to use a different tool. It lacks explicit exclusions but 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?

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds context about permanence and the need for user confirmation, enhancing transparency beyond the annotations.

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 succinct sentences, no extra words. The first sentence states the core action, the second provides a critical warning. Highly efficient.

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

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

For a simple destructive action, the description covers the essential behavior and warning. It lacks mention of required parameters (node, storage, volid) but the schema covers that, and there is no output schema to address.

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 50% schema description coverage, the description does not elaborate on parameters node, storage, or volid beyond the schema. The confirm parameter aligns with the 'ask user to confirm' advice, but overall parameter semantics are not improved.

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 'Permanently delete a vzdump backup file', specifying the verb (delete) and resource (vzdump backup file). This distinguishes it from sibling tools like delete_backup_job or delete_iso.

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 'DESTRUCTIVE — ask the user to confirm before invoking', providing a strong usage guideline. However, it does not explicitly mention when not to use this tool versus alternatives like prune_backups.

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 context beyond annotations by clarifying that existing backups are not deleted. However, annotations already declare destructiveHint=true, so the description reinforces but does not significantly extend behavioral insight.

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

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

The description is two sentences: one for purpose and scope, one for safety. Every word is necessary, no fluff. Ideal conciseness.

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

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

Given the tool's simplicity, destructive nature, and clear annotations, the description is complete: it explains what is deleted, what is not, and provides a safety instruction. No output schema exists, but the action's outcome is clear.

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 no parameter documentation. One parameter (id) is undocumented in both schema and description, while the confirm parameter is explained in the schema. With 50% schema coverage, the description fails to compensate for the missing id documentation.

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

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

The description clearly states the tool deletes a scheduled backup job, and explicitly notes that existing backups are not deleted. This distinguishes it from delete_backup and other 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 includes 'DESTRUCTIVE — ask the user to confirm before invoking,' providing a clear safety guideline. However, it does not explicitly state when not to use this tool (e.g., if you only want to disable but keep the job).

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

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

Annotations already indicate destructiveHint=true, and the description confirms permanence. It adds the behavioral instruction to ask for confirmation, which is useful. No contradictions found.

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

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

The description is a single concise sentence with a clear warning, front-loading the purpose and key action. 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 presence of annotations and simple input schema, the description covers the essential point of destruction and user confirmation. However, it omits the required parameters, behavior when container is running, and other practical details that would aid 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?

Schema description coverage is 50% (force and confirm have descriptions, node and vmid do not). The description does not explain any parameters beyond implicitly referencing confirm via 'ask the user to confirm'. It fails to compensate 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 the tool permanently deletes a container and its data, which distinguishes it from sibling tools like delete_vm or delete_backup. However, it does not explicitly specify that this applies to LXC containers, though context implies it.

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

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

The description advises asking for user confirmation due to destructive nature, but offers no guidance on when to use this tool versus siblings (e.g., delete_vm) or the force parameter. No preconditions or exclusions are mentioned.

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

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

Annotations already declare destructiveHint=true, but description adds meaningful behavioral detail: resources revert to default group. It also reinforces the destructive nature. No contradiction with annotations.

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

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

Two short sentences, front-loaded with the action, no filler words. Efficiently communicates purpose, side effect, and usage direction.

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 delete tool with 2 parameters and no output schema, the description covers the key behavioral aspects (reverting resources), confirmation requirement, and purpose. Adequate for agent understanding.

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 2 parameters with 50% description coverage (confirm has description). Description adds context by mentioning user confirmation, which ties to the confirm parameter, but does not elaborate on the group parameter beyond what schema provides.

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 'Delete an HA group' (specific verb+resource) and mentions side effect 'Resources assigned to it revert to the default group'. Distinguishes from sibling tools like create_ha_group, update_ha_group, list_ha_groups.

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 'DESTRUCTIVE — ask the user to confirm before invoking', providing a clear guideline for when to use (after user confirmation) and when not to use (without confirmation). No alternatives mentioned, but the guideline is strong.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false. The description adds 'Permanently delete' and the confirmation instruction, reinforcing the destructive nature and providing a safety step. No contradictions.

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

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

Two sentences, front-loaded with the action, no redundant words. 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 destructive delete tool with annotations and no output schema, the description is mostly complete. It lacks explanation of the three required parameters (node, storage, filename) but the schema provides their names and some descriptions. Overall adequate.

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

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

The description does not explain any parameters beyond the schema. Schema coverage is 50% (2 of 4 parameters have descriptions), and the description fails to add meaning for the undocumented parameters (node, storage). With low coverage, the description should compensate but does not.

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 'Permanently delete an ISO or template' uses a specific verb ('delete') and clearly identifies the resource type. It distinguishes this tool from siblings that delete VMs, containers, backups, snapshots, 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 includes 'DESTRUCTIVE — ask the user to confirm before invoking', which provides explicit guidance on when to use (when user requests deletion) and the need for user confirmation. It does not compare to alternative tools for listing ISOs, but the guidance 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?

Annotations already mark the tool as destructive (destructiveHint: true). The description adds valuable context on the behavioral impact (reverting to self-signed) and the required confirmation process, going beyond the annotations. It does not contradict annotations.

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 that cover purpose, risk, and usage instruction. Every word earns its place, with no redundancy or filler.

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

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

Given the lack of an output schema and the presence of 5 parameters including 'restart', the description omits explanation of the restart behavior and other consequences. It covers the essential risk and confirmation need but leaves some operational gaps.

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

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

Schema description coverage is 60%, which is moderate. The description itself adds no parameter-level details, leaving the schema to cover them. The baseline for this coverage is 3, as the description does not compensate further.

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

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

The description clearly states the action ('Delete a custom certificate from a node') with a specific verb and resource, distinguishing it from sibling delete tools. It immediately communicates the high risk and the consequence of reverting to self-signed.

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 explicitly warns of high risk, specifies the consequence ('reverts to self-signed'), and instructs to ask for confirmation before invoking. This provides clear guidance on when to use and the necessity of user approval, though it does not mention alternative actions like updating the certificate.

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 detailed behavioral context beyond annotations: it explains that the tool will disconnect any VM/CT using the interface, which is not captured by the destructiveHint=true annotation alone. No contradiction with annotations.

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

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

Two concise sentences delivering the core action and risk advisory. No redundant information; each sentence earns its place.

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

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

The description adequately covers the destructive nature and confirmation requirement. It could mention irreversibility or prerequisites, but the combination with schema required fields suffices for an agent to safely invoke the tool.

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

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

The description does not directly explain the 'node' and 'iface' parameters, relying on the schema. It adds value for the 'confirm' parameter by aligning with the instruction to ask for confirmation. With schema coverage at 33%, the description partially compensates but could detail parameter roles.

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 network interface' with a specific verb and resource, and distinguishes from siblings like create_node_network and update_node_network by highlighting the destructive nature and disconnection impact.

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 explicitly warns of high risk and instructs to ask for user confirmation. It provides clear context for when to use with caution, though it doesn't list specific alternatives 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?

The description says 'Remove' (mutation) but annotations set destructiveHint=false, which could be misleading. No additional behavioral context beyond annotations, such as permission requirements or side effects. IdempotentHint is set true, but the description does not reinforce this.

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 single sentence. No wasted words. However, it lacks detail that could be added without becoming verbose.

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

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

Minimal context for a simple tool. Does not explain what happens after removal (e.g., subscription status, license). No output schema means the description could clarify return behavior. Adequate but with noticeable gaps.

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

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

Schema has one 'node' parameter with 0% description coverage. The description does not explain what 'node' represents (e.g., node identifier). Fails to compensate for missing schema documentation.

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

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

The description 'Remove the Proxmox subscription from a node' clearly states the verb (Remove), resource (Proxmox subscription), and scope (from a node). It distinguishes from sibling tools like set_node_subscription (add/update) and get_node_subscription (read).

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. No mention of prerequisites or typical scenarios. The description does not indicate that get_node_subscription should be used to view current subscriptions, or set_node_subscription to modify.

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

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

Annotations already indicate destructiveHint=true, but the description adds the specific effect that members remain orphaned, which is not in annotations. It also reinforces the need for user confirmation, providing behavioral context beyond what annotations offer.

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, consisting of two sentences that front-load the key information: purpose, effect, and critical warning. No word is wasted.

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 destructive tool with partial schema coverage and no output schema, the description adequately covers the important aspects: destruction effect, membership behavior, and confirmation requirement. It is sufficient for an agent to understand what happens and how to invoke it safely.

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 50% (only 'confirm' has a description). The tool description does not add any new information about the parameters; it does not explain 'poolid' or further clarify 'confirm'. Given the moderate coverage, the description should compensate but fails to do so.

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

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

The description clearly states the verb 'delete' and the resource 'resource pool'. It also specifies that members are not deleted but orphaned, distinguishing it from other deletion tools. This provides a specific, complete purpose.

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

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

The description explicitly states 'DESTRUCTIVE — ask the user to confirm before invoking,' providing a clear usage guideline. While it does not list alternatives, the context of sibling tools includes create_pool and update_pool, making the when-to-use implicit. The guidance is clear and actionable.

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

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

Annotations already mark destructiveHint=true and readOnlyHint=false. The description adds that existing snapshots are kept unless pruned, providing useful behavioral context beyond annotations.

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

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

Two sentences, front-loaded with the action. Every word 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 the core action and behavioral note. Given the complexity of sibling tools, it could elaborate on when to use this versus other deletion tools, but it is still fairly complete for a simple deletion.

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 only 33% schema description coverage (only 'confirm' has a description), the description adds no parameter information. It could explain that 'id' is required, 'force' bypasses checks, and 'confirm' indicates user approval.

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 replication job' with the specific verb and resource. It distinguishes from sibling tools like create_replication_job and prune_backups by focusing on replication job deletion and noting that snapshots are kept unless pruned.

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 flags the tool as destructive and instructs to ask user confirmation. However, it does not compare with alternatives like delete_backup or other deletion tools, which would strengthen guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds that associated zones/vnets will stop working, which is important behavioral context. It also reinforces the need for confirmation. No contradiction with annotations.

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

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

Two sentences with no wasted words. Front-loaded with the action and resource. 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 destructive delete tool with two parameters and no output schema, the description provides necessary context: consequences and confirmation requirement. It could add detail about the 'name' parameter but is generally 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 50% (only 'confirm' has description). The tool description does not add any parameter semantics beyond the schema. It mentions confirmation but doesn't explain the 'name' parameter. Baseline is 3 due to partial coverage, and description doesn't compensate.

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 ('Delete') and the resource ('SDN controller'). It distinguishes from siblings like create_sdn_controller or update_sdn_controller. The warning about destructive effects further clarifies its purpose.

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

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

The description explicitly instructs to ask for user confirmation before invoking, which is a clear usage guideline. It doesn't explicitly say when not to use, but the destructive nature and the confirm parameter imply that. It could mention alternative non-destructive actions, but it's sufficient.

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

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

Annotations already provide destructiveHint=true and readOnlyHint=false. The description adds the instruction to ask for user confirmation, which reinforces the destructive nature. However, it does not disclose additional behavioral traits such as cascading deletes or prerequisites, relying heavily on annotations.

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

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

The description is two sentences: first states the action, second provides a critical warning. It is extremely concise with no wasted words, front-loading the 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?

The tool is destructive with 3 parameters and no output schema. The description lacks prerequisites (e.g., subnet must exist, not in use), error conditions, or return value. For a delete operation, more context is needed to ensure correct 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?

Schema description coverage is only 33% (only the 'confirm' parameter has a description). The tool description does not add any parameter semantics beyond stating the action. With low coverage, the description should compensate, but it fails to explain what 'vnet' and 'subnet' refer to.

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 an SDN subnet', providing a specific verb and resource. It distinguishes from sibling tools like create, update, list, get, and other delete 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 includes 'DESTRUCTIVE — ask the user to confirm before invoking', which provides a clear when-to-use guideline (only after user confirmation). It does not explicitly mention when not to use or alternatives, but the warning is sufficient for this 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?

Annotations already indicate destructiveHint: true. The description adds value by stating that it also deletes the subnets (cascading deletion) and reinforces the need for user confirmation. This provides useful behavioral context beyond the annotations.

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 short sentences to convey the action, resource, and critical warning. The key information is front-loaded, and every word is meaningful.

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 delete tool with two parameters and no output schema, the description covers the basics: what it does and that it requires confirmation. However, it lacks context about prerequisites (e.g., vnet must not be in use), potential failure conditions, or post-deletion behavior. It is minimally adequate but not fully complete.

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

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

The input schema has 50% description coverage (only 'confirm' is described). The tool description does not add any additional details about the 'name' parameter (e.g., its format or purpose) or further clarify 'confirm'. Since the schema coverage is low, the description should compensate, but it does not.

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 an SDN vnet and its subnets,' which specifies the exact resource and action. This distinguishes it from sibling tools like delete_sdn_subnet (which deletes only a subnet) and other delete tools for different 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 explicitly instructs the agent to ask the user for confirmation before invoking due to its destructive nature. This provides clear guidance on when to use the tool (only with user approval). However, it does not explicitly mention when not to use it or compare with alternatives like delete_sdn_subnet, leaving some room for improvement.

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?

Adds that vnets/subnets will stop working, which goes beyond the destructiveHint annotation. No contradiction.

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

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

Two concise sentences with front-loaded 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?

Sufficient for a destructive delete tool given sibling context and annotations. No output schema but behavioral warning is adequate.

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

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

Description does not detail parameters beyond schema. Schema covers one parameter; description adds implicit guidance on confirm but no explicit parameter documentation.

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

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

Clear verb 'Delete' and resource 'SDN zone'. Distinguishes from sibling tools like create_sdn_zone and update_sdn_zone.

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 states destructive nature and instructs to ask user confirmation. No alternative mentioned but context is sufficient.

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 labels the tool as DESTRUCTIVE, which aligns with the destructiveHint: true annotation. It adds the instruction to ask for user confirmation, providing behavioral context beyond the annotation. This is sufficient for a simple deletion action.

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

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

The description is extremely concise with two sentences: one stating the action and one providing a critical warning. Every sentence is necessary and earns its place.

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

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

For a simple deletion tool with no output schema and good annotations, the description is mostly complete. It covers the core operation and the destructive nature. However, it could mention that the snapshot must exist or that force and confirm parameters control 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?

The input schema has 6 parameters, but only 50% have descriptions. The tool description does not mention any parameters or provide additional meaning beyond the schema. Given the low schema coverage, the description should have compensated, but it fails to do so.

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 'Deletes a snapshot from a VM or container,' which is a specific verb+resource pair. It distinguishes itself from sibling tools like create_snapshot, rollback_snapshot, and list_snapshots by explicitly mentioning deletion.

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 a clear usage guideline: 'DESTRUCTIVE — ask the user to confirm before invoking.' This tells the agent when to use the tool (only after user confirmation) and implies a safety protocol. However, it does not provide explicit alternatives or exclusions.

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

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

Description adds key behavioral details beyond annotations: states that underlying files are not removed and that VMs/CTs lose access, which are not indicated by the annotations.

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

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

Three sentences efficiently cover purpose, nuance, and usage warning, with no redundant 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?

The description covers the core action, side effects, and confirmation requirement. However, it does not mention potential cluster-wide implications or dependencies on other resources.

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 50% (only 'confirm' has description). The tool description does not explain the 'storage' parameter beyond its name, leaving ambiguity about its value (e.g., pool ID vs. name).

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

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

The description clearly states the action ('Delete a storage pool from Proxmox config') and the scope ('Underlying disk/files are NOT removed'), distinguishing it from other delete tools.

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

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

Explicitly warns that VMs/CTs lose access and instructs to ask user confirmation before invoking. However, no alternative actions are suggested.

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 the important behavioral note about requiring user confirmation and emphasizes permanence, going beyond the destructiveHint annotation. No contradiction with annotations is present.

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 with no fluff—and front-loads the key purpose and caution.

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 is destructive and has an output schema absent, the description adequately covers the core behavior and necessary caution. It could briefly mention the result or impact on related resources, but it's sufficient for a delete 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 provides no additional meaning for the parameters beyond the input schema. With schema coverage at 60%, it fails to compensate for undocumented parameters like node and vmid.

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 'permanently delete a VM and its disks' and highlights its destructive nature, distinguishing it from other delete operations like delete_container or delete_backup.

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 advises to ask the user for confirmation before invoking, providing clear usage context. However, it does not explicitly state when not to use the tool or mention alternatives among the many delete 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?

Annotations already indicate it is a write operation (readOnlyHint=false) and not idempotent (idempotentHint=false). The description adds that it triggers a server-side fetch and mentions Proxmox fetches directly, but does not disclose potential side effects like storage space impact, network usage, or failure handling. With annotations providing basic safety profile, the description adds moderate value.

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

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

Two sentences: first front-loads the action and target, second adds mechanism and benefit. No wasted words. Efficient 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 download tool with no output schema and well-covered parameters, the description is largely complete. It conveys the core function and use case. However, it omits mention of prerequisites (e.g., storage pool must exist) or return behavior (e.g., task status), which could be added for full 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?

Input schema covers 86% of parameters with descriptions (e.g., url, node, storage, filename, checksum). The description does not add any parameter-specific meaning beyond the schema. Baseline 3 is appropriate as schema does the heavy lifting.

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 'Trigger a server-side download from a URL into a storage pool' with a specific verb ('download'), resource ('URL'), and target ('storage pool'). It differentiates from client-side uploads by noting it's server-side, and highlights being useful for large ISOs, distinguishing it from sibling tools that are primarily local 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 provides guidance by stating it is 'useful for large ISOs', implying it is optimized for large files where client-side download-upload would be inefficient. However, it does not explicitly state when not to use it or provide alternatives, leaving some ambiguity. No other sibling tool directly competes, so the guidance is adequate but not explicit.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the agent knows this is a mutating but not destructive operation. The description adds that the command is executed via 'pct exec' over SSH, which provides some implementation context. However, it does not disclose potential side effects (e.g., command output handling, exit codes, or resource limits beyond the timeout parameter).

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

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

The description is two sentences long, very concise, and front-loaded with the primary action. Every word earns its place; no fluff or repetition. It efficiently communicates the core functionality and a key prerequisite.

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

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

The tool is simple (execute a command in a container), and the description covers the essential action and prerequisites. However, it lacks details about the output format (e.g., stdout/stderr, exit code) and does not explain the timeout behavior beyond the parameter existence. Given the absence of an output schema, this information would help an agent interpret results correctly.

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

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

The input schema has 100% description coverage for all 4 parameters, so the schema already defines each parameter. The description adds context that the command is run via 'pct exec' and that SSH is required, which helps interpret the 'node' and 'vmid' parameters as Proxmox host and container ID. This adds marginal value beyond the schema.

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

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

The description clearly states the action: running a shell command inside an LXC container via pct exec. It specifies the resource (LXC container) and the method (SSH to host). However, it does not explicitly distinguish from sibling tools like vm_agent_exec for VMs, but the mention of 'container' and 'pct exec' makes the purpose 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?

The description mentions the prerequisite of SSH access (PROXMOX_SSH_* env), which is a useful precondition. However, it provides no guidance on when to use this tool versus alternatives (e.g., vm_agent_exec for VMs, or direct host commands via other tools). The usage context is implied but not fully explicated.

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 no behavioral context beyond the title; annotations already declare readOnly, idempotent, and non-destructive, but the description does not elaborate on behaviors like error handling or return structure.

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

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

The description is a single sentence that is concise and front-loaded, but could include more context without becoming verbose.

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

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

Given the simple tool with no output schema, the description omits information about the return value or fields, leaving the agent partially uninformed about what to expect.

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 100% schema coverage, the schema already describes the single 'id' parameter. The description adds no further meaning beyond the schema's 'Job ID'.

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 ('Get') and the resource ('a single scheduled backup job'), effectively distinguishing it from sibling tools like 'list_backup_jobs'.

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 when a single job is needed by ID, but provides no explicit guidance on when not to use it or alternatives among siblings like 'get_job'.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, so safety is clear. Description adds that the job is scheduled, but no other behavioral details (e.g., pagination, ordering).

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

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

Single sentence, no fluff. Purpose is front-loaded and clearly communicated.

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?

Simple tool with one parameter, no output schema. Description is adequate but could mention the return format (e.g., list of VM/container IDs or names) to be fully complete.

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

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

Single parameter 'id' is unnamed in description. Schema description coverage is 0%, and description does not clarify that 'id' refers to the backup job ID. Parameter meaning is left implicit.

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 lists VMs/containers captured by a scheduled backup job. Uses specific verb 'list' and distinguishes from sibling tools like get_backup_job and list_backup_jobs.

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?

Implied usage after obtaining a backup job ID. No explicit guidance on when to use or alternatives, but the tool's purpose is straightforward.

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

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

Annotations already declare readOnlyHint, idempotentHint, and no destructiveHint. The description adds the specific return fields (quorum status, cluster name/version, node list), which provides useful behavioral context beyond annotations.

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

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

The description is a single concise sentence with no wasted words. It front-loads the key information and is immediately understandable.

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 values adequately. It covers the main elements, though details like data formats (e.g., node IDs as strings) are omitted. Still, it is sufficient for a simple status query tool.

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

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

The tool has zero parameters, and schema coverage is 100%. The description adds value by explaining what the tool returns, which is the entire semantic content since there are no parameters to describe.

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 quorum status, cluster name/version, and node list with state and IDs. It uses a specific verb (return) and resource (cluster status), and uniquely distinguishes itself from sibling tools like get_nodes or get_node_status.

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