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 mentions the automation scope (Netbox, NPM, DNS, monitoring, backups) but does not disclose potential side effects, reversibility, required permissions, or failure modes. The mutating nature of 'create and provision' is implied but not detailed, and no mention is made of long-running operations or external system impacts.

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 with no fluff. It front-loads the purpose and includes a useful parenthetical about automation targets. However, it could include a bit more actionable detail (e.g., output or when to use) without becoming verbose, so it is 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 complex provisioning tool with 10 parameters and no output schema, the description is insufficiently complete. It does not explain what the tool returns (e.g., a CTID or success message), how long provisioning takes, or dependencies on sibling tools like get_available_ctid. The agent lacks a clear picture of the full operation, side effects, and follow-up actions.

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 10 parameters have descriptions in the input schema (100% coverage), so the baseline is 3. The description itself adds no parameter-specific information beyond the schema—it only summarizes the overall purpose. Since the schema already documents each parameter, the description does not need to compensate.

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

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

The description clearly states the tool creates and provisions a new LXC container, and enumerates the automation targets (Netbox, NPM, DNS, monitoring, backups). This distinguishes it from list/status siblings like list_containers and get_vm_status, though it does not explicitly contrast with provision_stack. The verb+resource is specific and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives such as provision_stack or get_available_ctid. It does not mention prerequisites (e.g., needing a free CTID), exclusions, or scenarios where another tool would be more appropriate. The usage context is only implied by 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 carries the full burden. It discloses only the action ('get next available CTID') but says nothing about side effects, error conditions, determinism, or what 'available' means. An agent cannot infer whether this is read-only or what happens on failure.

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. The action and scope are front-loaded, making it easy to parse quickly. It is appropriately concise for a tool with one parameter.

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 one-parameter tool, the description is adequate but missing key context: it does not state the return value type (e.g., integer CTID), whether the result is immediately usable, or any prerequisites. An agent would need to infer the output format from the name, which is not ideal.

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 documents the single parameter with an enum and description. The tool description adds the phrase 'function range', which clarifies that the CTID is scoped by the function category. This goes slightly beyond the schema's 'Container function category' by linking it to the range concept.

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 verb (get), resource (CTID), and scope (function range). It distinguishes itself from siblings, none of which mention CTID allocation, so an agent can readily identify its purpose.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that it should be called before create_container, nor does it name any sibling as an alternative. The usage context is entirely absent.

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 indicates a read operation (getting status), which is already implied by the name. It doesn't disclose output format, permissions, rate limits, or what 'detailed' entails, adding 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 a single clear sentence with no wasted words, appropriately concise for a one-parameter tool. It sacrifices some useful context for brevity, but remains 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?

With no output schema and no annotation coverage, the description leaves the agent uninformed about what 'detailed status information' actually contains, whether the node must exist, or how this tool compares to get_vm_status. The description is barely more than the tool name.

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 'node' parameter with a description ('Node name'), achieving 100% schema coverage. The tool description adds 'Proxmox node' context but doesn't explain how to find valid node names or any formatting requirements, 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 states a clear verb ('Get') and resource ('detailed status information for a Proxmox node'), making it distinct from sibling tools aimed at VMs/containers. It doesn't explicitly name alternatives like get_vm_status, but 'node' disambiguates well.

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 instead of get_vm_status or list_nodes. No conditions, exclusions, or alternative tool mentions are present, so the agent is left without routing 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 indicates the operation is a read but does not disclose what 'detailed status information' includes, whether the VM must exist, or what error conditions may 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 words. It is concise and easy to parse, though it offers no structural detail because of its minimal length.

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 two-parameter read tool, this is minimally adequate. However, with no output schema and no annotation, the description does not explain the shape of the returned status information or clarify failure behavior, leaving a moderate gap 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%, so the schema already documents both parameters clearly. The description adds no additional parameter meaning, which is acceptable given the high 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 uses a specific verb ('Get') and resource ('detailed status information for a specific VM'), clearly indicating a read operation on one VM. This distinguishes it from list_vms and list_containers, though it does not explicitly differentiate from 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?

No guidance is provided on when to use this tool versus alternatives like get_node_status or list_vms. The context is implied by the name and description, but no exclusions or alternative-selection conditions are stated.

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

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

With no annotations, the description must carry the behavioral burden. 'List' implies a read-only operation, and the description does not mention any side effects or additional behavior. It is a simple listing, but lacks explicit disclosure of output format or error conditions, so it earns a mid-level score.

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 that front-loads the core action and scope. No unnecessary words or filler, earning a top score for 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?

For a simple listing tool with one optional parameter and no output schema, the description is nearly complete. It does not explicitly state the return format (e.g., list of container IDs and names), but the verb 'list' implies a list result. This is adequate for a tool of this complexity.

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

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

Schema coverage is 100% and the description essentially restates the parameter's purpose ('on a specific node or all nodes') which mirrors the schema description. No additional semantics are added beyond what the schema already provides, so the baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'LXC containers', and specifies the scope ('on a specific node or all nodes'). It distinguishes from sibling tools like list_vms and list_nodes by its focus on LXC containers specifically.

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 by mentioning 'specific node or all nodes', but does not explicitly exclude alternatives like list_vms. It provides clear context for scope without naming alternatives or conditions, which is a minor gap.

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 disclosing behavior. 'List all Proxmox nodes' clearly indicates a read-only listing operation, but it adds no detail about output shape, ordering, error behavior, or authentication requirements. For a simple zero-parameter list tool this is adequate but not comprehensive.

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 immediately states the action, the object, and the scope, earning its place with zero wasted words.

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

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

For a parameterless list operation with no nested objects and no output schema, the description is largely sufficient. The only missing piece is a hint about what the returned payload looks like, but that is a minor gap for such a straightforward tool.

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

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

The tool has zero parameters, and schema coverage is effectively 100% since there is nothing to document. The description does not need to elaborate on parameters, and none are missing. This matches the baseline for parameterless tools.

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') with a clear resource ('Proxmox nodes in the cluster'). It naturally distinguishes itself from sibling tools like list_vms and list_containers by naming the exact entity type, leaving no ambiguity about what the tool returns.

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 intended use is implied: call it when you need the set of Proxmox nodes. However, it does not explicitly state when not to use it or mention alternatives such as get_node_status for per-node detailed status, so the guidance is only implicit.

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 states the core behavior but does not add details such as read-only safety, output shape, or what happens when the node does not exist. The 'list' wording implies a non-mutating read, yet that is not explicitly stated.

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 communicates the action, resource, and optional targeting with no wasted words.

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

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

For a simple list operation with one optional parameter and no nested objects, the description plus schema is nearly complete. It could be improved by explicitly noting the non-mutating nature and the return shape, but nothing essential for invoking it 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?

Schema coverage is 100% and the node parameter already has a clear description. The tool description adds the 'all nodes' default behavior, but this mostly restates what the schema already conveys.

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

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

The description names the specific operation (list), the resource (virtual machines), and the scoping options (a specific node or all nodes). This clearly separates it from sibling tools like list_containers and 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 gives clear context: VMs may be listed for one node or all nodes, and the schema notes that omitting node broadens the query. It does not explicitly name alternative tools or exclusions, but the resource focus makes the intended use obvious.

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 mentions 'pre-configured' and 'common settings' but does not explain side effects (e.g., creating containers, potential destruction of existing resources), whether the operation is reversible, what the response looks like, or any prerequisites. This is a significant gap for a provisioning action.

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

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

The description is a single, concise sentence that gets to the point quickly. It is front-loaded with the core purpose. However, for a provisioning tool with multiple parameters and potential complexity, the brevity might be too extreme, but it does not contain wasted words, so a 4 is appropriate.

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

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

The tool has 4 parameters, no output schema, and no annotations. The description is minimal, lacking details about the provisioning process, what 'common settings' entails, expected outcomes, or any prerequisites. An agent would not have enough context to understand the full implications of calling this tool, especially compared to the richer sibling tools. This is incomplete for a provisioning action.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any information about parameters beyond what the schema provides; it only generically refers to 'common settings'. Since the schema already documents each parameter well, the description adds no additional semantic value, but the baseline holds.

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 (provision) and the resource (pre-configured container stack/template), and notes 'common settings'. It is specific about what it does, though it does not explicitly differentiate from sibling tools like create_container, which is why it doesn't reach 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or contrasts with sibling tools such as create_container or list_containers. The only context is the general provisioning statement, which is insufficient for an agent to decide between similar 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 full responsibility for disclosing behavior. It only states the action without mentioning side effects, idempotency, asynchronous nature, or return values. For a state-changing operation, this is insufficient; an agent cannot infer what happens after calling it.

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

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

The description is a single short sentence, which is concise and front-loaded with the core action. It is appropriately sized for a simple tool, though it could be more informative without becoming verbose. The structure is clean and to the point.

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 annotations and no output schema, the description must explain the operation thoroughly. It only states the basic action, omitting details like whether it returns a task ID, whether it is asynchronous, or whether the VM must be in a stopped state. This is inadequate for an agent to call it correctly with 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% – both 'node' and 'vmid' have clear descriptions. The tool description adds no additional meaning to the parameters, so it does not exceed the baseline of 3. Since the schema fully documents the parameters, a 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 verb 'start' and the resource 'virtual machine', which is specific and directly maps to the tool name. However, it does not explicitly differentiate from siblings like stop_vm or get_vm_status, though the opposite action is implied. It is a clear purpose but lacks any additional context that would distinguish it 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?

There is no guidance on when to use this tool versus alternatives. The description only says 'Start a virtual machine' without mentioning prerequisites (e.g., VM must be stopped), typical use cases, or exclusions. Sibling tools are present but not referenced, so an agent gets no help selecting this tool over others.

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 itself, but it only states the broad action. It does not say whether the stop is graceful or forced, whether it is asynchronous, what side effects occur, or whether it can be safely called on an already-stopped VM.

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 wasted words. It front-loads the core action and is appropriately sized 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?

Despite the tool being relatively simple, the description omits important behavioral context such as return values, asynchronous behavior, error conditions, and prerequisites. With no output schema and no annotations, the description alone is insufficient 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?

The input schema already provides full descriptions for both parameters (node and vmid) with 100% coverage. The description adds no extra meaning beyond what the schema provides.

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

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

The description states a specific verb and resource: 'Stop a virtual machine'. It clearly identifies the action and is immediately distinguishable from siblings like start_vm and 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 about when to use this tool, prerequisites, or alternatives. It does not mention that start_vm is the inverse operation or provide any context for selection.

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