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

With no annotations, the description carries full burden but provides almost no behavioral details. It omits critical traits such as whether 'update' is idempotent, what happens on get, if changes require special permissions, or the effect of parameters like 'delete' and 'propagate'. This leaves agents guessing.

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?

While extremely short, the description is under-specified rather than appropriately concise. It front-loads purpose but lacks depth, forcing agents to infer behavior from the schema alone. A better balance would include a sentence clarifying key behavioral aspects.

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

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

Given the tool's complexity (11 parameters, no output schema, no annotations), the description is severely incomplete. It does not explain return values for 'get', how updates modify ACLs, or how parameters interact. Agents lack sufficient context to use the tool effectively.

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

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

Schema description coverage is high (91%), and each parameter already has a brief description. The tool description adds no additional meaning beyond listing the two actions. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states 'Manage ACL entries (get, update)', clearly identifying the resource and two main actions. It distinguishes from sibling tools which cover different Proxmox features (e.g., backups, VMs), so its scope is clear. However, it could be more specific about what 'manage' entails (e.g., create, delete, list).

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

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

No guidance on when to use this tool versus alternatives. While sibling tools cover different domains, there is no mention of conditions under which proxmox_acl should be chosen or avoided. Missing when-not-to-use advice.

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

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

No annotations are provided, so the description carries full burden. It only mentions elevated permissions for management actions, but omits other behavioral traits like idempotency, side effects of deletion, rate limits, or error conditions. This is minimal.

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

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

The description is short (two sentences) and front-loaded with the core purpose. However, the action enum values are referenced but not fully mapped, and the schema's action description ('List all ACME accounts') is slightly inconsistent with the tool's description.

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 and no output schema, the description covers the basic action categories but lacks details on required fields for create/update, return format, error handling, and prerequisites beyond elevated permissions. It is adequate but not comprehensive.

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

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

Schema coverage is 100% with each parameter already described. The description adds the elevation requirement for certain actions, which is marginally helpful. It does not provide new parameter semantics beyond what the schema offers, so a baseline of 3 is appropriate.

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

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

The description states 'Manage ACME accounts' and distinguishes between query actions (list/get) and management actions (create/update/delete). It is clear about the tool's scope, but does not explicitly differentiate from sibling tools like proxmox_acme_cert or proxmox_acme_info.

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 basic usage guidance: query accounts with list/get and manage with create/update/delete (requires elevated). However, it does not explain when to choose this tool over alternatives, such as when to use proxmox_acme_info instead.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only reveals that some actions require elevated privileges, but omits details such as potential side effects (e.g., revocation effects), success/failure indicators, or whether config retrieval is read-only. The transparency is minimal.

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

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

The description is a single, compact sentence that efficiently communicates the tool's purpose and action categories using a pipe-separated format. Every word adds value; there is no redundant or filler content.

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

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

Given the tool has multiple modes of operation (three certificate actions plus config), the description is adequate but not complete. It lacks information about expected outputs (no output schema present), prerequisites beyond 'elevated', or error scenarios. For a multi-action tool, more detail would improve completeness.

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

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

Although input schema descriptions cover all parameters (100% coverage), the tool description adds meaningful context by grouping the 'action' parameter values into two categories: certificate ops (order, renew, revoke) vs config, and hints at privilege requirements. This goes beyond the schema's generic 'Order new ACME certificate' description for action.

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

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

The description clearly states it manages ACME certificates and enumerates four specific actions (order, renew, revoke, config), distinguishing certificate operations from config retrieval. However, it does not explicitly differentiate from sibling tools like proxmox_acme_account or proxmox_acme_info, which share the ACME domain.

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 basic guidance by noting that certificate operations (order, renew, revoke) require elevated privileges, but it does not explain what 'elevated' means nor when to choose this tool over alternatives like proxmox_acme_account. No explicit when-not-to-use criteria are given.

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

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

Minimal description: 'Query ACME information.' No annotations provided, so description carries the full burden. Lacks disclosure of read-only nature, authentication needs, or side effects.

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

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

Two concise sentences with no extraneous words. Purpose is front-loaded immediately, making it 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?

Tool has 2 parameters and no output schema. Description is minimal; could explain what each action returns or expected behavior. For a simple query tool, it is adequate but not fully complete.

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

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

Schema coverage is 100%, with both parameters already well-described. The description only repeats the action enum values without adding new semantic meaning, so baseline of 3 is appropriate.

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

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

Description clearly states the tool queries ACME information with specific action options (list_plugins, get_plugin, directories), distinguishing it from sibling tools that handle other Proxmox aspects.

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

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

No guidance on when to use this tool vs. other ACME-related tools (e.g., proxmox_acme_account, proxmox_acme_cert). Missing context on prerequisites or use cases.

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

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

No annotations are provided, so the description shoulders the burden of behavioral disclosure. It states 'query' implying read-only, but the term 'requires elevated permissions' hints at privileged access. However, it does not explicitly confirm no side effects, nor does it describe the output or any potential latency. The listing of operations adds some transparency, but overall it's adequate but not thorough.

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

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

Extremely concise: two sentences, with the primary verb and resource ('Query guest info') front-loaded, followed by a quick enumeration of operations and a permission note. No unnecessary words; every part serves a purpose.

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

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

With no output schema, the description could be more complete by hinting at what each operation returns (e.g., JSON data). For a query tool, knowing the output format helps in usage. The description covers operation choices and permissions, but lacks return value context, leaving the agent to infer. This is adequate but not fully complete given the tool's verb ('query').

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

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

The input schema covers 2 of 3 parameters with descriptions (node, vmid) and provides an enum for operation. The description adds value by explicitly listing the operation values (ping, osinfo, etc.) and noting 'requires elevated permissions', which gives context not in the schema. This enhances understanding of the operation parameter beyond the enum 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?

Description clearly states 'Query guest info via QEMU agent' with a specific list of operations (ping, osinfo, etc.). This distinguishes it from sibling tools like proxmox_agent_exec (execute commands) and proxmox_agent_file (file operations), making the purpose immediately clear.

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

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

The description notes 'requires elevated permissions', which is a usage constraint, but it does not specify when to prefer this tool over alternatives (e.g., proxmox_guest_status for basic status) or when not to use it. No explicit when-not or alternative guidance is provided.

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

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

No annotations are provided, so the description carries full burden. It discloses the use of QEMU agent and permission requirements, but does not describe side effects (e.g., whether shutdown is graceful, what happens to suspended state details, whether operations are synchronous or return immediately). This is insufficient for a tool that can alter VM state significantly.

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 a clear list of operations and a note on permissions. It is concise, front-loaded, and contains no unnecessary words.

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

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

Given 3 parameters, no output schema, and no annotations, the description lacks critical context. It does not explain what happens after each operation (e.g., return value, polling for completion), whether the tool is synchronous, or what state the VM is left in after suspending. This is incomplete for a potentially disruptive tool.

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

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

Schema coverage is 67%, with descriptions for node and vmid already provided. The description adds minimal value by enumerating the operation values (shutdown, suspend_disk, etc.), which are otherwise only listed as an enum in the schema. This helps clarify the parameter's meaning but does not fully compensate for the lack of description for the operation parameter in the schema.

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

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

The description clearly states the tool's purpose: 'Guest power control via QEMU agent' and lists the specific operations (shutdown, suspend_disk, suspend_ram, suspend_hybrid). It distinguishes itself by mentioning the QEMU agent, which implies a graceful approach compared to other power tools like proxmox_guest_shutdown or proxmox_guest_stop. However, it does not explicitly differentiate from those sibling tools.

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

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

The description implies usage via QEMU agent and notes 'requires elevated permissions', but it lacks explicit guidance on when to use this tool versus alternatives like proxmox_guest_shutdown (which may use ACPI) or proxmox_guest_stop (force stop). No when-not-to-use or alternative suggestions are provided.

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

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

No annotations are provided, so the description carries the full burden. It adds the requirement for elevated permissions, which is useful, but does not disclose other behavioral traits such as whether the change is immediate, reversible, or affects running processes.

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 consists of two concise sentences, front-loading the core purpose and adding a key requirement. Every word earns its place with no redundancy.

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

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

Given the complexity of the tool (6 parameters, single operation, many sibling tools), the description is adequate but lacks information about prerequisites (e.g., QEMU agent installed and running) and return values (no output schema). It provides enough context for basic use but leaves gaps.

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

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

Schema description coverage is 83%, so the schema already documents most parameters. The description adds no additional parameter context beyond the schema; it only restates the operation enum value. Baseline score 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 indicates the tool manages guest users via QEMU agent and specifies the operation 'set_password'. While it differentiates from sibling agent tools (e.g., exec, file) by focusing on user management, it could be more precise by explicitly stating that it only sets passwords.

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

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

The description mentions 'requires elevated permissions' but provides no guidance on when to use this tool versus alternatives like proxmox_agent_exec or proxmox_agent_power. There is no context about prerequisites (e.g., QEMU agent must be running) or when not to use it.

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

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

No annotations are provided, so the description carries full responsibility. It discloses that update/upgrade are elevated operations, but lacks details on side effects, return values, or error behavior. The description is minimally transparent beyond the elevated hint.

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

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

The description is extremely concise, using a compact notation to convey key behavioral distinctions. Every word carries weight, and the main purpose is front-loaded. No extraneous text.

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

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

Without an output schema, the description should explain return values but does not. It only says 'list versions' for versions but omits format. For update/upgrade, it gives no indication of success/failure output. This is a significant gap for a 3-parameter 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 input schema describes node and package but not action. The description compensates by explaining each action (update/upgrade are package ops, versions lists versions) and adds the elevated context. This adds meaningful value beyond the schema's enums.

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 manages APT packages and distinguishes three specific actions (update, upgrade, versions) with behavioral hints (elevated). No sibling tool overlaps, so purpose is unambiguous.

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

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

The description explicitly notes that update and upgrade require elevated privileges, which guides the agent on prerequisites. However, it does not mention when to use this tool versus alternatives or when not to use it, though the sibling list shows no competing APT tool.

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

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

No annotations are provided, so the description carries full burden. It only lists actions without detailing side effects, permissions required, or any behavioral traits (e.g., whether actions are synchronous, if there are dependencies).

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

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

The description is a single sentence with no wasted words. It is concise and front-loaded with the core action and sub-actions.

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 three parameters, no output schema, and no annotations, the description is too minimal. It lacks information on return values, error handling, prerequisites, or examples, leaving significant 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 67% (node and name have descriptions; action has none). The description adds no parameter details beyond the schema, merely restating the actions. Baseline 3 given coverage, but no extra value.

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

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

The description states it manages Ceph MDS daemons and lists three specific actions (list, create, delete), making the purpose clear. It distinguishes from sibling Ceph tools (e.g., proxmox_ceph_mon, proxmox_ceph_pool) by specifying MDS.

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

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

No guidance on when to use this tool versus alternatives, prerequisites, or conditions under which it should not be used. The description is purely a general statement.

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, but it only lists actions (list, create, delete) without explaining side effects (e.g., deletion is destructive), required permissions, or whether operations are safe. The description adds no behavior beyond what the enum values imply.

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

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

The description is a single, focused sentence that immediately states the purpose and actions. There is no redundancy, and critical information is front-loaded. Every word is necessary.

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

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

The description is too minimal for a tool interacting with Ceph monitors. It lacks information about return values, error conditions, required Ceph cluster state, and typical use cases. Given the absence of an output schema and annotations, the description should provide more behavioral and usage context.

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

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

The description does not elaborate on parameter meanings beyond the schema. The action parameter's enum values are listed but not explained (e.g., what 'create' entails, that monid is needed for create/delete). The schema covers 'node' and 'monid' with brief descriptions, but the description misses the opportunity to clarify usage.

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

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

The description 'Manage Ceph monitors (list, create, delete)' explicitly states the tool's purpose with a verb and resource, and the parenthetical clarifies the allowed actions. It clearly distinguishes this tool from sibling Ceph tools (e.g., proxmox_ceph_osd, proxmox_ceph_pool) by specifying monitors.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention when not to use it, prerequisites, or relationships to other Ceph tools. For example, it doesn't indicate that this tool is for monitor management while proxmox_ceph_osd is for OSD management.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It only lists operations without any details on side effects (e.g., data loss on delete), authentication needs, rate limits, or other behavioral traits. The description is insufficient for safe invocation.

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

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

The description is a single short sentence that efficiently conveys the tool's purpose and allowed operations. It is concise, though it could be structured to front-load the most critical behavioral information (e.g., side effects of delete).

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 8 parameters, no output schema, and no annotations, the description is too minimal. It does not explain return values, parameter requirements per action (e.g., name required for create/delete but not list), or operational constraints. Important context 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 description coverage is high (88%). The description does not add parameter-specific meaning beyond what the schema already provides, such as dependencies between parameters and the action field. It relies entirely on the schema for parameter semantics.

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

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

The description clearly states the tool manages Ceph pools and explicitly lists the supported operations: list, create, update, delete. This provides a specific verb and resource, and no sibling tool duplicates this exact purpose, ensuring easy differentiation.

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

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

The description implies the tool is for managing Ceph pools via the listed actions, but it does not explicitly state when to use it vs. alternatives (e.g., general Ceph management tools like proxmox_ceph). No usage scenarios, prerequisites, or exclusions are mentioned.

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

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

No annotations are provided. The description discloses that upload and delete actions require elevated privileges, but it does not mention any other behavioral aspects such as side effects, return values, or the impact of parameters like 'force' and 'restart'. This leaves some behavioral ambiguity.

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

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

The description is extremely concise: two sentences with no extraneous words. The first sentence establishes the overall purpose, and the second efficiently lists actions with brief descriptors. It is front-loaded and every word adds value.

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

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

Given the lack of output schema and 6 parameters, the description covers the basic actions but lacks detail on return values, error handling, or the effect of optional parameters like 'force' and 'restart'. It provides minimal context beyond the action list, leaving gaps for a complete understanding.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional meaning beyond the schema; it merely summarizes the actions. The individual parameter purposes (node, certificates, key, force, restart) are not elaborated beyond what the schema already 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 starts with 'Manage node SSL certificates,' clearly stating the verb and resource. It then enumerates three specific actions (list, upload, delete) with brief explanations. This differentiates it from sibling tools like proxmox_acme_cert, which handles ACME certificates.

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

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

The description implies usage for node SSL certificates via the title and action descriptions. It notes that upload and delete require elevated privileges, providing a usage condition. However, it does not explicitly state when not to use this tool or mention alternative tools for different certificate types.

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

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

Without annotations, the description must fully disclose behavioral traits. It only mentions 'requires elevated' for the regenerate action but omits details about idempotency, side effects, or return values for other actions. This leaves significant gaps for an agent to invoke the tool correctly.

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

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

The description is extremely concise—one opening sentence plus a pipe-separated list of actions. Every sentence earns its place, and the structure is front-loaded with a high-level purpose, making it easy for an agent to parse quickly.

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

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

For a tool with 4 parameters and no output schema, the description adequately covers each action's behavior and required parameters. Minor gaps exist (e.g., what 'elevated' means, return format), but the core functionality is clearly communicated.

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?

Although schema coverage is 100%, the description adds value by mapping each action enum to a meaningful summary (e.g., 'dump: dump rendered config'), clarifying the schema's generic description for the action parameter. It also lists dump_type options explicitly, aiding understanding 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 starts with 'Manage cloud-init for a QEMU VM,' clearly identifying the resource and actions. It then lists three specific actions (get, dump, regenerate) with brief descriptions, making the purpose unambiguous and distinct from sibling tools.

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

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

The description provides explicit usage for each action variant (e.g., 'action=get: list config'), which helps the agent select the correct action. However, it does not compare this tool to alternatives (e.g., proxmox_guest_config) or specify when not to use it.

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

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

With no annotations provided, the description carries full burden for behavioral traits. It only notes that create, update, and delete are 'elevated', implying privilege requirements. It does not disclose destructive semantics for delete, idempotency, rate limits, or what happens to related rules. For a CRUD tool with destructive actions, this is insufficient.

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

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

The description is concise, using a single sentence with a structured list of actions. It is front-loaded with the tool's purpose. However, the list format is somewhat dense and could be slightly clearer if actions were separated by newlines or punctuation.

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 (6 parameters, no output schema, no annotations), the description is incomplete. It does not explain return values, error behavior, or how this tool relates to other firewall tools (e.g., proxmox_cluster_firewall_rule for rules within groups). Essential details for correct invocation are 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 description coverage is low (17%), so the description must compensate. It only indirectly explains the 'group' parameter via 'get group by name', but does not describe 'comment', 'rename', 'delete' (a parameter name), or 'digest'. The action enum is described, but other parameters lack guidance, leaving the agent to infer from parameter names alone.

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

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

The description clearly states it manages cluster firewall groups and enumerates actions (list, get, create, update, delete). The verb 'manage' combined with the action list provides a specific purpose. However, it does not explicitly differentiate from sibling tools like proxmox_cluster_firewall or proxmox_cluster_firewall_alias, though the resource 'group' is implied.

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

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

The description provides guidance for each action (e.g., 'list groups', 'get group by name', 'create group (elevated)'), indicating when to use each. However, it does not offer context on when to choose this tool over alternatives (e.g., using cluster firewall rules or aliases), nor does it mention prerequisites or postconditions.

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

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

The description notes that create, update, and delete actions are 'elevated', implying higher privilege requirements. This is a behavioral trait beyond what the schema provides. However, it does not disclose other side effects, such as whether list returns all rules or if updates are partial or full, nor does it mention idempotency or error behaviors.

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

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

The description is a single sentence and front-loaded with 'Manage cluster firewall rules'. It is concise but overly terse, compressing multiple actions into a list without structural separation. Every word serves a purpose, but the format could be improved (e.g., using bullet points or separate sentences) for better readability.

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

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

Given the tool's complexity (17 parameters, no output schema or annotations), the description is severely incomplete. It does not explain when each action is appropriate, what the return values look like, error conditions, or prerequisites. An agent would struggle to use this tool correctly based solely on the description.

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

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

The schema has very low description coverage (18%), with many parameters lacking meaningful descriptions. The tool description does not add any parameter-level information beyond the action list. For example, 'pos', 'rule_action', and 'type' are not explained in context. The description fails to compensate for the poor schema coverage.

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

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

The description clearly states 'Manage cluster firewall rules' and lists the supported actions (list, get, create, update, delete) with brief explanations. This distinguishes the tool from siblings like proxmox_cluster_firewall (which likely manages firewall options) by focusing on individual rule operations. However, the purpose is conveyed through a list rather than a unified statement.

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

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

The description does not provide any guidance on when to use this tool versus alternatives such as proxmox_cluster_firewall_group or proxmox_guest_firewall_rule. There are no prerequisites, constraints, or examples to help an agent decide between actions or understand typical workflows.

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

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

No annotations are provided. The description only notes 'elevated' for certain actions, but lacks details on side effects, idempotency, state changes, or error conditions. Behavioral transparency is minimal.

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

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

The description is a single sentence with a list, which is concise. However, it could be more efficient by grouping 'elevated' once. It lacks structure for readability and depth.

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

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

Given 14 parameters, no output schema, and missing behavioral details, the description is severely incomplete. It fails to provide necessary context for correct usage.

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

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

Schema description coverage is only 21%, and the description does not explain any of the 13 non-action parameters. The enumeration of actions is helpful but does not compensate for the lack of parameter semantics.

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

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

The description states 'Manage cluster replication jobs' and lists specific actions (list, get, create, update, delete), making the purpose clear. However, the verb 'Manage' is generic, and there is no explicit differentiation from sibling tools like proxmox_node_replication, though the cluster-level scope is implied.

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

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

The description mentions 'elevated' for create/update/delete, hinting at permission requirements, but provides no guidance on when to use this tool versus alternatives, no context on prerequisites, and no exclusions.

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

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

No annotations are provided, so the description carries the burden. It indicates a read operation ('get a ticket') and a permission requirement, but does not disclose potential side effects, access restrictions, or whether the ticket has an expiration. This is adequate but not thorough.

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

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

The description is a single, efficient sentence that front-loads the core action and includes the permission caveat. Every word earns its place; no fluff.

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

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

The tool has no output schema, so the description should clarify return values. It does not mention whether a ticket URL, token, or something else is returned. For a simple retrieval tool, this is a gap. Also lacks usage examples, though not strictly required.

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

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

Schema coverage is 100%, with each parameter described in the schema. The description adds context that the 'type' parameter distinguishes between VM and LXC, but does not add meaning beyond what the schema already provides. 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 specifies the action ('get a VNC proxy ticket'), the target resources ('VM (type=vm) or LXC container (type=lxc)'), and the requirement for elevated permissions. It distinguishes from sibling tools like proxmox_console_spice and proxmox_console_term by focusing on VNC.

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

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

The description mentions 'requires elevated permissions' but does not explicitly state when to use this tool over alternatives like SPICE or terminal consoles. It provides implied context but lacks clear when-to-use or when-not-to-use 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 disclose behavioral traits, but it only mentions permission requirements. It omits critical details such as whether the operation is synchronous, idempotent, or what happens if the vmid already exists.

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 is essential and directly conveys the tool's purpose and a key constraint.

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 moderate complexity (9 parameters, no output schema), the description lacks details on return values, success indicators, or error conditions. It is minimally functional but not complete for an agent to fully understand tool behavior.

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

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

The input schema covers all 9 parameters with descriptions (100% coverage), so the description adds no additional semantics. Baseline score of 3 is appropriate.

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

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

The description explicitly states 'Create a new LXC container' with a specific verb and resource, clearly distinguishing it from siblings like proxmox_create_vm for VMs. No ambiguity.

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

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

The description mentions 'requires elevated permissions' but gives no guidance on when to use this tool versus alternatives like cloning or updating, nor any context about prerequisites or sequencing.

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

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

With no annotations, the description carries full burden. It only states it creates a VM and needs elevated permissions, but lacks details on success response, error states, concurrency, or whether operation is idempotent. Minimal disclosure for a creation 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?

Single sentence, front-loaded with the core action. No unnecessary words or repetition. Efficient 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?

No output schema and no description of return value (likely VM ID). For a creation tool, the agent would need to know what is returned. Also lacks details on required permissions or prerequisites. Incomplete given the tool's complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add any parameter meaning beyond what the schema already provides. No extra context for how parameters like 'iso' or 'net0' interact.

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

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

Description clearly states 'Create a new QEMU virtual machine', specifying the verb 'Create' and the resource 'QEMU virtual machine'. This distinguishes it from sibling tools like proxmox_create_lxc (container) or proxmox_guest_clone (clone existing VM).

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

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

Mentions 'requires elevated permissions' but does not explicitly guide when to use this tool vs alternatives like proxmox_guest_clone or proxmox_get_next_vmid (referenced in schema but not in description). No when-not-to-use or comparison with siblings.

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

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

No annotations provided, so description must disclose behavioral traits. It fails to mention whether actions are read-only or destructive, authorization requirements, or side effects.

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

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

Very short and to the point, but the pipe-delimited action format is somewhat terse. No unnecessary words.

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

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

No output schema, no annotations, and description lacks return format for list action, error conditions, or how to combine path/filepath. Incomplete for a 6-parameter tool.

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

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

Schema coverage is 83%, baseline 3. Description adds meaning to the action parameter (list/download) but does not explain path vs filepath beyond schema.

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

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

Description states it restores files from backup and lists two actions (list/download), which is specific. However, it does not differentiate from sibling tools like proxmox_backup or proxmox_guest_snapshot that might also handle restores.

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

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

No explicit guidance on when to use this tool versus alternatives. Does not mention prerequisites or when list vs download 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 must disclose behavioral traits. It states 'requires elevated permissions' and specifies the guest types. However, it does not describe the cloning process's impact (e.g., non-destructive to source), return behavior, or other side effects. This is a minimal disclosure.

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

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

The description is a single, front-loaded sentence that conveys essential information without any waste. Every word serves a purpose, making it highly efficient.

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

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

The tool has 6 parameters (4 required) and no output schema. The description covers the core purpose and a permission caveat, but does not explain return values, error conditions, or the expected workflow. For a clone operation, this is sufficient for basic understanding but lacks completeness for nuanced agent decision-making.

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 83%, so most parameters are documented within the schema. The description adds no extra parameter-specific meaning beyond what the schema already provides. It mentions the 'type' parameter implicitly via examples, but does not enhance understanding of other parameters like 'name' or 'hostname'.

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

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

The description clearly states the action ('Clone'), the resource types ('VM (type=vm) or LXC container (type=lxc)'), and a key requirement ('requires elevated permissions'). It distinguishes between the two guest types, making the tool's purpose unambiguous.

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

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

The description mentions that elevated permissions are required, but does not provide guidance on when to use this tool versus alternatives like proxmox_create_vm or proxmox_guest_migrate. It implies usage for cloning, but no explicit when-not or comparative context.

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

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

With no annotations, the description only indicates 'Delete' and 'requires elevated permissions'. It does not disclose irreversibility, confirmation steps, or effect on associated resources, which are relevant for a destructive operation.

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

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

One sentence of 12 words, efficiently conveying the core purpose and a key constraint, with no unnecessary content.

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

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

For a destructive tool with 3 required parameters and no output schema, the description lacks context about the return value, potential implications, and fails to mention any side effects or safety measures.

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 67% (type parameter lacks description). The description does not provide any additional parameter information beyond the schema, failing to compensate for the gap.

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

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

The description clearly states the action (Delete) and the resource types (VM or LXC container), distinguishing it from other guest operations like shutdown or stop.

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

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

It mentions a prerequisite (requires elevated permissions), which provides guidance on when the tool can be used, but does not explicitly state when not to use it or compare to alternatives.

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

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

No annotations are provided, so the description must cover behavioral traits. It only states 'Move guest storage' and 'requires elevated permissions,' but fails to disclose side effects like potential downtime or the default behavior of deleting the source disk (default: true in schema). The mutation and destructive potential are not explicitly addressed.

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 communicates the essential information without any fluff. Every word earns its place.

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

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

Given the tool's complexity (6 parameters, no output schema), the description lacks critical context about prerequisites (e.g., VM must be stopped), whether the operation is synchronous, and the default delete behavior. The schema covers some details, but the description should at least hint at these aspects to be complete.

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

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

Schema coverage is high (83%), and the description adds value by clarifying the 'type' parameter (VM vs LXC). For other parameters, the schema descriptions are sufficient, so the description does not need to repeat them. Overall, it provides meaningful additional context for the key distinguishing parameter.

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

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

The description clearly states the verb (move), resource (guest storage), and specifies the applicable types (VM or LXC container), distinguishing it from sibling tools like proxmox_guest_disk_resize.

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 notes that elevated permissions are required but does not provide guidance on when to use this tool versus alternatives (e.g., disk resize, disk attach). No explicit when-not-to-use or alternative names are given.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only notes elevated permissions, but fails to mention if resizing requires the guest to be stopped, whether it's destructive, or any side effects. This is insufficient for a mutation tool.

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

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

The description is a single, efficient sentence with no superfluous words. It is appropriately concise, though it could benefit from slight elaboration without losing 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 description lacks crucial context such as whether the operation requires the guest to be offline, what happens to existing data, or the return value format. Given zero annotations and no output schema, it is incomplete for a destructive resize 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 high (80%), so much parameter meaning is already captured. The description adds context for the 'type' parameter by clarifying VM vs LXC, but does not significantly enhance beyond the schema.

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

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

The description clearly states the tool resizes guest storage for both VM and LXC container types, with a specific verb and resource. It distinguishes from sibling tools like proxmox_guest_resize by specifying 'disk' resize.

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

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

The description mentions 'requires elevated permissions', indicating a prerequisite, but lacks explicit when-to-use or when-not-to-use guidance compared to alternatives. It implies usage context but does not list 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 provided, so description carries full burden. It states the operation is a check (read-only), but lacks details on error behavior, permissions, or response format. Adequate for a simple check but could be more informative.

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

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

Single sentence, no redundancy, front-loaded with key verb and object. Every word earns its place.

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

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

Given the tool's simplicity, no output schema, and clear parameters, the description covers the essential input and action. Slightly missing context about return values (e.g., boolean) but not critical.

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 75% with descriptions for 3 of 4 parameters. Description adds context that type is 'vm' or 'lxc', complementing schema enum. Baseline 3; no significant extra meaning 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?

Description clearly states the verb 'Check' and resource 'feature availability for VM/LXC', listing specific features (snapshot, clone, copy) and types (vm, lxc). Distinguishes from sibling tools like proxmox_guest_snapshot which perform the 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?

Implies usage before performing snapshot/clone/copy to check availability, but no explicit when-not or alternative tools mentioned. The purpose is clear but guidance is minimal.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states the tool lists VMs/containers with status, which is transparent about the read operation. However, it omits details like permissions needed, data freshness, pagination, or performance implications. The description is functional but lacks depth.

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

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

A single concise sentence of about 12 words that immediately conveys the purpose. No unnecessary words. Perfect front-loading.

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 listing tool with two optional parameters and no output schema, the description is mostly complete. It could mention whether results are paginated or include additional details, but the core functionality is clear. Missing some contextual completeness for advanced use cases.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add meaning beyond the schema; it mentions 'across the cluster' which schema doesn't, but parameters are already well-documented in schema. No extra semantic value added for the parameters.

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

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

The description 'List all virtual machines and containers across the cluster with their status' uses a specific verb ('List'), identifies the resource ('virtual machines and containers'), specifies scope ('across the cluster'), and mentions output ('status'). It clearly distinguishes from sibling tools like proxmox_guest_status (single guest) and proxmox_guest_config (details).

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

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

The description implies usage for listing all guests, which is clear from context. However, it lacks explicit guidance on when not to use this tool (e.g., for a single guest's details) or mention of alternatives. The context is adequate but not fully 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?

Without annotations, the description partially discloses behavior (requires elevated permissions, migrates to another node) but omits details like online migration, side effects, or async behavior. Schema parameters add some context but are not in the description.

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

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

Single sentence is efficient, front-loads the action and resource, and includes critical context (type requirement and permissions) without extra fluff.

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

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

No output schema is provided, and the description does not explain what the tool returns (e.g., success status, async job ID). For a migration operation, this is a significant gap. Also, with 9 parameters, the description could be more complete.

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

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

Schema description coverage is 89%, so description adds minimal value beyond what's already in the schema. The main description does not elaborate on parameters except for 'type' being mentioned inline.

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 ('Migrate'), the resource ('VM or LXC container'), and distinguishes it from sibling tools like cloning or starting by specifying the required 'type' parameter.

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

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

The description mentions elevated permissions as a prerequisite but does not provide guidance on when to use this tool over alternatives (e.g., clone, move disk). No explicit when-to-use or when-not-to-use info.

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

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

No annotations are provided, so the description carries full burden. It only notes elevated permissions but fails to disclose idempotency, side effects, or failure behavior for add/update/remove operations.

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

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

The description is a single sentence that gets straight to the point, but it could be slightly more structured (e.g., listing actions separately) without losing 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 tool with 12 parameters, no output schema, and no annotations, the description is too sparse. It does not explain return values, error handling, or how parameters combine across different actions and guest types.

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 92%, so most parameters are already explained. The description adds minimal value beyond summarizing action and type, and mentions permissions, but does not elaborate on parameter interactions or constraints.

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 manages guest network interfaces, specifies actions (add/update/remove) and guest types (vm/lxc), and distinguishes it from sibling tools like proxmox_guest_config or proxmox_node_network_iface.

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

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

The description mentions that elevated permissions are required but does not provide when-to-use or when-not-to-use guidance, nor does it compare to alternatives like proxmox_node_network_iface for node-level interfaces.

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 only mentions elevated permissions. It does not disclose important behavioral traits such as state changes (e.g., memory preservation, network disconnection) or side effects, leaving the agent with incomplete understanding.

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

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

The description is a single concise sentence that immediately conveys the core purpose. It is front-loaded and wastes no words, which is ideal for a simple action 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 tool's simplicity and full schema coverage, the description is adequate for basic usage. However, it lacks behavioral details (e.g., what pausing entails) and does not explain return values (no output schema), limiting completeness for nuanced understanding.

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

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

The input schema already provides descriptions for both parameters with 100% coverage. The description adds no additional parameter information, so it meets the baseline expectation.

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 ('Pause') and the resource ('QEMU virtual machine'), and distinguishes it from sibling tools like stop, shutdown, or resume by specifying it's for VMs only.

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 notes that the tool is for VMs only and requires elevated permissions, providing context on when it can be used. However, it does not explicitly compare with alternatives (e.g., when to pause vs stop vs suspend).

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 should explain behavioral traits. It only states the tool gets pending changes but does not disclose that it is a read-only operation, return format, or any prerequisites. Minimal value added beyond the name.

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

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

A single, efficient sentence with no wasted words. Perfectly concise and front-loaded.

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

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

The description lacks details about the return value (e.g., format, structure) and does not mention any output schema. For a tool that retrieves data, this is incomplete.

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

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

Schema coverage is 67% (node and vmid have descriptions, type has enum only). The description does not add new parameter details beyond stating support for VM and LXC, which is already in the schema. Baseline 3 is appropriate as schema does most of the work.

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

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

The description clearly states the action ('Get pending configuration changes') and the resource (VM or LXC container), distinguishing it from sibling tools like proxmox_guest_config which retrieves current configuration.

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

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

The description implies the tool is for viewing unapplied changes, which distinguishes it from other guest tools. However, it does not explicitly state when to use this tool versus alternatives like proxmox_guest_config.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states 'reboot' (a restart) and mentions elevation, but does not describe side effects (e.g., VM unavailability during reboot, graceful vs. forceful) or error conditions.

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

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

A single sentence that immediately conveys the core action and resource types. No redundant words. Front-loaded with the verb 'Reboot', making it efficient for an AI agent to parse.

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

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

Lacks information about return values or behavior after the reboot command. No output schema is provided, so the agent has no indication of what to expect (e.g., success acknowledgment, error messages). Incomplete for a tool with no output schema.

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

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

The description explains the 'type' parameter (VM vs. LXC), which compensates for its missing schema description. Node and vmid are already described in the schema, so the description adds value for the enum parameter. Overall, it enhances understanding beyond the structured input.

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

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

The description clearly states it reboots a VM or LXC container, specifying the resource types. It is distinct from sibling tools like shutdown or stop, though not explicitly contrasted. The verb+resource combination is specific and unambiguous.

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

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

No guidance on when to use this tool versus alternatives like shutdown or stop. Only mentions that elevated permissions are required, which is a prerequisite but not a usage cue. Lacks context on appropriate scenarios.

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

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

With no annotations, description must provide behavioral details. It only mentions 'requires elevated permissions', but lacks info on idempotency, destructiveness, reboot requirements, or hotplug capability.

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

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

Single sentence, front-loaded with verb and resource, no unnecessary words. Every part is essential.

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

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

For a mutation tool without output schema or annotations, description is minimal. It does not explain return values, synchronization, or side effects like reboot, making it under-specified for complex VM operations.

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 80%, so baseline is 3. The description adds no additional parameter meaning beyond what the schema already provides.

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

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

Description clearly states verb 'Resize', resource 'VM/LXC CPU or memory', and includes the type parameter. This effectively distinguishes from disk resize tool (proxmox_guest_disk_resize) and config update.

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?

Description implies usage for CPU or memory resizing, and mentions elevated permissions as a prerequisite. However, it does not explicitly state when to use this tool versus alternatives like disk resize or config update.

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

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

No annotations are provided, so the description carries the burden. It mentions 'requires elevated permissions' and implies the VM must be paused, but lacks details on idempotency, error states (e.g., if VM is not paused), or side effects beyond resuming.

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 action and resource. Every part is necessary and there is no wasted text.

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

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

For a simple resume action with two well-described parameters and no output schema, the description is largely sufficient. However, it could mention expected output or behavior on invalid state, but overall it covers the essential context.

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

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

Schema coverage is 100% with clear descriptions for 'node' and 'vmid'. The tool description does not add any extra meaning beyond the schema, so it meets the baseline of 3.

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

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

The description clearly states the action ('Resume'), the resource ('paused QEMU virtual machine'), and distinguishes it as 'VM only' which differentiates from sibling tools like proxmox_guest_pause or proxmox_guest_start.

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

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

The description notes 'requires elevated permissions' but does not provide explicit when-to-use guidance or compare to alternatives like proxmox_guest_start. The context of resuming a paused VM is implied but not elaborated.

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 burden of behavioral disclosure. It states it returns RRD data, but it does not clarify data freshness, rate limits, handling of missing VMs, or that it is a read-only operation. The description is minimally adequate.

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

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

The description is a single, clear sentence that front-loads the purpose with no extraneous words. It is appropriately concise for a straightforward retrieval 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?

With 5 parameters, no output schema, and no annotations, the description is too sparse. It does not explain the meaning of 'RRD data', how 'timeframe' and 'cf' relate to the returned data, or what format the response will be. An agent would need additional context to invoke this 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 description coverage is high (80%): four of five parameters have descriptions, and the 'type' parameter has an enum limiting values. The description adds little beyond the schema—it confirms 'type' is vm or lxc, but this is already given. Therefore, it meets the baseline but does not significantly enhance understanding.

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

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

The description clearly states the verb 'Get' and the resource 'performance metrics (RRD data)', and explicitly distinguishes between VM and LXC container types (type=vm or type=lxc). This directly differentiates it from sibling tools like proxmox_guest_status or proxmox_guest_config, which focus on different data.

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

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

The description implies the tool is for retrieving performance metrics, but it does not provide explicit guidance on when to use it versus alternatives, nor does it mention when not to use it or any prerequisites. With many sibling tools, more context would be helpful.

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 stand alone. It only states 'gracefully shutdown' and 'requires elevated permissions,' but does not disclose behavior like timeout, success/failure indication, or whether it is synchronous. This is insufficient for an agent to fully understand the tool's behavior.

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

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

The description is a single concise sentence that covers the action, resource types, and permission requirement. No unnecessary words.

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

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

For a simple shutdown action with three parameters and no output schema, the description covers the core functionality. However, it lacks information about return values, error conditions, and whether the shutdown is blocking. It meets minimum adequacy but leaves gaps.

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

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

Schema description coverage is 67% (node and vmid described, type has enum values). The description repeats the enum values ('type=vm or type=lxc') but adds no new meaning beyond the schema. Baseline applies; no extra value.

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

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

The description clearly specifies the action ('gracefully shutdown'), the target resource ('VM (type=vm) or LXC container (type=lxc)'), and a key requirement ('requires elevated permissions'). It distinguishes this tool from sibling tools like proxmox_guest_stop (likely forceful) and proxmox_guest_reboot.

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 (for graceful shutdown) but does not explicitly state when not to use or mention alternatives. It hints at elevated permissions but lacks direct comparison to sibling tools like proxmox_guest_stop for forceful shutdown.

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 covers the basic actions and permission requirement. It lacks details on behavioral traits like rollback impact or deletion effects, leaving some transparency gaps.

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 purpose and key constraints. No redundant or unnecessary information.

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

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

Despite the tool complexity (4 actions, 6 parameters) and no output schema, the description is minimal. It covers purpose and permissions but omits details like action usage or snapshot naming conventions, making it adequate but not 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 83%, so parameters are well-documented. The description adds no new meaning beyond the schema; it only reiterates the actions and guest types, thus meeting the baseline.

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 manages guest snapshots for VMs and LXC containers, listing the specific actions (create, list, rollback, delete). It distinguishes from siblings like proxmox_backup by focusing solely on snapshot operations.

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

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

The description mentions 'requires elevated permissions', providing a usage prerequisite. However, it does not specify when to use this tool over alternatives (e.g., proxmox_backup) or when not to use it, resulting in limited 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 provided, so the description must carry the full burden. It only notes that elevated permissions are needed. It does not disclose idempotency, side effects (e.g., if already running), or whether the operation is synchronous.

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 15 words, conveying essential information without fluff. It is front-loaded and efficient.

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

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

With three required parameters and no output schema or annotations, the description should provide more context: e.g., return behavior, error conditions, or prerequisites beyond permissions. It is insufficient for a tool that mutates system state.

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

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

Schema description coverage is 67%, so baseline is 3. The description adds no new meaning beyond the schema: 'type' enum is already listed, and node/vmid descriptions are in the schema. The description only restates what's in the parameter names.

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

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

The description clearly states the verb 'Start' and specifies both resource types (VM and LXC). It distinguishes this from sibling tools like stop, shutdown, resume, etc., by the action and type.

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

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

The description implies usage for starting a guest that is stopped, but does not explicitly state when to use this vs. alternatives like resume. It mentions 'requires elevated permissions' but offers no exclusion criteria or context.

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

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

With no annotations, the description provides some behavioral context: it is forceful, requires elevated permissions, and affects VMs/containers. But it omits potential consequences like data loss or whether the operation is synchronous.

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 front-loaded with the core action, including essential context (type and permissions). No extraneous 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 tool with no output schema and three parameters, the description covers the primary action and requirement. However, it lacks details on operation effects, error conditions, or return values, which would be helpful for a complete understanding.

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

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

The input schema already describes node and vmid concisely; the description adds the purpose of the 'type' parameter. With 67% schema coverage, the description does not provide additional meaning beyond what the schema offers, meeting baseline.

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 forcefully stops a VM or LXC container, specifying the action (forcefully stop), target types (vm/lxc), and a prerequisite (elevated permissions). This distinguishes it from graceful shutdown tools among siblings.

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

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

The description hints at usage by noting 'forcefully' and 'requires elevated permissions', suggesting it is for emergency stops or when graceful methods fail. However, it could explicitly mention when to use instead of proxmox_guest_shutdown or proxmox_guest_pause.

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 convey behavioral traits. It fails to disclose that converting a VM to a template modifies the original VM in-place (destructive) or that the VM must be stopped. The agent may incorrectly assume a copy is created.

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 is front-loaded. However, it could afford to include additional critical details (like requiring the VM to be stopped) without becoming overly long.

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

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

Given the lack of annotations and output schema, the description is insufficient. It omits prerequisites (e.g., VM must be stopped), behavior (in-place conversion), and success/failure indicators, leaving key gaps for the agent.

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

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

Schema coverage is 67%: node and vmid have descriptions, type does not. The description adds value by clarifying the type parameter ('type=vm|lxc'), but does not enhance understanding of node or vmid beyond schema.

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

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

The description clearly states the action ('Convert') and the specific resource ('VM or LXC container to a template'), including the type parameter hint. It distinguishes this tool from siblings like proxmox_guest_clone, which is for cloning, not converting to template.

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

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

The description mentions a prerequisite ('requires elevated permissions') but does not provide explicit guidance on when to use this tool versus alternatives like proxmox_create_vm or proxmox_guest_clone. Usage context is implied but not explicitly 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 notes that create, update, delete are 'elevated', indicating permission requirements. However, it lacks details on side effects or other behavioral traits.

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

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

The description is concise, but the pipe-separated list format is slightly cluttered. It efficiently conveys the purpose and actions.

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

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

The description covers actions but does not explain parameter-action relationships or usage context. For a tool with 9 parameters, more guidance would be beneficial.

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

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

Schema description coverage is high (89%), so baseline is 3. The description does not add any additional parameter semantics beyond what the schema already provides.

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

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

The description clearly states it manages HA groups and enumerates specific actions (list, get, create, update, delete). This distinguishes it from sibling tools like proxmox_ha_resource.

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

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

No explicit guidance on when to use this tool vs alternatives; usage is implied through the listed actions but without comparisons to sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the execution method but does not explain whether the command runs synchronously, what happens on failure, or what the tool returns (e.g., stdout/stderr). The timeout parameter is mentioned in the schema but not highlighted in the description. Important behavioral traits are missing.

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

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

The description is a single sentence that efficiently conveys the core purpose and a key prerequisite. It is front-loaded with the action and method. However, it could be slightly more structured (e.g., separate prerequisite line), but overall it is concise without unnecessary words.

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

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

Given the tool's complexity (executing commands inside a container) and the absence of an output schema, the description should at least mention the return value (e.g., command output, exit code). It also lacks explanation of the 'elevated' requirement. The description is incomplete for an execution tool, leaving agents to guess expected behavior.

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

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

The input schema has 100% coverage for all 4 parameters, providing descriptions for each. The tool description adds no additional meaning beyond what the schema already provides. For example, it does not explain that 'command' should be a valid shell command or how to handle special characters. Baseline score of 3 is appropriate.

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

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

The description clearly states the action: 'Execute a command inside an LXC container'. It specifies the method (SSH + pct exec) and distinguishes from sibling tools like proxmox_agent_exec (which targets VMs, not containers). The verb 'Execute' combined with the resource 'LXC container' 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 implies usage for running commands inside an LXC container but does not explicitly state when to use this tool versus alternatives like proxmox_agent_exec or others. It mentions prerequisites (elevated + PROXMOX_SSH_ENABLED=true), which provides some usage context, but lacks explicit when-to-use or when-not-to-use 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 provided, so description must disclose behavioral traits. It mentions 'all elevated' hinting at elevated privileges but does not explain whether actions are destructive, require container state changes, or have side effects.

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

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

Very concise; the description fits in one sentence plus a concise mapping of actions. It is front-loaded with the resource and action enumeration.

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 good schema coverage, the description lacks details on prerequisites (e.g., container stopped), risk level, or return value. For a tool modifying LXC configuration, this is insufficient.

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

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

Schema description coverage is high (83%), and the description adds minimal context by mapping action values to their effects. The param descriptions in the schema already provide adequate meaning.

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 manages LXC mount points, with explicit actions 'add' and 'remove'. It distinguishes itself from sibling tools like proxmox_guest_disk_move by focusing on mount points.

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

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

No guidance on when to use this tool versus alternatives such as proxmox_guest_disk_move or proxmox_storage_content. The description only lists actions without context on prerequisites or constraints.

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

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

With no annotations, the description carries full burden. It only hints at elevated permissions but does not disclose whether the operations are synchronous, destructive, or how failures are handled. The behavioral impact of bulk operations is largely underspecified.

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 sentences, front-loading the purpose and actions. Every word adds value, and there is no redundancy or unnecessary detail.

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

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

Given the complexity of bulk operations (5 parameters, no output schema, no annotations), the description is incomplete. It lacks information about return values, error handling, concurrency implications, and the exact scope of 'all' guests. Users need more context to use this tool safely.

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

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

The schema already covers 80% of parameters with descriptions. The description repeats the action enum values, adding marginal value. It does not elaborate on the meaning or interaction of parameters like 'target' or 'with-local-disks' beyond what the schema provides.

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

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

The description clearly states it performs bulk guest operations with specific actions (start_all, stop_all, migrate_all). It distinguishes from sibling tools like proxmox_guest_start/stop/migrate which operate on individual guests, though it could be more explicit that it applies to all guests on the node.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as elevated permissions implied by 'all elevated', or scenarios where single operations are preferred. Missing context for effective tool selection.

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

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

No annotations are provided, so the description must fully convey behavioral traits. It only states 'Query node disk information' and lists actions, implying read-only operations, but does not disclose performance implications, safety (e.g., whether SMART checks are destructive), or any side effects. The lack of detail 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 extremely concise—one sentence plus a list—with no wasted words. It is front-loaded with the purpose, making it efficient for quick scanning.

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

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

Given the tool's complexity (7 parameters, 2 required, no output schema), the description is far too sparse. It does not explain return values, how different actions work, or how to effectively use parameters like disk or type. For a multi-action node disk query tool, this is inadequate.

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 86%, so the schema already documents most parameters. The description repeats the action enum values, adding no new meaning. It does not explain relationships between parameters (e.g., disk requirement for smart action). Thus, 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 clearly states 'Query node disk information' and lists the possible actions (list, smart, lvm, etc.), specifying the verb and resource. However, it does not explicitly differentiate from the sibling tool 'proxmox_node_disk_admin', which likely handles administrative operations, leaving some ambiguity.

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 alternative disk-related tools (e.g., proxmox_node_disk_admin, proxmox_vm_disk). It does not specify prerequisites, context, or exclusions, leaving the agent without decision support.

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

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

Without annotations, the description carries the full burden for behavioral transparency. It labels operations as 'Destructive' but fails to elaborate on specific implications: data loss, irreversibility, permission requirements, or side effects. More detail is needed for such high-risk actions.

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

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

The description is extremely concise: a single sentence followed by a clear mapping of actions to meanings. Every phrase earns its place, 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 destructive tool with no output schema and no annotations, the description is lacking. It does not mention return values, error conditions, or side effects, leaving the agent without sufficient context for safe invocation.

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

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

Schema description coverage is 75%, with the action parameter lacking description. The tool description compensates by listing and explaining the two enum values, adding crucial semantics beyond the schema. Node and disk are already described in the schema.

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

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

The description clearly states 'Destructive disk operations' and enumerates the two actions (init_gpt, wipe) with brief explanations, directly indicating the tool's purpose. It distinguishes from sibling tools like proxmox_node_disk (likely read-only) and proxmox_vm_disk (VM-level).

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

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

No usage guidelines are provided. The description does not indicate when to use this tool over alternatives, nor does it mention prerequisites (e.g., disk unmounted) or post-conditions. Such guidance is especially important for destructive operations.

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

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

No annotations are provided, so the description carries full burden. It does not disclose that the tool is read-only, what happens on invalid parameters, or authentication requirements. The description only states 'query', which implies read-only, but lacks explicit behavioral traits.

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

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

The description is a single sentence with a clear purpose and a well-structured list of actions. No wasted words; every part is informative and front-loaded.

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

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

Despite having 5 parameters and multiple actions, the description does not explain return values, required parameter combinations (e.g., storage for storage_rrddata), or error behavior. The lack of output schema means the description should provide more context, but it is insufficient.

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

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

Schema coverage is high (80%), and the description adds essential meaning for the 'action' parameter by enumerating each action and its data type. For other parameters, schema descriptions are sufficient. The description compensates for the missing schema description on 'action'.

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 'Query node information' and lists specific actions (aplinfo, netstat, etc.) that distinguish it from sibling tools like proxmox_node_config (which modifies config) or proxmox_node_disk (disk operations). It provides a specific verb and resource with scope.

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 lists actions but does not provide guidance on when to use this tool versus alternatives (e.g., proxmox_node_network_iface for network interface management). No when-not or alternative tools are mentioned, leaving the agent without context for selection.

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

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

No annotations provided; description only says 'Read node logs' without detailing side effects, permissions, rate limits, or output format, leaving the agent uninformed.

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

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

Extremely concise single sentence with clear structure: action-value pairs for the key 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?

Lacks details on output, pagination, filtering, or prerequisites; minimal for a 2-param tool with no output schema or annotations.

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

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

Adds meaning by mapping 'action' enum values to log sources (syslog/journal), which is not explained in the input schema (50% coverage).

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

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

The description clearly states it reads node logs and distinguishes between syslog and journal actions with explicit mappings.

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

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

No explicit guidance on when to use this tool vs alternatives or which log action is appropriate; usage is implied by the action 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?

The description notes that all actions are 'elevated', indicating required privileges, but does not elaborate on whether shutdown is graceful/forced, reboot behavior, or wakeonlan prerequisites. No annotations exist to supplement.

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 to the point, but could be better structured (e.g., bullet list) without losing brevity. No waste, but slightly too 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?

For a power control tool with no output schema, the description lacks details on how actions are performed (ACPI, WoL), error conditions, or return values. Minimal completeness given the tool's critical nature.

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

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

Schema coverage is 50% (node has description, action does not). The description only repeats the enum values without explaining each action's effect, and adds no detail on the node parameter beyond the schema.

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

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

The description explicitly states 'Node power control' and lists the three actions (shutdown, reboot, wakeonlan), clearly identifying the tool's purpose and distinguishing it from guest power control siblings.

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

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

The description does not explicitly state when to use this tool versus alternatives like proxmox_guest_shutdown, but the domain is implied by 'Node' and the sibling tools provide context. Lacks explicit when/when-not guidance.

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