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

With no annotations, the description carries the full behavioral burden. It does disclose one meaningful trait beyond the schema: mutating methods are gated behind confirm=true, implying GET is the safe default. However, it does not address PATCH, how confirm guards operations, serialization of params, or error/failure behavior — notable gaps for a tool that can reach arbitrary destructive endpoints.

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

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

Two short sentences, no filler, and the core purpose is front-loaded before the constraint. Every sentence earns its place. It is slightly terse for the complexity of a generic passthrough tool, but as pure economy of language it is well-structured.

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

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

An output schema covers return values, but this is an open-ended tool that can hit any Proxmox endpoint — the highest-complexity case in the sibling set. The description omits essential operational details: how params map to the request, how paths should be formatted, whether specific siblings should be preferred, and what happens on non-2xx responses. One sentence is insufficient for a tool of this scope.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does: it explains the method parameter (GET/POST/PUT/DELETE) and the confirm parameter (required for mutations). But path format (leading slash? full URL?) and params encoding (query string vs request body?) are left entirely undefined — two of the four parameters get no semantic help.

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 verb-resource pair: 'Call any Proxmox API path.' The word 'any' signals this is the generic passthrough/escape-hatch tool, implicitly distinguishing it from the 27 sibling tools that each target a specific operation. It is clear but could more explicitly position itself as the fallback for operations no dedicated tool 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 provides a method-level rule (GET allowed, POST/PUT/DELETE need confirm=true) but gives no when-to-use guidance versus the specific sibling tools. For an escape-hatch tool, the key guidance would be 'use this only when no dedicated pve_* tool applies' — that is absent. The confirm rule is a how-to-use constraint, not a usage-selection guideline.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only mentions the confirm requirement and does not explain side effects, asynchronous behavior, what resources are created or modified, or why confirmation is required.

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

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

The description is short and front-loaded with no filler. However, for an 8-parameter tool with no annotations, this brevity is under-specification rather than effective conciseness.

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

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

Even with an output schema present, the description is incomplete: it lacks usage context, parameter explanations, and behavioral details. An agent cannot determine when to choose this tool or what the confirm flag protects against.

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

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

Schema description coverage is 0%, and the description only adds meaning to confirm. Required parameters (node, source_vmid, newid) and optional parameters (full, name, target, storage) are left unexplained, forcing the agent to rely on titles and defaults.

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 operation ('Clone') and resource ('QEMU VM'), which distinguishes it from sibling tools like pve_create_qemu_vm or pve_migrate_vm. It could be slightly clearer about what cloning entails, but it is not vague or tautological.

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

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

It provides one explicit usage condition: 'Requires confirm=true', which is important because confirm defaults to false in the schema. However, it does not say when to use this tool versus alternatives such as pve_create_qemu_vm or pve_migrate_vm.

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 fully. It does mention 'Requires confirm=true,' which is a critical safety gate, but it omits other important behaviors such as whether the operation is asynchronous, whether it returns a task ID, or whether root privileges are needed. The description adds only this single requirement, leaving most behavioral aspects undisclosed.

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 brief (two sentences), but this is under-specification rather than conciseness. It treats the tool as trivial when it has 12 parameters and likely a complex action. The single useful detail (confirm=true) is front-loaded, but the overall structure lacks the substance an agent needs to correctly invoke the 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?

Given the complexity (12 parameters, no annotations), the description is woefully incomplete. It does not explain how the parameters relate to the LXC container creation, what values are acceptable for things like rootfs or ostemplate, or how the tool behaves after invocation. Even though an output schema exists, the agent cannot know how to form a correct request from this description alone.

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

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

Schema description coverage is 0%, yet the description provides no information about any of the 12 parameters except implicitly requiring 'confirm=true' to be set. It does not explain the meaning or format of required parameters like node, vmid, ostemplate, storage, or optional ones like memory, cores, net0, etc. The description entirely fails to compensate for the lack of schema descriptions, making parameter usage unclear.

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

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

The description clearly states the tool's purpose: 'Create an LXC container.' This is a specific verb and resource, distinguishing it from pve_create_qemu_vm. However, it lacks additional context that could further differentiate it, such as mentioning it's for Proxmox VE containers versus VMs. The core purpose is clear 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. There is no mention of pve_create_qemu_vm or any other sibling for comparison, no preconditions, and no exclusions. The only hint is 'Requires confirm=true,' but this is a parameter requirement, not usage context. The description fails to help an agent decide 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 is the sole source of behavioral disclosure. It reveals that the call requires a confirmation flag, but it does not explain permissions, failure modes, async behavior, or side effects beyond the fact that a VM is created. This is minimal coverage for a mutation-oriented tool with no annotation safety net.

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 two short sentences contain no filler: the first tells the core action and the second communicates a crucial precondition. The information is also front-loaded with the action at the start.

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 11 parameters, zero schema descriptions, zero annotations, and an output schema, a two-line description is not sufficient to let an agent correctly construct a request. Most parameter semantics and usage constraints are left implicit, and the description does not compensate for the almost total lack of schema guidance.

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

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

Schema description coverage is 0%, and the description does not compensate: it only mentions confirm=true. The parameters node, vmid, ide2, scsi0, net0, memory, cores, sockets, and ostype are not explained, leaving the agent without meaningful guidance for Proxmox-specific fields such as ide2 or scsi0.

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 names the action (Create) and the resource type (QEMU VM), so an agent can immediately identify the tool's main purpose. It is not explicitly cross-referenced with sibling creation/cloning tools, but the QEMU qualifier separates it from pve_create_lxc.

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 about when to use this tool over related siblings like pve_clone_vm, pve_create_lxc, or pve_set_vm_config. The only usage-related information is the precondition 'Requires confirm=true', which is a mandatory parameter value rather than a real use-case selector.

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 does reveal that confirm=true is required, which is a useful API guard, but it does not explain what happens if confirm is omitted, whether the VM/container is paused, or what other side effects snapshot creation may have. For a mutating tool, this is incomplete.

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

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

The description is two terse, front-loaded sentences with no filler. The action and the critical confirmation requirement are both stated directly, and every word earns its place.

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

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

Despite having an output schema, this tool has seven parameters, no parameter descriptions, and no annotations. The description covers only the core action and the confirm gate, leaving an agent without guidance on targeting an LXC container via vm_type, what vmstate controls, or how to handle the confirmation requirement beyond setting it true. This is insufficient for a mutating operation.

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

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

Schema description coverage is 0%, so the description needed to compensate by explaining the parameters. It only addresses confirm=true; node, vmid, snapname, vm_type, vmstate, and description receive no semantic guidance. Some names are self-explanatory, but vm_type's allowed values and vmstate's effect are left unspecified.

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

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

The description opens with a specific verb ('Create') and resource ('VM/container snapshot'), so an agent can immediately identify this as the snapshot-creation operation. This also distinguishes it from sibling tools like pve_delete_snapshot and pve_rollback_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 states a hard prerequisite (confirm=true) but gives no guidance on when to use this tool versus alternatives such as pve_delete_snapshot or pve_rollback_snapshot. There are no conditions, exclusions, or context about when snapshotting 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, the description carries the burden of behavioral disclosure. It clearly signals a destructive operation and adds a key behavioral requirement: 'Requires confirm=true', which is not obvious from the schema alone. It does not detail every consequence, such as permanence or dependency effects, but for a delete operation the core behavior is disclosed.

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

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

The description is two short sentences with no filler. Both sentences add value: the first states the action/resource, the second gives a critical invocation requirement. It is appropriately front-loaded and every word earns its place.

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

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

The description is complete enough to identify the operation and the mandatory confirmation flag, but it lacks guidance on parameter values, alternatives, and edge cases. Since an output schema exists, return values do not need explanation, but the missing parameter semantics and usage conditions leave meaningful gaps 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?

Schema description coverage is 0%, so the description must compensate for the five undocumented parameters. It adds some meaning by clarifying that confirm must be true and hinting at VM/container types (and thus vm_type), but it does not explain node, vmid, snapname, or when to set vm_type to 'lxc'. The parameter guidance is inadequate given no schema descriptions.

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

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

The description clearly specifies an action ('Delete') and a resource ('VM/container snapshot'), which fully distinguishes it from sibling tools like create_snapshot and rollback_snapshot. The verb and object leave no ambiguity about 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?

The description implies usage whenever a snapshot needs to be deleted, but it does not explicitly state when this tool should be preferred over alternatives or mention any exclusions. The only operational guideline provided is the confirmation requirement, which is useful but not a full 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 the full burden of behavioral disclosure. It states that deletion requires confirm=true, which is a key safety behavior. However, it does not disclose that this is a destructive, irreversible operation, what happens to associated resources (e.g., disks, snapshots) by default, or whether purge/destroy_unreferenced_disks affect those resources. The description is too terse to fully inform an agent of the consequences.

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

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

The description is very short: one sentence plus a requirement. It is front-loaded with the action and the critical prerequisite. It earns its place, though it could add a bit more context without becoming bloated.

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

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

Given that this is a destructive operation with 6 parameters, no annotations, and an output schema, the description is incomplete. It does not explain the destructive consequences, the meaning of optional parameters, or the difference between VM types. An agent could call it correctly with confirm=true, but might not understand the full impact of purge or destroy_unreferenced_disks, or that deletion is irreversible.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's lack of parameter explanations. The description only mentions 'confirm=true' and the resource type (VM/container), but does not explain the meaning of purge, destroy_unreferenced_disks, vm_type, or how node/vmid relate. The parameter names are somewhat self-explanatory, but the description adds minimal 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 states a clear verb and resource: 'Delete a VM/container.' This distinguishes it from sibling tools like pve_start_vm, pve_stop_vm, pve_create_snapshot, etc. It doesn't explicitly name a sibling alternative, but the action is unambiguous. The mention of 'Requires confirm=true' adds a necessary operational detail.

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

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

The description implies when to use this tool: when you want to delete a VM or container. It does not explicitly state when not to use it or mention alternatives (e.g., pve_shutdown_vm for graceful stop, pve_stop_vm for forced stop). The 'Requires confirm=true' is a usage prerequisite, which is helpful, but there is no guidance on choosing between VM types or when to use purge/destroy_unreferenced_disks.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. 'Return' conveys a read-only, non-mutating operation, which is useful context, but the description does not elaborate on freshness, error behavior, permissions, or whether any cluster-side side effects occur.

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. For a zero-parameter status-query tool, this is the appropriate length and 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?

The tool is simple, has no parameters, and the presence of an output schema covers return-value details. The description provides enough context for an agent to invoke it correctly, though it could optionally state that no arguments are required or that it is a read-only 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 tool accepts zero parameters, so there is no parameter semantics burden for the description to carry. This is the baseline case where no parameter documentation 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 uses a specific verb ('Return') and names the exact resource ('Proxmox cluster status'), making the tool's purpose immediately clear. It is distinguishable from sibling getters like pve_get_version and pve_list_nodes, though it does not explicitly differentiate itself from them.

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

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

There is no guidance about when to use this tool versus alternatives such as pve_list_nodes or pve_get_node_metrics. The intended use is implied by the name, but the description does not state it or mention any conditions, 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?

No annotations are provided, and the description adds no behavioral detail beyond the read-like verb 'Get'. It does not disclose whether metrics are live/sampled, what response characteristics to expect, permission requirements, or possible failure modes.

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; every word contributes to identifying the operation. It is concise, though it sacrifices useful behavioral and usage context.

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 one-parameter read-style tool with an output schema present, the description is minimally sufficient to identify the operation. However, it lacks selection context and behavioral caveats, and the output schema must cover return-value details since the description does not.

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

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

The schema has 0% description coverage for the only parameter, and the description never mentions 'node' or clarifies accepted values such as node name versus ID. The parameter is simple and inferable from the tool name, but the description adds no semantic value beyond the schema's property title.

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

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

The description names a specific verb ('Get'), a distinct resource ('node'), and the information delivered ('status and metrics'). It is differentiated from sibling tools like pve_list_nodes and pve_get_cluster_status by resource scope, though it does not explicitly state that it targets a single 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?

No guidance is provided about when to use this tool versus pve_list_nodes, pve_get_cluster_status, or pve_get_vm_status. The only implicit clue is the tool name and short description, so an agent must infer the selection 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Get task status by UPID.' It does not disclose read-only behavior, error conditions, whether the status is returned directly, or any side effects, though 'Get' implies a read 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, front-loaded sentence with no wasted words. However, it is so minimal that it approaches under-specification rather than deliberate conciseness.

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

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

The tool is a simple getter with an output schema and two self-named parameters, so the description does not need to explain return values. Still, it lacks usage guidance, behavioral details, and parameter semantics, leaving the agent to infer several things from names and 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 schema has 0% description coverage, and the description only references 'UPID' without explaining its format or how to obtain it. The 'node' parameter is not described beyond its schema title, so the description does not compensate for the schema gap.

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

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

The description states a specific verb and resource ('Get task status') and identifies the key input ('by UPID'). This distinguishes it from sibling tools like pve_get_vm_status and pve_get_cluster_status, though it remains terse and does not elaborate on what a task status represents.

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 such as pve_get_vm_status, pve_get_node_metrics, or pve_api_request. There are no exclusions, prerequisites, or context clues beyond the tool name itself.

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

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

With no annotations, the description carries the burden of indicating safety and side effects. 'Return' implies a read-only informational operation and no destructive behavior, but the description does not address authorization, error conditions, or response behavior beyond what the output schema presumably covers.

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 states exactly what the tool does with no filler. Every word earns its place.

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

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

For a simple, parameterless getter, the description is nearly complete, especially because an output schema exists to document return values. It could add minimal context around authentication or unavailability, but none of these are material gaps for version retrieval.

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

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

The tool has zero parameters and schema coverage is 100%, so there are no parameter semantics to explain. The description adds no parameter detail, but none is needed, matching the baseline score for a nullary 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 uses a specific verb ('Return') and a precise resource ('Proxmox VE version information'). It is clearly distinct from siblings like pve_get_cluster_status and pve_list_nodes, so an agent can tell it is the version-reporting endpoint without inspecting schemas.

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 makes the use case clear: call this to obtain Proxmox VE version information. It does not explicitly name alternatives or exclusions, but the scope is unambiguous and no sibling appears to overlap with version retrieval, so the context is sufficient.

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

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

No annotations are provided, so the description must carry the behavioral burden. The word 'Get' implies a read-only operationasia, which is useful, but the description does not disclose permission requirements, potential errors, or explicitly state that no modifications are made. This is a minor gap for a simple getter, so a middle score is appropriate.

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

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

The description is a single, efficient sentence with no redundant wording. It states the operation and the target resource immediately, making it easy to scan and process.

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 getter with an output schema, the description covers the basic operation and resource type, but it omits usage guidance and leaves parameter values (especially vm_type) only partially specified. The presence of an output schema reduces the need to describe return values, but the missing parameter context prevents a higher 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 has 0% description coverage for all three parameters. The description adds a meaningful hint that vm_type corresponds to either QEMU or LXC, but it does not explicitly define allowed values or explain the role of node and vmid beyond their names. It partially compensates for the schema gap but does not fully resolve 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 uses a specific verb ('Get') and a specific resource ('config for a QEMU VM or LXC container'), which clearly differentiates it from sibling tools like get_vm_status (status vs config) and set_vm_config (get vs set). The scope is unambiguous even without opening the schema.

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

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

The description implies usage by naming the resource type, but it does not explicitly state when to use this tool over alternatives such as pve_get_vm_status or pve_list_vms. There is no exclusionary guidance or mention of prerequisites, leaving the agent to infer from the verb and sibling names.

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

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

No annotations are provided, so the description carries the behavioral burden. 'Get' implies a read-only, non-mutating operation, which is useful, but the description does not explicitly state that no VM/container state is changed or mention any auth/rate constraints. This is minimally adequate for a simple read 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 no filler. It states exactly what the tool does without unnecessary elaboration.

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

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

An output schema exists, so return-value documentation is less critical. However, with no annotations and minimal parameter and usage guidance, the description is only minimally self-sufficient. It is complete enough for an obvious getter but leaves gaps around vm_type and when to choose this tool.

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

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

Schema description coverage is 0%, but the description adds almost no parameter meaning. 'QEMU VM or LXC container' hints at the vm_type values, but node and vmid are left only as titles in the schema, and the qemu default for vm_type is not mentioned.

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 clear verb ('Get') and identifies the resource ('current status for a QEMU VM or LXC container'). It is distinct from siblings like pve_get_vm_config, pve_list_vms, and the mutating tools, though it does not explicitly compare against them.

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

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

No guidance is given about when to prefer this tool over alternatives, nor any exclusions. The agent must infer that this is for runtime status rather than configuration, task status, or resource listing.

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

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

The verb 'List' signals a read-only operation, and there is no contradictory annotation. However, with no annotations the description carries the full burden and does not disclose additional behavioral traits such as permissions, pagination, or what 'content' includes.

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

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

One short sentence with the action and resource front-loaded. 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?

For a two-parameter read-only listing tool with an output schema, the description is close to adequate, but it omits parameter semantics and usage guidance. It tells the agent what it does but not enough about how to call it correctly.

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

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

Schema coverage is 0% and the description only paraphrases 'node storage' without explaining the individual 'node' and 'storage' parameters, their expected formats, or how they relate. This is not enough to compensate for the bare schema.

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

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

States a specific action ('List') and resource ('backup content') scoped to a node storage. This clearly distinguishes it from sibling list tools like pve_list_vms and pve_list_storage.

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

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

Provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. Usage is only implied by the name and the one-line 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?

No annotations are provided, so the description carries the behavioral disclosure burden. 'List' implies a read-only operation and the tool has no parameters, but the description does not disclose additional traits such as cluster-wide scope or ordering; the output schema covers return shape.

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

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

A single short sentence with no filler is exactly the right size for a no-argument list operation. The information is front-loaded and every word earns its place.

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

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

For a zero-parameter listing operation with an output schema, the description is minimally sufficient for an agent to invoke it correctly. It could be more explicit about whether it lists all nodes in the cluster, but nothing essential to calling the tool 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 tool has zero parameters and the schema coverage is 100%, so there are no parameter semantics to clarify. The baseline of 4 is appropriate for a parameterless tool.

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

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

The description uses a specific verb ('List') and a specific resource ('Proxmox nodes'), clearly identifying what the tool does. It does not explicitly distinguish itself from siblings like pve_list_resources or pve_get_node_metrics, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as pve_list_resources or pve_get_cluster_status. The intended use case is only implied by the tool name and terse description, not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it's a 'list' operation, which implies read-only, but it doesn't mention pagination, ordering, default behavior when no filter is given, or any potential side effects. The output schema exists but isn't shown in the description, so the return format is not disclosed. This is a minimal disclosure for a read 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, front-loaded sentence that states the purpose and the key option. No wasted words, and it is immediately clear what the tool does.

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

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

Given the tool is a simple list with one optional parameter and has an output schema, the description covers the core usage well. The main gap is not explicitly stating the default behavior when no filter is provided, but this is partially implied by the word 'optionally' and the existence of sibling tools for specific types. The presence of an output schema reduces the need to describe return values.

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 single parameter resource_type is described as an optional filter with examples (vm, storage, node), which adds meaning beyond the schema's plain 'string' type. However, it doesn't explain the default behavior when null (presumably returns all resources) or enumerate the full set of accepted values, which could be important for correct invocation.

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 cluster resources and optionally filters by type (vm, storage, node). This is specific enough to distinguish it from sibling tools like pve_list_vms or pve_list_storage, though it doesn't explicitly mention it's the general-purpose listing that covers all types when no filter is applied.

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 indicates the optional filtering capability, which implies when to use it: when you need resources of a particular type or a combined listing. However, it doesn't explicitly contrast with sibling tools like pve_list_vms or pve_list_storage, so the agent must infer that the specific tools may offer more detailed information or different scopes.

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

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

With no annotations, the description carries the behavioral disclosure burden. 'List' implies a read-only operation and the global-or-node scoping is a useful behavioral distinction, but no further behavior is disclosed beyond that scope.

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

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

The description is one short sentence with no filler. It front-loads the operation and immediately communicates the key scoping choice.

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 single-parameter list tool with an output schema, the description covers the essential invocation modes. However, it does not address when to prefer this over sibling tools or any special behaviors, leaving some context gaps.

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

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

Schema description coverage is 0%, so the description must clarify the node parameter. 'Globally or for a node' effectively conveys that omitting node gives global scope and supplying it restricts to a node, though it does not name the parameter or describe its format.

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

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

The description uses a specific verb and resource: 'List storage', and adds the global-versus-node scoping that distinguishes it from sibling list tools like pve_list_vms and pve_list_resources. It is immediately clear what the tool operates on.

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 such as pve_list_resources or pve_list_nodes. The description states the operation but does not mention exclusions, prerequisites, or sibling routing.

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?

'List' conveys a read-only operation, and 'from cluster resources' identifies the data source. However, with no annotations, the description carries the behavioral burden and does not mention read-only status explicitly, pagination, permissions, or what exactly 'cluster resources' includes.

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 with the verb and object front-loaded. It has no wasted words, though it is a bit terse.

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

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

With zero parameters and an output schema present, the description clearly identifies the tool's intent and source. It is sufficient for an agent to decide to call it; only the lack of usage guidance keeps it from being fully complete.

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

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

The input schema has zero parameters, and schema description coverage is 100%. No parameter explanation is needed; the baseline of 4 applies as no parameters exist.

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 'List' and names exact resource types ('QEMU VMs and LXC containers') drawn from 'cluster resources'. This clearly differentiates it from broader list tools like pve_list_resources and from single-VM tools such as pve_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?

No guidance is given on when to use this tool versus alternatives like pve_list_resources or pve_api_request. The description is purely declarative and leaves the choice to 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 must disclose behavior on its own. It does state the action and the confirmation requirement ('Requires confirm=true'), but it does not describe side effects, downtime, source-node cleanup, or asynchronous behavior. This is moderately transparent but missing significant operational context.

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

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

The description is very concise and front-loaded, with no wasted words. Both sentences carry essential information: the action and a critical requirement (confirm=true).

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 8-parameter mutation tool with no annotations and no documented behavior beyond the basic action, the description is far too sparse. The presence of an output schema helps return-value understanding, but it does not compensate for missing context about prerequisites, migration modes, storage handling, and consequences.

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

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

Schema description coverage is 0%, and the description adds minimal parameter meaning. It only hints that 'target' corresponds to 'another node' and that confirm must be true, but it does not explain required parameters like node/vmid or optional ones like targetstorage, online, vm_type, and with_local_disks.

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

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

The description clearly states the tool's purpose with a specific verb ('Migrate'), resource ('VM/container'), and destination ('another node'). It distinguishes itself from sibling tools because no other sibling is a migration action.

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

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

The description does not explain when to choose this tool over alternatives such as clone or relocate storage. It only mentions 'Requires confirm=true', which is an invocation requirement, not contextual 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 behavioral burden. It does disclose that confirmation is mandatory, which is a useful safeguard for a mutating operation. But it does not describe side effects, failure modes, or behavior when confirm is omitted, and it does not clarify whether the reboot is asynchronous.

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

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

The description is very short, front-loads the action, and has no filler. The confirm requirement is isolated as its own sentence, making it prominent. It is appropriately concise, though the terseness contributes to some 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?

The output schema covers return values, and the core reboot action is clear. However, for a mutating tool amid many VM lifecycle siblings, the description lacks selection guidance, parameter semantics, and side-effect context. It is minimally viable but not fully complete.

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

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

Schema description coverage is 0%, so the description needed to explain the parameters. It only addresses confirm=true. node and vmid are somewhat inferable from their names, but vm_type is left unexplained, and there is no guidance on valid values such as qemu vs lxc.

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 ('Reboot') and a clear resource ('VM/container'), which is distinct from sibling operations like start, stop, shutdown, suspend, or resume. An agent can immediately identify the tool's job from the description alone.

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 one explicit operational prerequisite: 'Requires confirm=true.' However, it does not explain when to choose reboot over related tools such as start_vm, shutdown_vm, or stop_vm. Usage context is mostly implied by the word 'Reboot' rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses that confirm=true is required, which is a behavioral prerequisite, but it does not explain the destructive/irreversible nature of resizing a disk, potential risks (e.g., data loss if shrinking), or whether the operation is synchronous or async. For a mutation tool with no annotations, 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 sentence with no filler. It front-loads the action and includes the critical confirm requirement. It is concise, though it could be slightly more informative without becoming verbose.

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

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

Given the tool has 5 parameters, no annotations, and no schema descriptions, the description is incomplete. It does not explain the size format, disk identifier conventions, or the confirm flag's role. An agent would likely need to guess or call pve_api_request to understand the parameters. The output schema exists but the input semantics are under-specified.

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

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

Schema description coverage is 0%, so the description must compensate. It only mentions 'confirm=true' and does not explain the meaning or format of 'size' (e.g., '10G', '512M'), the 'disk' identifier (e.g., 'scsi0', 'virtio0'), or the 'node'/'vmid' parameters. The description adds minimal value beyond the schema's bare property names.

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

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

The description states a specific verb ('Resize') and resource ('QEMU VM disk'), which clearly distinguishes it from sibling tools like pve_set_vm_config or pve_create_qemu_vm. It doesn't explicitly name a sibling alternative, but the action 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 implies when to use it: when you need to resize a QEMU VM disk. It does not explicitly state when not to use it or mention alternatives (e.g., pve_set_vm_config for other VM settings). The 'Requires confirm=true' is a usage prerequisite, which adds some 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 behavioral disclosure. It does surface the non-obvious requirement that confirm must be true, which is useful. However, it omits state prerequisites and what happens when confirm is false or when the VM is not suspended.

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

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

Two short sentences, front-loaded with the action and a key requirement. There is no filler or redundant content; every word earns its place.

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

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

For a mutating tool with no annotations and no schema descriptions, this is too sparse. It lacks the suspended-state precondition, vm_type guidance, and explicit differentiation from related start/reboot tools. The presence of an output schema covers return values but not invocation semantics.

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 property descriptions have 0% coverage, and the description only compensates for the confirm parameter. Node and vmid are inferable by name, but vm_type with default 'qemu' is unexplained, and no parameter semantics beyond confirm=true are 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 the verb 'Resume' and the resource 'VM/container', making the core operation identifiable. However, it does not explicitly distinguish this tool from sibling start/suspend/reboot tools or mention the 'suspended' precondition, so differentiation is mostly left to inference.

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 about when to use this tool versus alternatives. It does not say it applies to previously suspended VMs/containers, nor does it point to pve_start_vm for stopped VMs. 'Requires confirm=true' is a call requirement, not 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 provided, the description carries the full burden of disclosing behavioral traits. It reveals the confirmation requirement, which is useful, but it does not state that rolling back overwrites the current state, discards changes since the snapshot, or is irreversible. 'Rollback' implies mutation but the description stops short of explicit 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 only two sentences and contains no filler or redundancy. The core purpose is front-loaded, and the confirmation requirement is stated immediately after. It is appropriately terse, though more behavioral detail could have been included without harming conciseness.

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

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

This is a destructive rollback operation with five parameters, no annotations, and an output schema, yet the description provides minimal context. It omits parameter semantics, what happens to the current state, and any prerequisites beyond confirm=true. The output schema covers return values, but the description is not complete enough for safe and correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the missing parameter documentation. It only adds meaning to 'confirm' by saying it must be true; node, vmid, snapname, and vm_type are left to their names and schemas. No additional semantics are given for how these parameters interact with the rollback operation.

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, 'Rollback', and a clear resource, 'a snapshot', which unambiguously states the operation. It distinguishes this tool from sibling tools like pve_create_snapshot and pve_delete_snapshot because 'rollback' implies restoring rather than creating or removing.

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 only usage guidance is 'Requires confirm=true', which is a necessary invocation condition rather than guidance on when to choose this tool over alternatives. It never mentions the destructive or irreversible nature of rollback, nor does it compare with related snapshot 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It does state a confirmation requirement, which hints at a safeguard against unintentional changes, but it does not mention mutation consequences, whether changes apply to running VMs, permission needs, or reversibility. This is minimal disclosure for a config-modifying 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, direct sentence with no filler. The key action is front-loaded, and the critical confirmation requirement is placed in the second clause. Every word contributes, making it highly concise and structurally efficient.

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

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

For a tool with 5 parameters, a nested config object, no parameter descriptions, and no annotations, the description is far too thin. Although an output schema exists and can cover return values, the agent still lacks essential context about what config keys are accepted, how vm_type affects behavior, and what the confirmation flag actually protects against.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning only for 'confirm' by indicating it must be true. It provides no explanation of the central 'config' object, the 'vm_type' values, or the roles of 'node' and 'vmid'. With a nested free-form config object, this is a significant gap.

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

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

The description states a clear action and resource: 'Update VM/container config.' It is not a tautology and can be distinguished from retrieval tools like pve_get_vm_config. However, it does not explicitly differentiate itself from other mutation tools or describe the scope of 'config', so it falls short of a full 5.

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

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

The description provides no guidance on when to use this tool versus alternatives such as pve_create_qemu_vm, pve_create_lxc, or pve_get_vm_config. The only usage-related note, 'Requires confirm=true', is an invocation constraint, not a selection guideline. This leaves the agent to infer appropriate usage from the tool's 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 load. It says 'gracefully' and mandates confirm, but does not disclose timeout behavior, force_stop semantics, or potential side effects of a shutdown. This is minimal for a state-changing operation.

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

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

Two short sentences with no filler; the core action is front-loaded and every word contributes meaning. The terseness is almost too sparing, but as a concise summary it works.

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 6-parameter mutation tool with zero schema descriptions and no annotations, this description is severely incomplete. It does not explain vm_type choices, force_stop/timeout roles, or the safety significance of confirm beyond a passing mention. The existence of an output schema slightly reduces return-value burden, but operational guidance is still far too thin.

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

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

Schema description coverage is 0%, and the description only addresses confirm. It leaves node, vmid, timeout, vm_type, and force_stop unexplained, forcing an agent to guess their meanings from schema structure alone.

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

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

The description states a clear action ('gracefully shut down') and resource ('VM/container'), which distinguishes it from pve_stop_vm (force stop) and pve_reboot_vm. The word 'gracefully' signals the operational intent unambiguously.

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

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

It provides one explicit requirement ('Requires confirm=true'), but does not name alternatives or describe when to choose graceful shutdown over stop/reboot. The usage context is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It discloses the confirm requirement, which is a behavioral constraint, but it does not explain what happens without confirm (e.g., error), whether the operation is synchronous or asynchronous, or any side effects. The disclosure is minimal and leaves key behaviors opaque.

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

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

The description is extremely concise, with only two short sentences, and it front-loads the core action. However, it sacrifices informational richness for brevity; still, it earns points for not wasting words and placing the critical requirement right after the action.

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

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

For a tool with 4 parameters, 0% schema coverage, and no annotations, the description is incomplete. It omits any guidance on the required node and vmid parameters, the meaning of vm_type, and the expected outcome or return value (though an output schema exists, which mitigates that gap). The agent is left to infer too much from the schema alone.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for the confirm parameter by stating it must be true, but it does not clarify the role of node, vmid, or vm_type. Since the schema has no descriptions, the description leaves three of four parameters unexplained, failing to compensate for the coverage gap.

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

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

The description states a clear verb and resource ('Start a VM/container') and is distinct from sibling operations like shutdown, stop, reboot, and resume. However, it does not explicitly differentiate itself from those siblings, so it lacks the specificity of a full contrast.

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

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

It provides a critical usage condition ('Requires confirm=true'), which guides the agent on a required parameter. However, it does not state when to use this tool versus alternatives (e.g., resume vs start) or any prerequisites beyond the confirm flag. Usage context is only implied.

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

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

With no annotations, the description must carry the behavioral burden. It discloses that the stop is hard and that confirmation is required, but it does not warn about unsaved data loss, bypassing graceful shutdown, or behavior if the VM is already stopped. Adequate but thin for a destructive action.

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

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

Two concise sentences with no filler. The action verb is front-loaded, and the single critical usage requirement is stated immediately afterward. Every word earns its place.

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

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

For an unannotated destructive operation, the description is too sparse. It omits how to specify a container via vm_type, provides no safety caveats about forced termination, and lacks any guidance about expected task or result behavior. The output schema reduces the return-value burden, but selection and safety context remain 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 0%, so the description must compensate. It only explains confirm=true, leaving node, vmid, and especially vm_type unexplained. The vm_type parameter matters for choosing between QEMU and LXC, and its absence is a real gap.

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

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

Uses a specific verb and resource: 'Hard stop a VM/container.' The 'Hard' qualifier directly differentiates it from the sibling pve_shutdown_vm, making the forceful nature of the operation 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?

The description implies this is the forceful alternative to shutdown, but it never explicitly states when to prefer it over pve_shutdown_vm or pve_reboot_vm. It does provide the essential precondition 'Requires confirm=true', which is useful, but no exclusion or alternative-selection 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?

No annotations are present, so the description carries the full behavioral burden. It only states 'Suspend' and the confirm requirement; it doesn't disclose reversibility, effects on running workloads, or what happens to the VM/container state. For a state-changing 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 front-loaded sentence with no filler; every word carries meaning. It is concise but brief to the point of omitting useful context.

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 annotations and zero schema parameter descriptions, the description is too thin for a mutating tool. It covers the critical confirm requirement and identifies the target, but omits behavioral effects and doesn't clarify vm_type. The output schema helps with return values but not invocation semantics.

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

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

Schema description coverage is 0%, and the description only compensates for 'confirm' by stating it must be true and hints that vm_type may distinguish VM vs container. node and vmid are left entirely to their names, and vm_type's accepted values are not explained.

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 'Suspend' and identifies the resource as a VM/container, which clearly distinguishes it from siblings like pve_start_vm, pve_stop_vm, and pve_resume_vm. It doesn't explicitly contrast with shutdown/stop, but the operation name and wording are unambiguous.

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

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

No guidance is given on when to choose suspend over stop, shutdown, reboot, or resume. 'Requires confirm=true' is a call requirement rather than usage guidance, so an agent receives little help deciding between this tool and its alternatives.

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