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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention side effects, prerequisites, or failure modes (e.g., whether the VM must not already be in a pool, or what happens if the pool does not exist), leaving significant behavioral ambiguity.

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 conveys the core purpose efficiently and is appropriately sized for the simplicity of the operation.

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

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

The tool has a simple signature and no output schema, but the description omits any context about preconditions or results. It is adequate for basic invocation but lacks depth for an agent to handle edge cases or understand the operation's effects, earning a mid-range score.

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

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

The input schema already provides 100% coverage with descriptions for both 'vmid' and 'poolid'. The description adds no additional parameter meaning beyond what the schema conveys, so it offers no extra 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 'Add a VM to a resource pool' uses a specific verb ('Add') and clearly identifies both the object (VM) and the target (resource pool). It is unambiguous and easily understood, though it does not explicitly differentiate from sibling tools like remove_vm_from_pool.

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

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

The description provides no guidance on when to use this tool versus alternatives. It simply states the action without any context, preconditions, or mention of related tools, leaving the agent to infer usage entirely.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states a basic 'create' action without mentioning required permissions, asynchronous task behavior, potential side effects, or dependency on existing templates or node state.

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

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

The description is a single, focused sentence with no filler or redundancy. It conveys the essential purpose efficiently and 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?

Despite a rich schema, the description is extremely thin and does not address operational context such as dependencies on templates/nodes, return values, or whether creation is asynchronous. With no annotations or output schema, this leaves the tool under-specified for an agent to invoke confidently.

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 15 parameters, including types, ranges, and examples, so the description need not elaborate. The description itself adds no parameter details, but the schema already provides sufficient semantics.

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

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

The description clearly states the tool creates a new container on Proxmox, using the specific verb 'create' and naming the resource 'container'. This distinguishes it from create_vm and other container lifecycle tools in the sibling list.

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

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

No guidance is provided about when to use this tool versus alternatives like create_vm, or about prerequisites such as template availability or node readiness. The description lacks any contextual pointers for selection.

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

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

No annotations are provided, so the description must disclose behavioral traits, but it only states the basic action. It does not mention potential side effects such as container interruption during backup, storage requirements, or that the backup may be stored remotely. The agent is left without critical operational knowledge.

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 short sentence, perfectly concise and front-loaded with the action and object. Every word is useful, and there is no filler or redundancy. It achieves clarity with minimal 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's complexity (12 parameters, 3 required, no output schema, no annotations), the one-line description is severely inadequate. It does not explain the backup process, what happens on success or failure, prerequisites like storage availability, or how the backup can be identified later. The description provides almost no contextual richness, leaving the agent to rely solely on the schema.

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

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

The input schema includes descriptions for all 12 parameters (100% coverage), so the baseline is 3. The tool description adds no extra meaning beyond the schema, but the schema already defines each parameter's purpose. No additional semantic guidance is provided in the description, so it neither helps nor hinders.

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 'Create a backup of a container' clearly states the action (create backup) and the target resource (container), using a specific verb+resource structure. It distinguishes from VM-focused tools like create_vm_backup and snapshot tools by using the term 'container,' but does not explicitly state alternatives or edge cases.

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. There is no mention of preferring it over create_container_snapshot for quick snapshots, or using create_vm_backup for VMs. The absence of any context leaves the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description must disclose behavior. It only says 'Create a firewall rule' and does not mention side effects, whether the rule is appended or replaces existing rules, validation behavior, permissions required, or what the response contains. This is a significant gap for a mutating operation.

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

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

The description is a single clear sentence with zero wasted words. It includes the verb, resource, and target without redundancy. It earns its place entirely and is appropriately concise for the tool's simplicity.

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

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

The tool is a create/mutation operation with no annotations and no output schema. The description lacks essential context such as the need to enable the container firewall first, potential failure modes, or the effect of the 'pos' parameter on rule ordering. The schema covers parameters but the overall use context is incomplete.

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%, so the schema already documents all four parameters with meaningful descriptions (e.g., rule examples). The description adds no additional parameter meaning beyond what is in the schema, so the 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?

The description 'Create a firewall rule for a container' uses a specific verb (Create) and resource (firewall rule) with a clear target (container). It distinguishes from sibling tools like list_container_firewall_rules and delete_container_firewall_rule, and from create_vm_firewall_rule via the container qualifier.

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, no prerequisites (e.g., firewall must be enabled first via enable_container_firewall), and no exclusion criteria. It merely states the action without 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?

No annotations are provided, so the description carries the full burden. It only says 'Create a snapshot for a container' without disclosing side effects, requirements (e.g., container running/stopped), or consequences. This is essentially a restatement of the tool name with no additional 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 a single, clear sentence with no wasted words. It is highly concise, though it lacks additional structured sections (e.g., usage notes) that could make it more helpful 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?

For a mutation tool with no annotations and no output schema, the description is too thin. It provides only the core action and leaves out important context such as whether snapshots require the container to be running, if they are crash-consistent, or how they relate to backups. The 4 parameters are documented in the schema, but the overall context is insufficient for an agent to invoke the tool confidently.

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 for parameters is 100%, with each parameter having a description. The tool description adds no extra meaning beyond the schema, so a baseline score of 3 is appropriate as the 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 the action (create) and the target (snapshot for a container). It distinguishes from related tools like create_vm_snapshot and create_container_backup by specifying container snapshot, making the purpose unmistakable.

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

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

There is no guidance on when to use this tool versus alternatives (e.g., create_container_backup or restore_container_snapshot). The description only states what it does, not the context or prerequisites for using it.

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

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

No annotations are provided, so the description carries the full burden. 'Create a new resource pool' is essentially a restatement of the tool name and offers no insight into behavior such as uniqueness checks, permissions required, or potential side effects. This is comparable to the 'process' example in its lack of disclosure.

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

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

The description is a single, front-loaded sentence with no filler. It is efficient, though minimal, earning high marks for conciseness even if other dimensions suffer from under-specification.

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 create operation with fully described parameters, the description is minimally adequate but lacks behavioral context. Without annotations or output schema, details about uniqueness constraints, failure modes, or access requirements are missing, making this incomplete.

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% with both 'poolid' and 'comment' described in the input schema. The description adds no additional parameter meaning, so the 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 'Create a new resource pool' uses a specific verb and resource, clearly distinguishing it from sibling tools like delete_resource_pool and list_resource_pools. It unambiguously states what the tool does.

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

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

No guidance is provided on when to use this tool versus alternatives. While creation context is implied by the name, there is no mention of prerequisites, exclusions, or relationship to sibling pool operations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely restates the tool name without mentioning side effects such as converting the container (which may make it unusable as a container), required permissions, or reversibility. This is a significant transparency gap for a mutation tool.

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

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

The description is a single, concise sentence with no wasted words. It is front-loaded and easy to read, but it is too terse for the information needed, which is more a completeness issue than a conciseness one.

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

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

With no output schema and no annotations, the description should explain what happens to the original container, what the return value looks like, and potential failure modes. None of this information is present, making the tool severely under-specified for a 3-parameter mutation 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 input schema already has 100% description coverage for all three parameters (node, vmid, storage), so the schema documents their meaning. The tool description adds no additional parameter semantics beyond the schema, aligning with the baseline of 3.

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

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

The description uses a specific verb ('Create') and resource ('template from a container'), clearly indicating what the tool does. It distinguishes from the sibling tool 'create_template_from_vm' by explicitly mentioning 'container', though it does not elaborate on the conversion aspect.

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 'create_template_from_vm' or 'list_templates'. It lacks any mention of context, 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?

With no annotations provided, the description must fully disclose behavioral traits. It only states the basic action and reveals nothing about side effects (e.g., the source VM being converted/destroyed), permissions required, or the resulting state. This is a significant gap for a mutation tool.

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

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

The description is a single clear sentence with no wasted words, making it very concise. However, it could be more informative without losing conciseness, so it does not earn a perfect score.

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

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

Despite low parameter complexity, this is a mutation tool without annotations or an output schema. The description does not explain the conversion's impact on the source VM, prerequisites, or reversibility. More behavioral detail is needed for an agent 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?

The input schema has 100% coverage with clear descriptions for node, vmid, and storage. The description adds no additional parameter-level meaning beyond the schema, so a 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?

The description uses a specific verb ('Create') and resource ('a template from a VM'), clearly stating what the tool does. It also distinguishes itself from sibling tools like create_template_from_container and delete_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 no guidance on when to use this tool versus alternatives such as create_template_from_container, nor does it mention prerequisites or limitations like requiring the VM to be stopped. There is no contextual or exclusionary information.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Create a new VM' and mentions optional cloud-init configuration, but does not explain side effects, permission requirements, vmid uniqueness, whether the VM auto-starts, or what the operation returns. For a mutating tool, this is a significant gap.

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

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

The description is a single 11-word sentence that front-loads the core action and resource. Every word earns its place: 'Create', 'new VM', 'Proxmox', and the differentiator 'optional cloud-init configuration'. There is zero wasted text and the structure is ideal for quick scanning.

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 35-parameter creation tool with no output schema and no annotations, an 11-word description is severely incomplete. It does not cover operation semantics, asynchronous behavior, return values, prerequisites, or how it differs from related creation tools. The agent must rely entirely on the schema for context, which is insufficient for safe invocation.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The description itself adds no parameter-level detail beyond hinting that cloud-init configuration is optional, which is already evident from the schema. It neither improves nor harms 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 uses a specific verb 'Create' and a clear resource 'new VM on Proxmox', making the tool's purpose unambiguous. It naturally distinguishes itself from sibling tools like create_container and other VM management operations. The optional cloud-init mention adds relevant feature context without confusing the primary 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 clearly states when to use the tool: when a new VM is needed on Proxmox, with optional cloud-init support. However, it does not explicitly mention when not to use it or name alternatives such as create_container, so it stops short of full exclusionary guidance.

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

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

With no annotations, the description must carry the full burden, but it merely states the obvious action. It does not disclose whether the VM is affected (e.g., snapshot vs shutdown), how the backup is stored, or any side effects, despite the schema hinting at modes and compression.

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 short and free of fluff, but for a tool with 12 parameters it is under-specified. It lacks any structured breakdown; while concise, it is not appropriately sized for the tool's complexity.

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

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

The tool has 12 parameters, no output schema, and no annotations. The description provides only the bare minimum, omitting return values, behavioral nuances, and any cautionary notes, making it grossly incomplete for an agent to invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds no parameter context beyond what the schema already provides, so there is no additional value.

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

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

The description 'Create a backup of a VM' clearly specifies the action (create) and resource (backup of a VM). It distinguishes from sibling tools like create_container_backup and restore_vm_backup by explicitly targeting VM backups.

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 usage context or alternatives are provided. The one-sentence description gives no indication of when to use this tool versus create_container_backup or delete_backup, nor any preconditions or exclusions.

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

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

No annotations are provided, so the description must carry the full burden. It simply says 'Create a firewall rule' without detailing side effects, requirements (e.g., firewall enabled), or behavior of the 'pos' 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 a single short sentence with no wasted words, front-loading the core action. It is concise but under-specified.

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

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

With no output schema and no annotations, the one-sentence description is insufficient for a mutation tool with four parameters. It lacks context about prerequisites, rule syntax, and what happens on creation.

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 already provides full descriptions for all four parameters (100% coverage). The description adds no additional parameter semantics 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 'Create a firewall rule for a VM', using a specific verb and resource. This distinguishes it from sibling tools like create_container_firewall_rule.

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. It does not mention that this applies to VMs only, nor does it reference the container counterpart or any prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Create a snapshot' without mentioning that snapshots can include memory (via memory/vmstate), may briefly pause the VM, or are stored on the node's storage. No permissions or side effects are disclosed.

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

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

The description is a single sentence with no wasted words, but it is under-specified. It provides only the core action without any structural context, such as prerequisites or optional behavior, making it minimally concise but not information-rich.

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 absence of annotations and output schema, the description should explain what happens after creation (e.g., returns a task ID), any disk/storage implications, and that snapshots can include memory. With 6 parameters, this description is insufficient for an agent to understand the full context.

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

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

Schema description coverage is 100%, with each parameter clearly documented. The description itself adds no additional parameter semantics, so the 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?

The description clearly states the action (create) and resource (VM snapshot), and the scope is explicitly a VM which distinguishes it from sibling tools like create_container_snapshot. It 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?

No guidance is provided on when to use this tool versus alternatives such as create_container_snapshot or restore_vm_snapshot. There is no mention of prerequisites like the VM needing to exist or that snapshots are point-in-time states.

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

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

With no annotations, the description carries the disclosure burden. It does add value by noting the guest agent dependency, which is a non-obvious behavioral requirement. However, it does not disclose side effects, error conditions, reversibility, or required permissions for this mutation operation.

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

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

The description is a single sentence of seven words that conveys the core purpose and a key prerequisite. It is extremely concise with no filler or redundant content.

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

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

For a mutation tool with no annotations and no output schema, the description is minimal. It explains what and the guest agent requirement, but it does not clarify whether password or ssh_keys is required for access, what a successful result looks like, or common failure modes. The schema covers parameter names but not operational 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 100%, so the schema already fully documents all parameters. The description adds no parameter-specific meaning beyond what the schema provides, which is acceptable given the full coverage.

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

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

The description clearly states 'Create a new user in a VM' with a specific verb and resource, and includes the prerequisite that it requires a guest agent. This unambiguously distinguishes it from sibling tools like set_vm_user_password or run_vm_command.

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 'requires guest agent', implying it should only be used when the guest agent is available. However, it does not explicitly state when to prefer this tool over alternatives (e.g., set_vm_user_password) or provide exclusion conditions beyond the guest agent requirement.

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

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

No annotations are provided, so the description bears the full burden of disclosing behavioral traits. It says only 'Delete a backup,' which conveys the action but omits critical details such as irreversibility, whether the operation is immediate, any dependencies on other resources, or potential side effects. This is a significant transparency gap for a destructive operation.

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

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

The description is extremely short, but this is under-specification rather than conciseness. It consists of a single sentence that repeats the tool's name and provides no additional information. A concise description should be compact yet informative; this one is merely minimal and fails to justify its existence.

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 inadequate for a deletion tool with no output schema and no annotations. It does not explain the effect of deletion (e.g., freeing storage), any required preconditions, or how it relates to the many sibling backup/snapshot tools. Given the complexity of the environment and the absence of structured behavioral hints, the description leaves the agent without essential context.

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

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

The input schema provides full descriptions for both parameters (node and backupfile), and the coverage is 100%. The description adds no further semantic value beyond what the schema already states. Since schema coverage is high, a baseline of 3 is appropriate; no additional parameter clarification is needed.

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

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

The description 'Delete a backup' is a tautology—it restates the tool name 'delete_backup' without adding any new information. It does not specify what kind of backup (VM, container, etc.) or provide any context that distinguishes it from sibling deletion tools. The verb and resource are present, but no useful specificity is added.

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

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

There is no guidance on when to use this tool versus alternatives. It neither states conditions for use nor mentions when not to use it. The description mentions nothing about prerequisites, such as whether backups must be inactive, or how it differs from deleting snapshots or VMs. The agent is left without any context for decision-making.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Delete' implies destructive action, but the description does not state permanence, impact on running containers, or whether a force flag is required. It adds minimal value beyond the name.

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, grammatically correct sentence with the core action and object. No unnecessary words, 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?

The description is incomplete for a destructive operation. It omits any mention of data loss, how to verify deletion, or whether the operation is reversible. Since there is no output schema and no annotations, the minimal text leaves critical context uncovered.

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%, with each parameter already documented. The tool description adds no parameter-level semantics, so the baseline 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?

Clear verb 'delete' + resource 'container' + system 'Proxmox' distinguishes the action from sibling tools like delete_vm, delete_container_snapshot, and delete_template. It unambiguously states what the tool does.

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

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

No guidance on when to use this tool vs alternatives, prerequisites, or conditions. It does not mention, for example, that containers should be stopped before deletion or that delete_vm is for VMs, leaving usage context entirely 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 are absent, so the description carries full responsibility for behavioral disclosure. It only says 'Delete', implying a mutation, but does not disclose that the operation is permanent, whether it requires the rule to exist, or any permissions needed. This is a significant gap for a destructive operation.

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

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

The description is a single, efficient sentence with no wasted words. However, it is very close to the tool name and provides little additional structure or context, so it earns a 4 rather than a 5.

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 a destructive deletion with no annotations, no output schema, and a minimal description. It lacks information about effects, error conditions, or how to use it in workflow. The schema provides parameter details, but overall the description is under-specified for a mutation 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 schema fully describes all three parameters (node, vmid, ruleid) with clear descriptions, covering 100% of parameter semantics. The description itself adds no parameter-specific meaning, but the schema does, so the 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 action (Delete) and resource (firewall rule for a container), distinguishing it from sibling tools like delete_vm_firewall_rule and create_container_firewall_rule. It's specific enough, though it doesn't mention the rule identifier or that it's a destructive removal.

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

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

No guidance is provided about when to use this tool or how it differs from alternatives. There is no mention of prerequisites, or that this tool should be used instead of list_container_firewall_rules to identify the ruleid. The description only states the core function without context.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It simply says 'delete' without mentioning that the operation is permanent, may affect dependent snapshots, or requires specific permissions. The description adds no context beyond the tool name.

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 fluff, but it is under-specified. While it reads well, it lacks any structural elaboration (e.g., expected outcome, prerequisites), making it minimally informative rather than efficiently complete.

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 insufficient for a destructive operation. It does not mention irreversibility, whether the snapshot must exist, or what the effect is on the container. With no output schema and no annotations, the description should carry more contextual weight.

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%, so the baseline is 3. The description provides no additional parameter detail, but the schema already fully documents node, vmid, and snapshotname with clear descriptions.

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

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

The description clearly states the action (delete) and the target resource (container snapshot), matching the tool name exactly. This is specific and distinguishes from sibling tools like delete_vm_snapshot or restore_container_snapshot.

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 list_container_snapshots, restore_container_snapshot, or delete_vm_snapshot. There are no prerequisites, exclusions, or context about typical use cases.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states the action without revealing side effects like permanence, required permissions, or behavior if the ISO is in use. As a destructive operation, this lacks necessary 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 a single concise sentence with no filler, directly and efficiently conveying the tool's 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?

For a simple delete operation, the essential information is present, but the lack of an output schema and the absence of notes about reversibility or failure conditions leave some gaps. It is adequate but not fully comprehensive.

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?

All three parameters (node, storage, filename) are fully described in the schema, achieving 100% schema description coverage. The description itself adds no additional parameter meaning, so the 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?

The description states exactly what it does: 'Delete an ISO file from a Proxmox node' with a specific verb (delete), resource (ISO file), and location (Proxmox node). It clearly distinguishes this from sibling tools like delete_vm 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 implies usage: use this when you need to remove an ISO file. It does not explicitly discuss when not to use it or mention alternatives, but given the simplicity of the operation, the context is reasonably clear.

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

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

No annotations exist, so the description carries the full burden. It only states 'Delete a resource pool' without warning about permanence or side effects, which is insufficient for a destructive operation.

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

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

The description is a single, direct sentence that efficiently conveys the core function without any filler or redundancy.

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

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

For a destructive operation with no annotations or output schema, the description is too minimal. It omits return value, error semantics, and the implications of the force parameter, leaving the agent without sufficient operational 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 100%, with the 'force' parameter clearly documented as 'Force delete (even if pool has members)'. The description adds nothing beyond the schema, so the 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?

The description uses the specific verb 'Delete' with the resource 'resource pool', clearly distinguishing it from sibling tools like create_resource_pool and get_resource_pool_status.

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

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

No usage context is provided. The description does not explain when deletion is appropriate, prerequisites (e.g., pool must be empty unless force is used), or contrast with other pool-related tools.

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

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

No annotations are provided, so the description carries the full burden. It merely says 'delete' without disclosing that this is destructive, permanent, or whether the 'force' option overrides in-use templates. Minimal 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 one concise, front-loaded sentence with zero wasted words. It communicates the essential action clearly.

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 delete tool with 100% schema coverage, the description is minimally adequate. However, it lacks annotations and an output schema, and does not explain force behavior or error conditions, leaving the agent without a complete picture.

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% (node, vmid, force are all described). The tool description adds no additional parameter meaning, but per the baseline for high schema coverage, this is acceptable.

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

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

Description states the exact action: 'Delete a template from Proxmox'. It uses a specific verb ('delete') and resource ('template'), clearly distinguishing it from sibling delete tools like delete_vm, delete_container, delete_backup, 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?

No guidance is given about when to use this tool versus alternatives. There is no mention of prerequisites, conditions, or scenarios where this tool is preferred over other delete operations.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the action ('Delete a VM') but provides no warning about irreversibility, potential data loss, related resources (backups, snapshots, firewall rules) that may be affected, or permission requirements. For a destructive operation, this is a significant gap.

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

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

The description is a single, front-loaded sentence that directly states the purpose. It contains zero wasted words and is appropriately sized for its simple action. Every word earns its place.

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

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

Given this is a destructive operation with no annotations and a non-trivial parameter set, the description is incomplete. It does not mention return values, side effects, prerequisites, or the implications of the force flag. The tool would benefit from at least a note that deletion is permanent and may affect associated data.

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% (all three parameters have descriptions), so the schema already documents node, vmid, and force. The description adds no parameter-specific meaning beyond what the schema provides; it does not even restate the parameters. Baseline is 3 since the 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 the operation ('Delete') and the target resource ('a VM'), with the platform ('Proxmox') providing context. It distinguishes itself from sibling tools like delete_container and delete_backup by naming the exact resource type. This is a specific verb+resource statement that leaves no ambiguity about the tool's function.

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, prerequisites, or conditions such as the need for the VM to exist or the availability of the node. It does not mention that force deletion may be necessary when the VM is in use, nor does it differentiate usage from other delete tools. The user is left to infer appropriate usage from the schema and context.

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

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

With no annotations, the description carries full burden. It only states the action without disclosing consequences (permanence, impact on traffic, required rule existence) or any risk factors. Mere 'delete' is insufficient for safe usage.

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

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

A single, concise sentence with no wasted words. It is appropriately front-loaded and easy to parse.

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

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

Although the tool is simple and schema/parameters are well-defined, the absence of annotations and lack of any behavioral or usage context makes the description incomplete. It does not explain side effects or preconditions for a deletion 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 coverage is 100% with clear descriptions for node, vmid, and ruleid. The tool description adds no semantic value beyond the schema, so 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 'Delete a firewall rule for a VM' uses a specific verb (delete) and resource (firewall rule for a VM), clearly distinguishing it from siblings like list_vm_firewall_rules or delete_container_firewall_rule.

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 usage context is provided. The description does not mention when to use this tool, prerequisites (e.g., firewall must be enabled), or alternatives. There is no guidance on workflow such as listing rules first.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. 'Delete a VM snapshot' merely restates the tool name and provides no information about irreversibility, required permissions, or impact on the VM. This is a significant gap.

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

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

The description is a single, clear sentence that is appropriately concise for a simple delete operation. It does not waste words, but it is brief enough that it could be considered slightly under-specified.

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

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

For a destructive tool with no annotations and no output schema, the description is too terse. It does not indicate what happens after a successful deletion, whether any prerequisites must be met, or any consequences. This makes it incomplete for an agent to fully understand the 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 input schema fully describes all three parameters (node, vmid, snapshotname) with 100% coverage. The tool description adds no parameter-specific information, so the 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 ('Delete') and the target resource ('VM snapshot'). It is specific enough to distinguish from sibling tools like delete_container_snapshot and restore_vm_snapshot.

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

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

The description gives no guidance on when to use this tool versus alternatives such as creating, listing, or restoring snapshots. It also lacks any mention of prerequisites or exclusions (e.g., cannot delete a snapshot with child snapshots).

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

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

With no annotations, the description must disclose behavioral traits. It only states the action, without mentioning consequences like removal of firewall rules, reversibility, or impact on container network security. This is a mutation tool with zero safety 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 one short, front-loaded sentence with no filler. It is concise but could include a bit 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?

The tool is simple with two well-documented parameters and no output schema. However, as a disabling action, it would benefit from clarifying the effect (e.g., 'removes firewall protection from the container') 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?

Schema coverage is 100% with clear parameter descriptions ('Node where container is located', 'Container ID'). The description adds no parameter-level detail, so it takes the baseline of 3 for full schema coverage.

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

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

The description clearly states the action: 'Disable firewall for a container' with a specific verb and resource. It distinguishes from siblings like enable_container_firewall and list_container_firewall_rules.

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 enable_container_firewall or disable_vm_firewall. The description gives no context or exclusions.

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

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

There are no annotations, so the description carries the full burden. It only states the basic action without disclosing side effects, permission requirements, reversibility, or what happens if HA is not currently enabled.

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

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

The description is a single, front-loaded sentence that directly conveys the operation. It is concise with no wasted words, earning 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 tool with two well-documented parameters, the description is minimally adequate. However, it lacks behavioral context such as prerequisites, side effects, or the fact that this is a mutating operation, and there is no output schema to clarify return 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?

Both parameters (node, vmid) are fully described in the schema with clear definitions, achieving 100% schema description coverage. The tool description adds no additional semantic value beyond the schema.

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

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

The description clearly states the action ('Disable') and the specific resource ('High Availability for a container'). It distinguishes from siblings like disable_vm_ha (for VMs) and enable_container_ha (the inverse operation).

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

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

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or context (e.g., HA must be enabled first). The intended usage is only implied by the tool's name and description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without noting reversibility, whether existing rules remain, or any security implications. This is insufficient for a mutation tool.

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

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

The description is a single, front-loaded sentence with zero wasted words. It effectively communicates the core action in a compact form.

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

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

Despite low complexity and full schema coverage, the description lacks essential context for a security-affecting operation. It doesn't explain when to use it, what happens to existing rules, or any side effects. Given no annotations or output schema, the description should provide more context.

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

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

The input schema fully describes both parameters (node, vmid) with clear descriptions. The tool description adds no additional meaning beyond what the schema already provides, so the 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?

The description clearly states the action ('Disable'), the target ('firewall'), and the scope ('for a VM'). It distinguishes itself from sibling tools like enable_vm_firewall and disable_container_firewall.

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 enabling the firewall or deleting firewall rules. No mention of prerequisites (e.g., VM must exist) or implications.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It only states the operation itself and does not explain what happens to the VM, whether the change is reversible, or any side effects (e.g., cluster reconfiguration). This is a mutation tool with no 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 a single, clear sentence with no extraneous words. It is appropriately concise, though it sacrifices potentially valuable context. It earns a high score for efficiency, but not perfect due to the lack of additional structure.

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

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

Given no annotations, no output schema, and only a minimal one-sentence description, this is incomplete for a state-changing operation. Users are left without knowledge of expected outcomes, safety implications, or relationship to HA status tools. More context is needed for confident invocation.

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

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

The input schema fully describes both parameters (node and vmid) with clear descriptions, giving 100% schema coverage. The description adds no supplementary parameter semantics beyond implying that these identify the VM, so the 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?

The description clearly states the action (disable) and resource (High Availability for a VM), which distinguishes it from siblings like enable_vm_ha and disable_container_ha. However, it essentially restates the tool name in plain words without adding substantive new information.

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

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

There is no guidance on when to use this tool vs alternatives. It does not mention prerequisites (e.g., HA must be enabled), consequences, or contrast with enable_vm_ha or get_ha_status. A single sentence offers no context for tool selection.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It fails to mention whether the download is synchronous or asynchronous, what happens to existing files with the same filename, any required permissions, or how to check the result. This is a significant gap for a download operation.

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

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

The description is a single, well-structured sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized for the information it conveys, though it could include more behavioral 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?

The tool is relatively simple (4 parameters) but lacks output schema and annotations. The description does not explain the return value, potential asynchronous behavior, failure modes, or how to verify the download status. The existence of sibling tools like get_iso_download_status suggests important context that is missing.

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

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

The input schema covers all four parameters (url, node, storage, filename) with clear descriptions, achieving 100% coverage. The description does not add any parameter-specific meaning beyond what the schema already provides, so it neither improves nor degrades 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 'Download an ISO file to a Proxmox node' clearly states the action (download), the resource (ISO file), and the destination (Proxmox node). This distinguishes it from related sibling tools like list_isos, delete_iso, and get_iso_download_status, which serve different purposes.

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

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

The description implies the tool is for downloading ISOs but provides no explicit guidance on when to use it versus alternatives or any prerequisites (e.g., node/storage availability, URL accessibility). It does not mention that get_iso_download_status could be used to poll the download progress, which is likely relevant.

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

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

No annotations are provided, so the description carries the full burden of disclosure. It only states the action 'Enable firewall' without explaining effects, reversibility, idempotency, or any prerequisites. For a mutating operation, this is a significant transparency gap.

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

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

The description is a single, front-loaded sentence with no wasted words. It communicates the core action clearly, though it lacks elaboration that might aid understanding. It is concise but not under-specified to the point of being meaningless.

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 relatively simple with only two parameters and no output schema, so the description 'Enable firewall for a container' provides a minimal but functional understanding. However, it omits any context about side effects, whether the container must exist, or how this relates to firewall rule management, leaving room for improvement.

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 already provides 100% coverage, describing 'node' as 'Node where container is located' and 'vmid' as 'Container ID'. The description adds no additional parameter meaning beyond what the schema already documents, so the 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?

The description clearly states a specific action: 'Enable firewall for a container.' This distinguishes it from sibling tools like 'disable_container_firewall' (opposite action) and 'enable_vm_firewall' (different resource type). The verb+resource combination is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'enable_vm_firewall' or 'create_container_firewall_rule'. There are no explicit use cases, prerequisites, or exclusion criteria. Usage must be inferred entirely from the tool name.

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

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

With no annotations, the description carries the full burden of disclosing behavioral traits. It fails to mention side effects, whether existing HA settings are overridden, or implications for the container. The tool also has additional parameters (group, state, etc.) that indicate nuanced behavior, but the description does not address 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?

The description is a single, front-loaded sentence that efficiently conveys the core purpose. There is no waste or redundancy, making it appropriately concise for a straightforward operation.

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 6 parameters and no output schema, the description is too minimal to provide complete context. It does not explain the effects of enabling HA, the meaning of parameters like 'group' or 'state', or expected behavior after invocation. This is insufficient for an agent to fully understand the tool's operational impact.

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%, so the baseline is 3. The description adds no semantic value beyond what the schema already provides; it does not explain how parameters relate to the enablement process, but the schema itself is self-documenting for all 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 'Enable High Availability for a container' uses a specific verb and resource, clearly distinguishing it from sibling tools like enable_vm_ha which target VMs. It is unambiguous and directly states the tool's function.

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, nor are prerequisites or context mentioned. The description only states the action, leaving the agent without criteria for tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Enable firewall for a VM' and does not mention side effects, idempotency, permissions, or whether the VM must be in a specific state.

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

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

The description is a single short sentence, which is concise and front-loaded. However, it essentially restates the tool name and adds minimal value beyond the name itself, making it under-specified.

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

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

This is a mutation tool with no annotations and no output schema. The description is too sparse to fully inform an agent: it lacks usage context, behavioral details, and prerequisites, making it incomplete for a tool that changes state.

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

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

The input schema fully documents both parameters (node and vmid) with descriptions, achieving 100% schema description coverage. The tool description adds no additional parameter semantics, so the baseline 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 (enable) and resource (firewall for a VM). It distinguishes from sibling tools such as disable_vm_firewall and enable_container_firewall by explicitly specifying 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 is provided on when to use this tool versus alternatives. There are no prerequisites, exclusions, or pointers to related tools like disable_vm_firewall or list_vm_firewall_rules.

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

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

No annotations exist, and the description discloses no behavioral traits. It does not state that this modifies VM configuration, requires cluster resources, or has reversible effects. The description is silent on permissions and side effects, leaving the agent with no safety information.

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

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

The description is only eight words, which is efficient in length, but it essentially restates the tool name and provides no explanatory value. It is under-specification rather than genuine conciseness, as it fails to include any information beyond what the name already implies.

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

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

With 6 parameters, no annotations, and no output schema, the description should explain the effect, potentially note the 'group' and 'state' parameters, and give usage guidance. Instead, it offers only the bare phrase, making it inadequate for an agent to invoke 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 already documents all 6 parameters with descriptions, yielding 100% coverage. The description adds no parameter-level detail, so it relies entirely on the schema. Baseline of 3 is appropriate given full schema coverage.

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

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

The description 'Enable High Availability for a VM' is nearly a verbatim expansion of the tool name 'enable_vm_ha', providing no additional specificity beyond what the name already conveys. It identifies the resource (VM) and action (enable HA), but this is a restatement rather than a clarifying definition.

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 usage context is provided. The description does not indicate prerequisites, situations to use this tool over enable_container_ha, or any warnings. There is no guidance on when to use or when not to use.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Get Proxmox cluster status' only states the basic action and does not disclose what the status includes, whether it is a simple read operation, or any response format. No additional behavioral traits are provided, leaving the agent without important 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 a single short sentence that is front-loaded and contains no extraneous words. It is appropriately sized for a zero-parameter tool. However, it is minimal and essentially restates the tool name without adding extra context, so it is not a perfect 5.

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 zero parameters and no output schema, the description is mostly sufficient for a simple read tool. However, it lacks context about what 'cluster status' encompasses, especially with siblings like get_summary and get_ha_status that could overlap. The description is minimally complete but leaves room for ambiguity.

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

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

The tool has zero parameters, so the baseline score is 4. The description does not need to elaborate on parameters, and the input schema is empty, meaning there is no missing information to compensate for. The description adequately matches the parameterless nature of the tool.

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

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

The description 'Get Proxmox cluster status' uses a specific verb and resource, clearly indicating this tool retrieves cluster-level status. It is distinct from sibling tools like get_node_status and get_storage_status, which target different scopes. However, it does not explicitly differentiate from get_summary or get_ha_status, which may overlap in function.

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 offers no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or conditions under which this tool is preferred. An agent would have to infer usage purely from the name and description.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It only says 'Get status', implying read-only, but does not clarify whether it returns a list or single status, or any side-effect-free guarantee. This is minimal transparency for an unannotated tool.

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

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

The description is a single, front-loaded sentence: 'Get status of Proxmox containers'. Every word is necessary, and there is no extraneous content or repetition of schema details.

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

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

For a tool with no output schema and no annotations, the description is incomplete. It does not explain what 'status' includes (e.g., running/stopped, resource usage), nor how optional parameters affect the result. The sibling context suggests a broader ecosystem, but this description alone leaves the agent uncertain about invocation and response.

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% (both node and vmid have descriptions), so the baseline is 3. The description itself adds no additional meaning about parameters, not even hinting that providing both is valid or what happens when neither is provided.

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

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

The description clearly states a verb ('Get') and resource ('status of Proxmox containers'), distinguishing it from sibling tools like get_vm_status (VMs vs containers). However, it lacks specificity on whether it returns status for all containers or a single container, and how node/vmid filters apply.

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

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

No guidance is provided regarding when to use this tool versus alternatives such as get_container_status versus get_vm_status or get_summary. There are no exclusions, prerequisites, or situational hints, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries the full disclosure burden. 'Get' implies a read operation, but the description does not disclose what status information is returned, whether HA must be enabled on the node, or any error conditions. This is minimal 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 short sentence with no filler, front-loading the action. However, it is under-specified rather than appropriately concise, so it does not earn a 5.

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

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

Given no output schema and no annotations, the description should explain what 'HA status' contains and how it relates to the node parameter. It does neither, leaving the agent with insufficient context to anticipate the tool's 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 schema has 100% coverage: the 'node' parameter is described as 'Node name'. The description adds no additional meaning beyond the schema, so the baseline 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 states a specific verb ('Get') and resource ('High Availability status'), making it a clear read operation. However, it does not clarify whether the status is for a node, cluster, or HA resource, and it doesn't distinguish it from sibling tools like get_cluster_status 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.

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

There is no guidance on when to use this tool versus alternatives such as get_cluster_status or get_node_status. The description merely implies it is for checking HA status, but no when-to-use or exclusion criteria are provided.

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

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

No annotations are provided, so the description must convey behavioral traits. While 'Get status' implies a read-only operation, the description does not disclose whether the task must still be running, what happens for invalid task IDs, or the format of status information. It essentially restates the tool's name without adding new information.

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 one short sentence that is fully front-loaded and contains no unnecessary words. It earns full marks for efficiency.

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

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

Despite the tool's simplicity, the description omits critical context: what the status response contains, whether the task ID is always required after download_iso, and how errors manifest. With no output schema and no annotations, the description leaves the agent guessing about the return value and expected usage flow.

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 provides full descriptions for both parameters, including the relationship to download_iso responses. The tool description adds no additional parameter semantics, so the baseline score of 3 applies given the 100% schema coverage.

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

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

The description clearly states the tool retrieves status for an ISO download task, using a specific verb and resource. It distinguishes itself from generic status tools by focusing on ISO downloads, though it does not explicitly contrast with get_task_status.

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

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

The description provides no guidance on when to use this tool versus alternatives like get_task_status, nor does it mention prerequisites such as having started a download via download_iso. The schema's taskid description hints at this, but the tool description itself lacks any usage guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states 'Get status' without explaining what data is returned, whether it is read-only, whether authentication or permissions are required, or how nodes are selected. This is minimal despite the tool's read-oriented nature.

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

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

The description is a single, concise sentence with no redundant words. It is front-loaded with the verb and resource, making it easy to scan. Every word earns its place.

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

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

Given the absence of an output schema and the minimal description, the tool lacks essential context about what 'status' includes (e.g., CPU, memory, uptime, health). The optional node parameter is explained, but the return format and data fields are completely unspecified, reducing completeness for an AI agent.

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

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

The schema provides 100% coverage for the single optional 'node' parameter with a clear description ('Node name (optional, defaults to all nodes)'). The tool description adds no additional parameter semantics beyond the schema, so the 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?

The description 'Get status of Proxmox nodes' uses a clear verb+resource structure, distinctly identifying the target as node-level status rather than VM, container, storage, or cluster status. It differentiates from most sibling status tools like get_vm_status and get_storage_status, though it could be slightly more specific about what 'status' encompasses.

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 get_cluster_status or get_summary. There are no mentions of exclusions, prerequisites, or fallback tools, leaving the agent to infer appropriate usage from the name alone.

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

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

There are no annotations, so the description must carry the full burden of behavioral disclosure. It only states 'Get Proxmox VE version', implying a read-only operation but not explicitly confirming safety, return format, or underlying behavior. This is a notable gap for a getter with no structured output schema.

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

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

The description is a single, focused sentence that gets straight to the point. It is concise and front-loaded with the key action and resource, containing no filler or 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?

Given the simplicity of the tool (0 parameters, no output schema), the description provides the core function but lacks details on the expected return value or any behavioral nuances. It is adequate for a trivial version check but could be slightly more descriptive.

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, which earns a baseline of 4 per the rubric. The description correctly implies there are no inputs to specify, so no additional parameter explanation is needed.

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

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

The description clearly states the tool retrieves the Proxmox VE version using the specific verb 'Get' and resource 'Proxmox VE version'. It distinguishes itself from sibling tools by targeting version information, which no other sibling covers.

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

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

The description gives no explicit when-to-use guidance, but the usage is implied by the tool's name and its purpose. Since there are no alternative tools for fetching the version, the context makes it obvious when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the function name without revealing any operational details. It does not explicitly state that the operation is read-only, describe the response format, or note any potential errors, failing to add value beyond the tool name.

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 unnecessary words. It efficiently communicates the tool's purpose and is appropriately sized for a tool with one parameter, earning a high score in this dimension.

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 lacks an output schema and annotations, so the description should at least hint at the return value or the meaning of 'status'. It does neither, leaving the agent unaware of what the response will look like. The low complexity mitigates this slightly, but the missing return details make the description incomplete.

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 already documents the single parameter 'poolid' with a description, so the baseline is 3. The description adds no additional meaning or context for the parameter, leaving parameter semantics entirely to 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's function with a specific verb ('Get') and resource ('status of a resource pool'). It distinguishes itself from sibling tools like list_resource_pools (which lists pools) and other status getters targeting different resources, making the purpose unambiguous.

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

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

The description offers no guidance on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or references to related tools such as list_resource_pools or get_cluster_status, leaving the agent without context for selection.

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

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

No annotations are provided, so the description carries the full behavioral burden. It clearly indicates a read-only operation ('Get'), which is non-destructive, but it does not disclose return format, error handling, or permission requirements. For a simple listing operation, this is adequate though not detailed.

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 that directly states the tool's function without any redundant words or fluff. It is appropriately front-loaded and easy to parse.

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

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

Given the simplicity of the tool (one parameter, no output schema), the description is minimal but adequate. It does not explicitly state the response format or behavior when the node is invalid or has no running VMs, but the core functionality is clear. It could benefit from a bit more context, but it is not critically incomplete.

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 fully documents the only parameter 'node' with 100% coverage, and the description adds no additional semantic meaning beyond the schema. The baseline of 3 applies because the schema already handles the parameter description adequately.

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

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

The description clearly states the tool lists all running VMs and containers on a node. The verb 'Get' and the specific resource (running VMs/containers) make the purpose unambiguous, and it is easily distinguished from sibling tools like get_vm_status (for a specific VM) or get_node_status (node health overview).

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

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

The description implies the tool is used to retrieve running VMs and containers on a node, but it does not explicitly state when to prefer this over similar tools such as get_vm_status or get_container_status. No alternatives or exclusions are mentioned, so the agent must infer the appropriate use case.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only restates the tool's function without revealing read-only behavior, authentication needs, or what the response looks like. It adds minimal value beyond the tool name.

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 that immediately conveys the tool's purpose. It contains no redundant information and is well-structured for quick scanning.

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 simplicity of the tool (two optional parameters, no output schema), the description is adequate but minimal. It does not explain the return format or how the optional parameters affect the result, which would be helpful for a complete understanding. Still, it meets the minimum viable threshold.

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 already provides descriptions for both 'node' and 'storage' parameters, covering 100% of the parameters. The description itself adds no additional parameter semantics, so the 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?

The description clearly states the action ('Get status') and resource ('Proxmox storage'), making it distinguishable from sibling status tools like get_node_status and get_cluster_status. However, it does not detail what aspects of storage status are returned, so it is a clear but not fully specific 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?

No guidance is provided on when to use this tool versus alternatives. The name implies it is for storage status, but there is no explicit mention of context, prerequisites, or exclusion of other tools, leaving the agent without decision support.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get' implies read-only, but it does not explain what the summary contains, whether it aggregates data, or any access requirements. It adds minimal behavioral context beyond the verb.

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

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

The description is a single, front-loaded sentence with no redundancy. It is concise and easy to parse, earning a high score for efficiency.

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

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

The tool has no output schema and no annotations, so the description should explain what the summary includes (e.g., CPU, memory, disk). It does not, leaving the return format and scope ambiguous. For a simple tool with one required parameter, it is under-specified relative to the context.

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

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

The schema fully describes the only parameter 'node' as 'Node name' (100% coverage), so the baseline is 3. The description adds no extra meaning about the parameter, but the schema already handles it adequately.

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

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

The description states a clear action ('Get') and a specific resource ('summary of Proxmox node resources'). It distinguishes the tool's function but does not explicitly differentiate it from sibling status tools like get_node_status or get_storage_status, and 'summary' is somewhat vague.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any context, exclusions, or alternative tools, leaving the agent without decision criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral transparency. It only states that it gets a status, which implies a read operation, but does not mention potential errors, whether the task must be actively running, or any side effects. The term 'running task' is left undefined.

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 that is front-loaded with the action and object. Every word contributes to the core meaning, with no redundant or filler content.

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

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

The tool is simple (2 parameters, no nested objects), but with no output schema and no annotations, the description should explain what 'status' means, how the response is structured, or any related constraints. It does not, leaving the agent with insufficient context to fully understand the tool's behavior.

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

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

Schema description coverage is 100% for both parameters, with clear descriptions ('Node where task is running' and 'Task ID'). The tool description adds no additional meaning beyond what the schema already provides, so the 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?

The description clearly uses a specific verb ('Get') and resource ('status of a running task'), making the basic purpose understandable. However, it does not differentiate from sibling status tools like get_node_status or get_iso_download_status, leaving some ambiguity about what 'task' specifically refers to.

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

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

There is no guidance on when to use this tool versus alternatives. The sibling list includes many status-related tools, but the description offers no exclusions, prerequisites, or context that would help an agent choose this tool appropriately.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It does not mention whether the operation is read-only, if authentication is required, what the response format is, or how the optional node parameter affects the result. This leaves significant gaps for an agent to anticipate side effects or output.

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 direct and front-loaded. It contains no redundant information and every word adds value. It is appropriately sized for the tool's simplicity.

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

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

The tool has no output schema and no annotations, so the description should compensate by explaining return values, scope, and behavior. It only states 'Get available updates for Proxmox,' leaving unclear what the output looks like, how node filtering works, and whether it contacts remote repositories. For a tool with one optional parameter, this is still incomplete.

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 fully describes the sole parameter 'node' with a clear description and optional status, so schema coverage is 100%. The tool description does not add additional meaning beyond the schema, but the baseline of 3 applies because the schema itself is sufficient.

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 ('available updates for Proxmox'), which is specific and distinguishes it from sibling tools like get_proxmox_version or get_node_status. Even though the node parameter is not mentioned, the core purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives, no exclusions, and no mention of prerequisites. For example, there is no suggestion to use this before upgrade_proxmox or to check updates on specific nodes. It is a bare statement of functionality.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds the critical constraint 'requires guest agent', which is useful. However, it fails to mention what happens when the agent is missing (e.g., error vs empty list) or what the return data includes, leaving some behavioral ambiguity.

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 redundant words. It front-loads the core purpose and appends the crucial prerequisite, making it maximally efficient while still informative.

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

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

The tool is simple with only two well-documented parameters and no output schema. The description adequately identifies the operation and a key prerequisite, but it does not specify what the returned interface data looks like (e.g., list of IP/MAC), which would be helpful given the lack of an output schema. It is adequate but leaves a notable gap.

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

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

The input schema already provides descriptions for both parameters (node and vmid) with 100% coverage. The tool description does not add any additional meaning or clarify parameter usage beyond what the schema gives, so it neither enhances nor detracts from the schema information.

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

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

The description clearly states the action ('Get') and the resource ('network interfaces from a VM'), making its purpose specific and distinct from sibling tools like get_vm_status or set_vm_ip. The added prerequisite 'requires guest agent' further scopes the operation.

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

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

The description mentions the guest agent requirement, which is a clear prerequisite and implicitly tells the agent not to use this tool if the guest agent is not running. However, it does not explicitly compare with alternatives or state when to prefer this tool over related ones, so guidance 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?

With no annotations, the description carries the full burden. It only states 'Get status', implying a read operation, but provides no details about output format, whether node/vmid are required, or what 'status' encompasses. It does not disclose any behavioral traits beyond the obvious.

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

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

A single front-loaded sentence that is easy to parse. It earns its place but lacks detail; it's appropriately concise for a simple description, though not exemplary.

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?

Without an output schema and with no annotations, the description leaves much unknown. The tool's behavior (what statuses are returned, whether it handles multiple VMs, etc.) is ambiguous. Given the large sibling set, a more detailed description is needed.

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

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

Schema coverage is 100% with both node and vmid documented. The description adds no additional parameter information, so the baseline 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 uses a specific verb 'Get' and resource 'status of Proxmox VMs', clearly stating the tool's purpose. However, it does not explicitly distinguish from sibling tools like get_container_status or get_running_vms, so it's clear but not differentiating.

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

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

No usage guidance is provided. The description does not indicate when to use this tool vs alternatives like get_node_status or get_container_status, nor any exclusions or prerequisites.

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

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

There are no annotations, so the description must communicate behavioral traits. 'List available backups' implies a read-only operation but says nothing about return format, pagination, filtering behavior, or any side effects. The term 'available' is vague and unqualified.

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 concise three-word phrase with no filler words. It is front-loaded and easy to parse, but it may be too terse for complex usage. Still, it earns its place as an efficient summary.

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 two parameters, no output schema, and many related backup siblings, the description is insufficient. It does not clarify what data is returned, how node and backupdir affect results, or how this tool fits into the backup lifecycle (create, restore, delete).

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 already provides descriptions for both parameters (node, backupdir) with 100% coverage. The tool description adds no additional meaning beyond what the schema states, so a 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?

The description 'List available backups' clearly states a list operation on backups, distinguishing it from sibling backup tools like delete_backup or create_vm_backup. However, it lacks detail on what 'available' means or whether it covers VM, container, or both, which prevents a top score.

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 restore_backup or create_vm_backup. The description is purely functional and gives no context about prerequisites or typical workflows.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only states the action 'List' without mentioning that it is a read-only operation, what the expected response format is, or whether any permissions are required. It adds no insight beyond the tool's name.

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 redundant or unnecessary words. All key elements (action, resource, scope) are present 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?

The tool is simple with only two parameters and no output schema, but the description does not explain what the return value will contain (e.g., a list of rule objects). It also lacks differentiation guidance from list_vm_firewall_rules, which would enhance completeness for an agent navigating sibling tools.

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 already provides 100% coverage for both parameters (node and vmid) with clear descriptions. The tool description adds no further explanation of the parameters or their usage, so the baseline 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 uses a specific verb ('List') and resource ('firewall rules for a container'), and explicitly names the target as 'container', distinguishing it from the sibling tool list_vm_firewall_rules. It is concise and unambiguous about the tool's primary function.

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 is for containers, but it does not explicitly state when to choose this tool over the alternative list_vm_firewall_rules. There is no mention of when not to use it or any context about container-specific firewall rule management, leaving the decision to the agent's inference.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action without mentioning read-only nature, output format, pagination, or any side effects. This is insufficient for a tool that likely requires specific node and VM ID contexts.

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

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

The description is a single, front-loaded sentence with no filler. It is concise and to the point, making effective use of the limited space.

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

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

Despite the tool's simplicity, the description lacks essential context: no output schema, no annotations, and no mention of what a snapshot list contains or how it behaves across different container states. The minimal text is insufficient as a standalone guide for an agent.

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

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

Schema description coverage is 100%, with clear descriptions for both 'node' and 'vmid'. The description text adds no additional parameter meaning, but the schema already documents them adequately, so the baseline 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 'List snapshots for a container' uses a specific verb and resource, clearly stating the tool's function. It distinguishes itself from sibling tools like list_vm_snapshots by scope (container vs. VM), even if only implicitly through the tool name.

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 list_vm_snapshots. There are no prerequisites, context, or exclusions mentioned, leaving the agent to infer usage solely from the name.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. However, it only states the action 'List' and says nothing about read-only guarantees, permission requirements, or output structure. With zero behavioral context, the description fails to inform the agent of anything beyond the basic operation.

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

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

The description is a single, clear sentence with no superfluous words. It front-loads the key action and object, making it immediately scannable and appropriate for a simple tool.

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

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

The description lacks essential context: there is no output schema to explain return values, and the description itself does not mention what fields are returned, whether storage is an optional filter, or how this tool relates to ISO management siblings. The absence of any usage or behavior details makes the description incomplete for reliable tool selection and invocation.

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

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

The input schema fully describes both parameters (node with type/description, storage with type/description/optional), so the description does not need to repeat them. However, the description does not add any meaning beyond the schema, such as how the storage parameter filters the listing, which is a missed opportunity to enrich 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 'List ISO files on a Proxmox node' uses a specific verb and resource, making the tool's function immediately obvious. It distinguishes itself from sibling tools like list_templates and list_backups by clearly targeting ISO files on a specific node.

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 vs. alternatives, nor does it mention the optional storage parameter for filtering results. It also does not reference related ISO tools like download_iso or delete_iso, leaving the agent to infer usage context from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'List all resource pools' and does not add context about side effects, permissions, rate limits, or return format. The read-only nature is implied but not explicitly stated, and no other behaviors are disclosed.

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

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

The description is extremely concise—a single short sentence that is front-loaded with the action and target. Every word adds value, and there is no unnecessary information.

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

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

Given the tool's simplicity (0 params, no annotations, no output schema), the description is largely complete. It adequately states the purpose and scope, though it does not specify the output format or any filters. Since none exist, this is sufficient but could benefit from a note on returned data.

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 zero parameters, so there are no parameter semantics to explain. The baseline for 0 params is 4, and the description adds no extra parameter-related ambiguity.

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 'List all resource pools' uses a specific verb ('List') and clearly identifies the resource ('resource pools') with a scope ('all'). This distinguishes it from sibling tools like 'get_resource_pool_status' or 'list_templates', which target different resources or actions.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of exclusions, prerequisites, or context. The description simply states the action without any situational advice or comparisons.

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

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

With no annotations, the description carries the full burden. It accurately implies a read-only list operation and the node scope, but it does not disclose any additional behavioral traits such as default behavior when optional filters are omitted, error handling, or return value structure. This is a simple list operation, so the burden is relatively low, but still not fully met.

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, direct sentence that front-loads the action and resource. Every word earns its place with no redundancy or unnecessary detail.

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

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

The tool is a simple list operation and the schema fully documents the parameters. The description clearly states the purpose and scope, which is sufficient for an agent to understand the core function. However, a bit more context about the optional filters or the nature of the return value could improve completeness, especially given the absence of an output schema.

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

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

The input schema provides 100% coverage for all three parameters (node, type, storage) with clear descriptions. The tool description adds no additional parameter semantics beyond the schema, so the 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?

The description uses a specific verb 'list' and names the exact resource 'templates' with scope 'on a Proxmox node'. This clearly communicates the tool's function and distinguishes it from sibling tools like list_isos or get_vm_status.

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

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

The description implies usage—one would use this to list templates on a node—but provides no explicit guidance on when to prefer this over alternatives such as list_isos or get_vm_status. There are no exclusions or alternative references.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only says 'List firewall rules for a VM.' It does not mention whether this is read-only, requires specific permissions, what the output format is, or any side effects. For a simple read operation, some behavioral context is still expected.

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

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

The description is one short sentence that immediately states the purpose without any filler. It is front-loaded and avoids unnecessary details.

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

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

The tool is simple with two required parameters and no output schema, so the description is minimally viable. However, it omits any indication of what the response looks like (e.g., array of rules) or whether the operation is safe. Given the lack of annotations and output schema, a bit more context 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?

The schema covers 100% of the parameters with descriptions ('Node where VM is located' and 'VM ID'), so the description does not need to add much. It adds no extra meaning beyond the schema, but the schema is already sufficient.

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 (List) and the resource (firewall rules for a VM), which fully specifies the tool's purpose. It also distinguishes it from sibling tools like list_container_firewall_rules by explicitly scoping to VMs.

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 scoping to VMs implies when to use this tool, but it does not explicitly mention alternatives (e.g., list_container_firewall_rules for containers) or provide exclusion criteria. This is implied usage rather than clear guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly identifies the operation as a read-only list, but it does not mention return format, error scenarios, or any side effects. This is a minimal but acceptable disclosure for a simple list operation, hence a score of 3.

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 redundant words. It is well-structured and easy to parse, earning full marks for efficiency.

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

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

Given the tool's low complexity, fully described parameters, and absence of an output schema, the description is adequate but sparse. It does not explain what the returned snapshot list contains or any edge-case behavior, leaving some gaps for an agent.

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

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

The schema provides 100% description coverage for both parameters ('Node where VM is located' and 'VM ID'), so the baseline is 3. The tool description adds no additional parameter semantics beyond what the schema already documents.

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 'List snapshots for a VM' is a grammatical expansion of the tool name 'list_vm_snapshots' with no additional information. It is specific but amounts to a tautology, doing nothing to differentiate from siblings beyond the name itself.

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 offers no guidance on when to use this tool versus alternatives such as list_container_snapshots or other snapshot operations. There is no mention of prerequisites (e.g., VM must exist) or exclusions, leaving the agent without actionable usage context.

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

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

No annotations are provided, so the description carries full burden. It does not disclose behavioral traits such as whether migration is offline/online, prerequisites (like shared storage), potential downtime, or effects on container operation. The boolean parameters suggest nuances (online, force, stateonly) but the description does not explain them.

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, clear sentence: 'Migrate a container to another node.' Every word contributes to the core purpose, with no filler or redundancy. This is appropriately 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?

For a mutating operation with 8 parameters, no output schema, and no annotations, a one-line description is insufficient. It does not address return values, failure modes, prerequisites, or the impact of flags like 'with_local_disks' and 'online'. The description needs more context to be complete given the tool's complexity.

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

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

Schema description coverage is 100% with descriptions for all 8 parameters (e.g., 'Current node where container is located', 'Target node for migration'). The tool description itself adds no additional semantic value beyond what the schema already provides, meeting the baseline for high 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 uses a specific verb ('Migrate') and resource ('container'), clarifying the operation and target ('another node'). It clearly distinguishes from sibling tool migrate_vm by specifying container rather than 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 container migration (vs. VM migration via migrate_vm) but does not explicitly state when to choose this tool over alternatives or provide exclusions. The behavior is inferred from the tool name and sibling list.

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