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

Annotations already indicate this is a mutating (non-read-only), non-idempotent operation. The description adds meaningful behavioral context by highlighting the monetary consequence and the mandatory confirm flag. This exceeds annotation coverage without contradicting it.

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

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

Two compact sentences with the primary action, the critical behavioral warning, and the alternative routing. Every clause adds value and the most important information is front-loaded.

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

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

For a straightforward disk-addition tool with three parameters and no output schema, the description covers all key agent decisions: action, financial warning, confirmation flow, and sibling differentiation. It doesn't mention edge cases like existing disk size limits, but those would presumably be validated at runtime; the core invocation guidance is 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?

With 0% schema description coverage, the description properly compensates: it clarifies size is in GB, that vps_id refers to the target VPS ('directly to this VPS'), and that confirm must be true. Each parameter is given practical meaning beyond the raw schema.

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

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

The description states a specific action ('Add a new disk') and resource ('to this VPS') with the size in GB. It also distinguishes itself from the sibling purchase_volume by explicitly naming what it is not, 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?

It clearly directs the agent to purchase_volume when a standalone, independently-manageable volume is needed instead. It also instructs that the confirm=true parameter is required because the operation spends real money, giving explicit usage conditions.

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

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

Beyond the annotations (which only indicate it is not read-only, not open-world, not idempotent, and not destructive), the description discloses the most important behavioral trait: 'Spends real money — requires confirm=true.' This financial side effect is critical for an agent deciding whether to invoke the tool and provides context the annotations do not.

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

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

Three sentences, each earning its place: the action, the financial/confirmation warning, and the sibling routing. Information is front-loaded and there is no redundant text or restatement of the tool name.

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 financial mutation with two parameters and no output schema, the description covers the core essentials: what it does, the prerequisite (confirm=true), and the alternative path. An agent can correctly invoke this tool and avoid misuse without additional information.

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

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

Schema coverage is 0%, so the description carries the burden of explaining parameters. It clarifies that confirm must be true for the purchase to execute, which adds meaning to the boolean parameter. The vps_id is implied by 'this VPS' in the description, but no formatting or source information is provided; still, enough is conveyed for correct invocation.

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

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

The description begins with a specific verb phrase: 'Purchase and attach a brand-new IP address directly to this VPS.' This states the exact action and resource, and the adjective 'brand-new' distinguishes it from attaching an existing IP via attach_ip. The purpose is unmistakable 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 explicitly names the alternative for a different use case: 'To attach an IP you already own instead, see attach_ip.' It also tells the agent that confirm=true is required, establishing the precondition for using this tool. This is clear routing guidance.

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

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

Annotations already indicate this is a non-read-only, non-destructive mutation. The description adds useful behavioral context by stating 'Requires confirm=true' and the same-region limitation, which go beyond the schema. It does not describe effects like what happens if the IP is already attached, but with annotations present the description adds moderate value.

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

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

Two short sentences, front-loaded with the action and resource, with the operational constraint and confirmation requirement stated clearly. There is no filler or redundant repetition of schema fields.

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

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

The description covers the core operation, the region restriction, and the confirmation flag, which is enough for a minimal understanding. However, with no output schema and sparse annotations, it omits what a successful attachment returns, how IDs are obtained, and what prerequisites or failure cases apply. 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 description coverage is 0%, so the description must compensate, but it only explicitly clarifies 'confirm=true'. It does not explain the meaning or format of ip_id and vps_id beyond the schema's weak 'Ip Id' and 'Vps Id' titles. While inferable from context, this is insufficient semantic enrichment for a low-coverage 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 'attach' and the resource 'standalone IP address to a VPS', with the important 'same region' constraint. It does not explicitly differentiate itself from similar sibling tools like add_ip_to_vps or detach_ip, but the specific standalone-IP framing makes the purpose understandable.

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

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

No guidance is given about when to use this tool versus alternatives such as add_ip_to_vps, detach_ip, or list_attachable_ips_for_vps. The 'same region' constraint and confirm requirement are usage preconditions, not selection guidance, so an agent gets no help choosing among related IP 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?

Annotations (readOnlyHint=false, destructiveHint=false) only signal non-readonly status, which is weak. The description adds real value by disclosing the operation is asynchronous and telling the agent to poll get_volume_task_status. It could go further by noting what a successful attach looks like or how failure is surfaced, but the async disclosure is genuinely useful.

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

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

Three tight sentences with zero waste. The core action is front-loaded, followed by the mandatory precondition and the async behavior. Every sentence earns its place.

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

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

For a mutation with no output schema and minimal annotations, the description covers the critical operational facts: scope (same region), required confirm flag, and async polling behavior. It is slightly incomplete on what the agent should check when polling to confirm success and what the immediate response looks like, but these are minor gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to the confirm parameter by stating confirm=true is required, which is the only non-obvious parameter. However, volume_id and vps_id are left self-evident and no additional context (e.g., that the volume must not already be attached) is provided for them.

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

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

States a specific verb (attach), the resource (standalone volume), and the target (VPS) with useful qualifiers ('same region'). This clearly differentiates it from sibling tools like detach_volume and makes its scope obvious without opening the schema.

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

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

Provides the confirm=true precondition and instructs the agent to poll get_volume_task_status afterward, which is helpful operational guidance. However, it never says when to choose this tool over alternatives (e.g., when a volume should be attached vs. installed-with-OS) or mentions prerequisites like checking list_attachable_vps_for_volume first.

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

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

Despite the annotations only saying readOnly=false, destructive=false, etc., the description discloses the real side effect: it rewrites files on the offline disk image and is unsafe on a running VPS. It also surfaces the mandatory confirm=true guard. No contradiction with annotations.

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

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

Two dense sentences: main action up front, then the critical precondition and confirmation requirement. No filler or repeated schema 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 three-parameter mutation with no output schema, the definition supplies the core operation, the prerequisite, the safety rationale, the first-to-call sibling, and the guard flag. Nothing needed to invoke it correctly 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?

With 0% schema description coverage, the description must carry parameter meaning. It does for the two key ones: hostname is what is being changed and confirm must be true despite the schema default of false. It does not explicitly describe vps_id, but its role is clear from 'a VPS's' and 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 opens with 'Change a VPS's hostname,' a specific verb+resource statement that exactly identifies the operation and distinguishes it from sibling mutations like change_vps_root_password or resize_vps. It goes beyond the tool name by adding the offline-disk-image context.

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

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

It explicitly states the prerequisite ('The VPS must already be stopped'), explains why (rewrites files on the offline disk image), and names the tool to call first ('stop it first with stop_vps'). This is clear when-to-use guidance and a concrete alternative.

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

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

Annotations already indicate this is a mutating operation (readOnlyHint=false), so the description doesn't need to state that. It adds useful behavioral context (VPS must be stopped) and the confirm requirement, which goes beyond annotations. However, it does not disclose post-change behavior (e.g., whether the VPS needs a restart or how the change affects existing sessions), so transparency is limited.

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, front-loaded with the action. The prerequisite and confirm requirement are stated efficiently with zero redundancy. Every word 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?

The description references 'same reason as change_vps_hostname' without providing that reason, forcing the agent to look elsewhere for context. It also lacks information about what happens after the password change (e.g., whether a reboot is needed, how the password is applied). For a mutating tool with no output schema, these gaps make the description incomplete 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?

With 0% schema coverage, the description must compensate. It clarifies that new_password is the root/administrator password and explicitly states that confirm must be true. It does not provide password constraints (length, complexity) or explain the purpose of confirm beyond the requirement. Given the self-evident vps_id, this adds moderate value but is not comprehensive.

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 ('Change a VPS's root/administrator password') with a specific resource and target. It distinguishes itself from the sibling change_vps_hostname by referencing that tool, implying a different operation while sharing a prerequisite. The 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?

It states a key usage precondition: 'The VPS must already be stopped'. It also specifies that confirm=true is required, which is a direct invocation guideline. It does not explicitly outline when not to use the tool or alternative tools, but it gives enough context for correct usage in most 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?

Annotations already cover readOnlyHint=true and idempotentHint=true. The description adds value by disclosing the real-time nature ("right now") and the return content (count + price), giving the agent an accurate expectation of 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?

A single sentence front-loads the purpose (count and price) and includes the necessary source of the parameter. No filler, though it could arguably be split into two sentences for readability; still very concise.

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

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

For a one-parameter read-only tool with no output schema, the description covers the parameter source, the query scope, and the expected result shape. It is complete enough for an agent to invoke it correctly without further inference.

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

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

Schema coverage is 0%, so the description must carry the parameter semantics. It does: pop is clearly defined as a Point of Presence id obtained from list_regions, which is the only essential guidance for correct invocation.

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

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

The description states exactly what the tool does: reports how many standalone IPs can be purchased in a given region and the current price. This distinguishes it from purchase_ip, list_ip_addresses, and other IP-related siblings without 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 makes the use case clear: checking purchase availability and price before buying. It also instructs the agent to obtain the pop from list_regions. It stops short of naming alternatives or exclusions, so it gets 4 rather than 5.

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

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

The description adds useful behavior beyond the annotations: confirm=true is mandatory, and ssh_key must be public key material, never a private key. Given the annotations only provide common mutation flags, this is meaningful context, though it stops short of discussing auth, rate limits, or result 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 compact and front-loaded: purpose first, usage connection second, then critical parameter constraints. Every sentence adds necessary value with no filler.

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

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

For a 3-parameter mutation tool with no output schema, the description gives enough orientation to use it safely: purpose, connection to create_vps, confirm requirement, and key material type. It does not mention return values, but this is not a major omission for such a focused 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?

With 0% schema description coverage, the description compensates by explaining a key fact for two of the three parameters: ssh_key must be public key material and confirm must be true. The title parameter is not described, leaving a gap, but the most safety/problem-prone parameters are clarified.

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

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

The description uses a clear action verb ('Save') with a specific resource ('SSH public key to this account') and connects it to a concrete use case ('installing onto future VPS instances via create_vps's own ssh_key parameter'). This distinguishes it from sibling tools like list_ssh_keys and delete_ssh_key.

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

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

The description states exactly when the tool is relevant: when the agent needs to store an SSH key for later use with create_vps. It also gives a clear precondition ('Requires confirm=true'). It does not explicitly name alternatives/exclusions, but the use case is specific enough to guide 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?

Annotations already declare readOnlyHint=false, so the write nature is known. The description adds no extra behavioral details like side effects (e.g., notifications, response format) beyond the action itself. It doesn't contradict annotations but also doesn't enrich them.

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

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

Two sentences with no waste. The purpose is front-loaded, and the parameter clarifications are given in the second sentence. The structure is efficient and easy to scan.

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 all required parameters implicitly (subject, message, department_id are not explained but are obvious) and explains the ambiguous ones (priority, vps_id). It doesn't mention how to obtain department_id, but the sibling list_ticket_departments provides that context. Adequate for correct invocation.

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

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

With 0% schema description coverage, the description must compensate. It explains priority values and vps_id's purpose (linking to a VPS from list_vps), but does not explain department_id, which is required. Subject and message are self-explanatory. Partial compensation for the missing schema descriptions.

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

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

The description states 'Open a new support ticket with an opening message,' a specific verb+resource combination that clearly distinguishes it from sibling tools like list_tickets and reply_to_ticket. It also mentions optional VPS linking, further clarifying its unique role.

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 opening a new ticket, which is unambiguous. It doesn't explicitly mention alternatives or conditions when not to use it, but the purpose is so distinct among siblings that the context is clear. No exclusions are stated, but none are needed.

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?

Given annotations provide no hints beyond readOnlyHint=false, the description fully carries behavior disclosure. It clearly warns that the tool spends real money, requires confirm=true, provisions asynchronously (returns immediately with id and is_building=true), and explains the exact cost formula including the often-forgotten IP price. It also notes that invalid core/ram/disk values will be rejected with an allowed-value list.

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?

Although long, the description is tightly structured with clear sections for boot disk, IP address, and cost. Every sentence conveys necessary information, and critical warnings are front-loaded. The length is justified by the tool's complexity, and no words are wasted.

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

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

The description is complete for a tool with 12 interdependent parameters, no schema descriptions, and no output schema. It covers all parameters, the asynchronous nature, the cost calculation, and points to the relevant lookup tools. An agent has everything needed to invoke it correctly and 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?

With 0% schema description coverage, the description does all the work for all 12 parameters. It explains each parameter in detail, including mutually exclusive groups (boot disk and IP address), default behaviors, which parameters are ignored in certain cases, and which values come from other tools. This goes far beyond what the schema alone 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 opens with 'Deploy a new VPS', a specific verb and resource. It clearly distinguishes this from sibling tools like start_vps (which starts an existing VPS) and destroy_vps, making the purpose unmistakable.

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

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

The description explicitly states when to call this tool (only after telling the user what will be provisioned and estimated cost) and provides detailed preconditions, such as checking whether existing_ip or existing_boot_volume are already attached. It also names specific lookup tools (list_regions, list_ssh_keys) to acquire required IDs, leaving no ambiguity about prerequisites.

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

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

Beyond annotations, the description adds meaningful behavioral facts: the action may incur a cost and requires confirm=true. It does not discuss whether the backup is created asynchronously or what the full side effects are, but the cost and confirmation guard are valuable additions.

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

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

Two short sentences, front-loaded with the action and immediately followed by the two most important conditions: cost check and confirmation. No filler or repetition.

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

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

For a two-parameter creation tool, the description covers the core call conditions: target VPS, confirmation flag, and cost risk. It does not describe the response or return value, but no output schema exists and an agent has enough to invoke it correctly.

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

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

With 0% schema description coverage, the description has to compensate. It explains confirm ('Requires confirm=true') and implies vps_id via 'this VPS', but it does not describe the expected value, format, or source of vps_id. This is partial compensation rather than full documentation.

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

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

Description uses a specific verb ('Take') and resource ('a new backup of this VPS'), making the creation intent clear. It does not explicitly contrast with sibling backup operations like list_vps_backups or restore_vps_backup, but 'new backup' is enough to distinguish 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?

It gives actionable guidance to check get_vps_backup_cost first because the operation may incur cost, and it states the confirmation requirement. It does not explicitly list when not to use the tool or name alternatives, but the cost-check sequence is clear usage context.

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

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

Annotations already indicate destructiveHint=true, but the description adds critical behavioral details: irreversibility, requirement for confirm=true, and the scope of impact (doesn't affect existing VPS installs). This goes beyond the annotation and is essential 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?

Three concise sentences. The primary action is front-loaded, followed by essential caveats. No redundant wording or valuable space wasted.

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

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

For a tool with 2 parameters and no output schema, the description covers the purpose, irreversible nature, confirm requirement, and behavior regarding existing VPS instances. Nothing critical is missing for an agent to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly explains the confirm parameter ('requires confirm=true'), which is non-obvious. The ssh_key_id parameter is self-explanatory from its name. This adequately covers the parameters given the low schema coverage.

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

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

The description states a specific verb ('delete'), a specific resource ('saved SSH key'), and the scope ('from this account'). It clearly distinguishes from sibling tools like create_ssh_key and list_ssh_keys by naming the action and object.

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 conveys the usage context by stating it is for permanent deletion and notes that it does not affect VPS instances already installed, only future deploys. However, it does not explicitly name alternative tools or provide 'when not to use' guidance, though siblings are self-evident.

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

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

Adds behavioral context beyond the destructiveHint=true annotation by disclosing that the delete is permanent/irreversible and guarded by confirm=true. No contradiction with annotations.

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

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

One sentence with zero filler. The action and consequence are front-loaded, and the confirm requirement is stated compactly.

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

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

For a simple delete tool with annotations, the description covers the action, permanence, and confirmation guard. It omits response or error details, but no output schema exists and the operation is straightforward.

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

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

With 0% schema description coverage, the description partially compensates by explaining that confirm must be true to execute the deletion. vps_id and backup_id are only implied via 'this VPS' and 'one backup', and their names already carry most of the 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?

States a specific verb ('Permanently delete') and resource ('one backup of this VPS'), making the action unambiguous. It clearly distinguishes from sibling tools like create_vps_backup, restore_vps_backup, and list_vps_backups.

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

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

The usage context is implied: use this to delete a single backup. It provides one clear condition, 'requires confirm=true', but does not explicitly name alternatives or state when to prefer list_vps_backups or restore_vps_backup.

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

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

Annotations already declare destructiveHint=true, but the description adds significant behavioral context: it states the operation is irreversible, requires confirm=true, and explains the nuanced behavior of release_ip_ids/release_disk_ids (releasing vs. detaching). This goes beyond what annotations provide and clarifies side effects on attached resources, making the tool's behavior transparent.

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 front-loaded with the core action, then adds the irreversibility note and optional parameter behavior. It is dense but not overly long, and each sentence adds value. The structure is logical: main action, safety warning, then parameter details. It could be slightly more concise, but it is well-organized.

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

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

For a destructive operation with optional parameters, the description covers the essential context: default boot disk destruction, confirm requirement, and the release vs. detach distinction. It also points to list_vps for ID retrieval. While it does not mention output or any post-destroy effects, the absence of an output schema makes that less critical. It is sufficiently complete for an agent to call correctly.

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

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

The schema provides no parameter descriptions (0% coverage), so the description carries the burden. It explains the confirm flag (required for destruction) and details the release_ip_ids/release_disk_ids behavior, including their default (kept, unreleased) and how to obtain IDs via list_vps. vps_id is implicitly understood from context. This effectively compensates for the schema gap.

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

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

The description clearly states the action: 'Permanently destroy a VPS and, by default, its boot disk.' This specifies a verb (destroy), a resource (VPS), and a critical default (boot disk), distinguishing it from sibling operations like stop_vps or poweroff_vps. The irreversibility is also flagged, leaving no ambiguity about the tool's purpose.

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

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

The description does not explicitly state when to use this tool versus alternatives (e.g., stop_vps for a graceful shutdown). However, it implies usage by noting the irreversible nature and the confirm requirement. It does reference list_vps for obtaining IP/disk IDs, which is a helpful prerequisite, but it lacks a clear when-not-to-use or alternative routing.

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

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

Beyond the annotations, the description adds meaningful side-effect context: the IP is kept and not released, and the operation requires explicit confirmation. This gives the agent important operational expectations without contradicting any annotation.

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 zero filler. The key behavioral note '(kept, not released)' and the confirmation requirement are both packed in without unnecessary details.

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

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

For a simple two-parameter tool with no output schema, the description communicates the operation, the important confirm requirement, and the result semantics. It could be slightly more complete if it addressed behavior when the IP is not currently attached or explicitly pointed to release_ip, but it is sufficient for correct invocation.

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

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

Schema coverage is 0%, so the description must compensate. It adds value by specifying that confirm must be true, and contextually clarifies that ip_id refers to a standalone IP. However, ip_id is not described with full precision, and the description leans mostly on the parameter name plus tool name.

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

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

The description clearly states the verb ('Detach'), the resource ('a standalone IP address'), and the behavioral scope ('from whatever VPS it's currently attached to'). It also distinguishes the operation from releasing by adding '(kept, not released)', so the tool's 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 conveys a clear usage context: use it to detach an attached standalone IP while retaining it. It also gives an implicit exclusion by emphasizing 'kept, not released', though it does not explicitly name release_ip as the alternative or state when not to call the 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?

Beyond the annotations, the description discloses that the operation is non-destructive (volume kept, not released), requires explicit confirmation, and is asynchronous with a status-checking follow-up. This adds meaningful context for an agent deciding whether and how to invoke the 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?

Two tight sentences deliver the essential facts: what happens, what doesn't happen, the required flag, and the async polling step. No filler or redundancy.

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

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

The description is sufficient for an agent to invoke detach_volume correctly: it identifies the resource, the required confirmation, the async nature, and where to check completion. No output schema exists, but the description gives the needed follow-up mechanism.

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

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

With 0% schema description coverage, the description must carry param meaning. It explains that confirm=true is required and that the volume is detached but kept; however, it does not add much detail on volume_id beyond the schema's property title.

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

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

The description states a specific verb ('Detach') and resource ('standalone volume'), and clarifies the operation's scope: detaching from whatever VPS it's attached to while keeping the volume on the account. This clearly distinguishes it from sibling tools like release_volume and attach_volume.

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 gives explicit usage conditions: confirm=true is requiredchers, and the operation is asynchronous, directing the agent to poll get_volume_task_status. It also differentiates from release by noting the volume is kept, not released, though it doesn't explicitly name the alternative 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?

Annotations already declare readOnlyHint and idempotentHint, but the description adds important behavioral context: the output is CSV, ids narrows to specific row ids rather than exporting everything, and the invoices category cannot be returned as text because it is a zip archive. That is meaningful, non-contradictory detail beyond the structured fields.

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 compact and well ordered: first the main action, then the category requirement, then the optional ids parameter, then a short caveat about invoices. Every sentence serves a distinct purpose and there is no filler.

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

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

With only two parameters and an output schema present, the description covers all needed call decisions: required category values, optional ids behavior, and the one category that should not be handled by this tool. An agent has enough information to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must carry the parameter meaning, and it does. It gives exact allowed category values and explains when ids is valid and what it does, which is far more than the empty schema properties provide.

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 a specific action and resource: 'Export a copy of this account's own data as CSV' and immediately constrains it to 'one category at a time'. It then enumerates the categories, making it easy to distinguish from sibling list/get/create tools, which do not export.

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 clearly says when to use the tool: when a category-scoped CSV export of account data is needed. It also gives a when-not by explaining that the 'invoices' category is a zip archive on the real dashboard and should be downloaded from the dashboard's Export Data page instead, an explicit exclusion.

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

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

Annotations already mark the tool as read-only and idempotent, which covers the main safety behavior. The description adds response content (balance, currency, profile fields) but no deeper behavioral context such as data freshness, authentication requirements, or error behavior. This is acceptable but adds limited value beyond the annotations.

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

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

The description is a single compact fragment with no filler. It front-loads the main purpose and lists the returned data in a way that is easy to scan. Every word contributes meaning.

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

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

For a zero-parameter, read-only, idempotent getter, the description is complete: it names exactly what the agent will receive and requires no further setup or preconditions. The absence of an output schema is compensated by listing the return fields directly.

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 no parametersebb, and schema description coverage is 100%, so the baseline is 4. The description usefully scopes the operation to 'this account', clarifying that no account identifier is needed and the tool acts on the authenticated/current account.

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 identifies the resource: the current account's wallet balance, currency, and basic profile. It lacks an explicit verb like 'retrieves', but the tool name and 'current' make the read operation obvious. It is specific enough to stand apart from account-adjacent siblings like get_quota or list_transactions.

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: call this when you need the current account's wallet balance and basic profile. However, it does not explicitly state when not to use it or mention any alternative tools, even though related billing and transaction tools exist.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds scope (account-wide vs per-VPS) but does not disclose other behavioral traits like return format, time range, or aggregation method. With annotations covering the key traits, a 3 is appropriate.

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

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

A single, front-loaded sentence that contains no filler. Every word contributes meaning, and the key scoping detail is placed at the start.

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

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

For a zero-parameter read-only tool with annotations covering safety, this description is complete. It tells exactly what the tool does and its scope. No output schema exists, so the description does not need to detail return fields; 'overview' is sufficiently self-explanatory.

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

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

The tool has zero parameters, so a baseline of 4 is appropriate. The description adds nothing about parameters (there are none) and the schema already fully covers this (100% 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?

States a specific verb ('get'), resource ('bandwidth usage overview'), and scope ('Account-wide... across every VPS'). This clearly distinguishes it from per-VPS tools like get_vps_bandwidth_history and get_vps_stats without needing to open schemas.

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

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

The phrase 'Account-wide... across every VPS' gives clear context that this is for aggregate usage, implying it is not for per-VPS queries. However, it does not explicitly name alternative tools or exclusion conditions, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe read operation. The description adds 'full detail' and 'standalone' context, which clarifies scope but doesn't disclose return format, pagination, or error behavior. With annotations covering the safety profile, a 3 is appropriate.

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

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

One sentence, zero waste, and the key scoping terms ('full detail', 'standalone', 'by its id') are front-loaded. Every word earns its place.

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

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

For a simple single-parameter read tool with annotations covering safety, the description is mostly adequate. However, it doesn't clarify what 'full detail' includes (e.g., attached VPS, reverse DNS, region) or how it differs from get_vps or get_volume. Given the large sibling set, a bit more context would help.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'by its id' which maps to the ip_id parameter, but adds no format, source, or validation details. The parameter name ip_id is self-explanatory, so the description provides minimal added meaning beyond the schema.

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

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

The description states a specific verb ('Get'), resource ('one standalone IP address'), and the selection criterion ('by its id'). It clearly distinguishes from list_ip_addresses (which lists all IPs) and from VPS-related IP operations like attach_ip/detach_ip. However, it doesn't explicitly contrast with siblings, so it loses a point.

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: call when you need full detail for a single IP by id. It doesn't explicitly state when not to use it or name alternatives like list_ip_addresses for enumeration or check_available_ips for availability. The context is clear but no exclusions or alternatives 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds useful context about what data is returned (limits, usage, tier) and references the tier system, but doesn't disclose additional behavioral traits such as pagination, caching, or error scenarios. Given that annotations carry the core safety burden, the description provides moderate added value.

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

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

The description is a single, dense sentence that front-loads the primary purpose (resource limits) and lists the specific components. It includes the tier system reference and dashboard comparison without unnecessary words. Every phrase contributes to understanding the tool's output.

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 no parameters, no output schema, and annotations already cover safety, the description is fully adequate for an agent to decide to call it and understand what it returns. It mentions all key data categories (limits, usage, tier) and provides a reference to the dashboard page, making the tool's function clear in isolation.

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

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

The tool has zero parameters, and schema coverage is trivially 100% (empty properties). The baseline for a no-parameter tool is 4, and the description doesn't need to explain parameters. It appropriately focuses on the return data instead.

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 returns the account's resource limits (VPS count, vCPU, RAM, disk, IP caps), current usage against each, and the current tier. It specifies exact resource categories and references the tier system, making it distinct from siblings like get_usage_billing or get_bandwidth_overview. The verb 'get' combined with the resource scope leaves no ambiguity about what is retrieved.

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 context by stating it shows 'exactly what the dashboard's own Tier page shows' and lists specific resource metrics. While it doesn't explicitly name alternative tools to avoid, the resource-focused content clearly differentiates it from billing or bandwidth tools. The context is strong enough for an agent to infer when to use this tool versus siblings.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description agrees by framing this as a read operation. Beyond annotations, it adds a useful behavioral detail: the response includes replies, which is material because there is no output schema.

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

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

A single front-loaded sentence with no filler. Every word contributes to explaining what the tool does and what the response contains.

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

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

For a one-parameter, read-only getter with annotations covering safety and side effects, this description is complete. The 'including its replies' clause compensates for the missing output schema, and no additional information is needed to invoke the tool 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 0%, and the description does not elaborate on ticket_id. However, the parameter is self-explanatory, required, and the only input, so the schema title 'Ticket Id' plus the parameter name carry most of the meaning; the description adds little.

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

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

The description states a specific verb ('Get'), a clear resource ('full detail for one ticket'), and a meaningful scope ('including its replies'). This immediately distinguishes it from list_tickets (list vs. single) and list_ticket_replies (replies-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 phrase 'for one ticket' gives clear context: this is the tool to use when you need the complete detail of a specific ticket plus its replies. It does not explicitly name alternatives or exclusions, but the single-ticket framing makes the intended scope unambiguous.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the nuance that it returns 'full detail', which distinguishes from a list/summary variant, but doesn't elaborate on output format, pagination, errors, or any other behavioral traits. This is a small value-add beyond the annotations.

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

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

A single, front-loaded sentence that clearly conveys the action and target. Every word earns its place, with no fluff or redundancy. This is a model of concise tool documentation.

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

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

For a one-argument, read-only tool with no output schema, the description is mostly adequate. It identifies the required parameter and broadly describes the result, but 'full detail' is vague and not accompanied by any statement about what fields are included or any error semantics. Given the simplicity of the tool, this is acceptable 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?

The schema description coverage is 0%, so the description is the only potential source of parameter meaning. It only restates that the parameter is an ID ('by its id'), which is already obvious from the parameter name. It doesn't provide examples, data type hints, or instructions on where the ID comes from (e.g., list_transactions), leaving the agent with minimal added guidance.

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

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

States the action clearly ('Get') and identifies the resource as a single transaction and its full detail. This distinguishes it from siblings like list_transactions, although the distinction is implicit rather than explicit (e.g., it does not name the sibling). The phrase 'by its id' is a specific constraint that leaves little 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?

Gives no explicit guidance on when to use this tool versus alternatives. There is no mention of list_transactions, no prerequisites (e.g., obtaining the transaction ID), and no exclusions. The agent is left to infer from the name that this is the single-record counterpart to list_transactions.

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 annotations already declare readOnlyHint=true and idempotentHint=true, which cover the core non-mutating nature. The description adds meaningful behavioral context by describing the data as a 'live snapshot' and distinguishing between unbilled and already-billed historical cost, plus the availability of component-wise breakdown. This provides clarity beyond the annotations without contradicting them.

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

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

The description is a single, well-structured sentence that front-loads the core purpose and scope, then adds the relevant breakdown and dashboard reference. No unnecessary words; every clause 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 tool has no input parameters, annotations carrying the safety profile, and no output schema, the description provides a useful sense of the response scope (unbilled vs billed, categories) that an agent can act on. It could mention whether the snapshot is real-time or delayed, but the 'live snapshot' mention covers much of that. The description is sufficiently complete for a zero-parameter, read-only tool.

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

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

The tool accepts zero parameters, so the description need not explain any. The baseline of 4 for zero parameters applies; the description does not add any parameter-specific detail, which is appropriate.

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

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

The description clearly states the verb ('get') and resource ('usage billing'), and specifies the content: current unbilled usage plus historical billed cost, broken down by categories. It also anchors to the dashboard's Usage Billing page, giving a concrete reference. However, it does not explicitly distinguish this tool from the sibling get_usage_billing_line_items, which may offer similar data at a different granularity.

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

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

The description implies when to use this tool: it provides a summary breakdown of both unbilled and billed usage, similar to the dashboard page. It does not explicitly state when to prefer this over alternatives like line items or VPS-specific billing, but the summary nature is reasonably implied. No exclusions are mentioned.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds meaningful behavior: status is 'unbilled' (live snapshot) or 'billed' (already charged), which clarifies the data's temporal nature. It does not contradict annotations, and the extra detail is valuable beyond annotations.

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

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

Two sentences with zero fluff. The first sentence establishes the tool's purpose and scope, the second explains the parameter. Information is front-loaded and every word earns its place. Highly concise.

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

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

For a simple one-parameter read-only tool, the description is complete. It explains what the tool does, what the parameter means, and the context relative to a sibling. There is no output schema, but the description implies the return is row-by-row detail. No critical information is missing for an agent to call it correctly.

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

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

The only parameter 'status' has no schema description (0% coverage), so the description fully compensates by explaining its possible values and their meanings. It even notes the default is 'unbilled' and explains the live snapshot aspect. This is complete parameter documentation.

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

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

The description clearly states the tool provides row-by-row usage detail backing the summary tool, and specifies the charge types (VPS/volume/IP/bandwidth). It distinguishes itself from get_usage_billing by explicitly mentioning it is the underlying detail. The purpose is unambiguous and specific.

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

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

The description implies when to use this tool: when you need row-level detail behind get_usage_billing's summary. It does not explicitly name alternatives or state when not to use it, but the connection to the summary tool gives clear context. It would benefit from an explicit 'use when you need line items' but is still clear enough.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the read-only and repeatable nature is covered. The description adds a modest behavioral detail by promising 'full detail' and qualifying the volume as 'standalone', but it does not describe response contents, error behavior, or any further runtime characteristics. This is sufficient but not rich.

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 earns its place: it specifies the action, scope, target, and required input in under 10 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 one-parameter read-only tool with annotations covering safety and idempotency, the description is nearly complete: an agent knows what to call and with what input. The only gap is that it does not hint at the response shape, but full detail' implies a comprehensive return and no output schema exists to enumerate. Slight improvement would be naming alternatives, but that is already handled under usage guidelines.

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

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

Schema description coverage is 0%, so the description must compensate. It does partly by tying the parameter to a volume id ('by its id'), but the schema property is already named volume_id with title 'Volume Id', so the added meaning is minimal. No format, source, or uniqueness details are given.

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

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

The description names a specific verb ('Get'), an explicit resource ('full detail for one standalone volume'), and the identifying mechanism ('by its id'). It clearly distinguishes from siblings like list_volumes (which lists multiple volumes) and get_volume_task_status (which reports task progress), so an agent can infer exactly what this tool does.

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

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

The description provides a clear context: use it when you need full details for a single volume and you have its id. However, it does not explicitly mention alternatives such as list_volumes for overviews or get_volume_task_status for ongoing operations, leaving the when-not-to-use guidance implied rather than stated.

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

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

Annotations already communicate readOnlyHint=true and idempotentHint=true, so the safe, repeatable nature is covered. The description adds that this is an async status-polling endpoint, but it does not disclose what the response contains or whether the task status may be pending/failed/successful, which would add value beyond the annotations.

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

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

A single, front-loaded sentence fully communicates the tool's role and parameter source with no redundant words. It earns its place and remains easy to scan.

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

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

For a one-parameter polling endpoint, this is usable but not complete: with no output schema, the description should hint at the kind of status values the agent can expect or note that the response reflects an async operation's progress. Missing that leaves agents guessing about the response shape and possible outcome states.

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 0%, the description clarifies the only parameter's meaning and origin: task_id is the ID returned by the async volume calls. This goes beyond the bare 'Task Id' string property name, satisfying the required compensation for low schema coverage.

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

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

The description states a specific verb ('check the status') and a specific resource ('async volume operation') and enumerates the relevant operations. It clearly distinguishes this polling tool from the many direct volume and VPS action tools in the sibling list.

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

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

Usage context is implied: this is for checking an async operation's status using the task_id returned by those calls. However, it does not explicitly say when NOT to use it, nor does it point to alternatives like get_volume for finished-state reads, so the guidance is adequate but not thorough.

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

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

Annotations already declare the operation read-only and idempotent, so safety is covered. The description adds that the response contains 'full detail' and clarifies the id format, but it does not disclose error behavior or response structure. This is acceptable given the annotations, but no additional behavioral context is provided.

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

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

A single sentence that is front-loaded with the operation and resource, then supplies the essential parameter guidance. No filler, no redundancy, and every word earns its place.

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

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

For a simple read-only get-by-id tool with one parameter and strong annotations, this description is complete. It identifies the input, its source, and the output nature ('full detail'). No critical information is missing for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 0%, so the description must fully explain the parameter. It does: vps_id is a UUID and comes from list_vps's id field. This goes well beyond the schema's bare string type and gives the agent everything needed to supply a valid 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 identifies the operation (get full detail), the resource (one VPS instance), and the key discriminator (by id, as opposed to listing). It also points the agent to list_vps for obtaining that id, making the tool's role unambiguous among many VPS-related 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 implies when to use this tool: when you need full detail for a specific VPS and already know its id. It also tells the agent where the id comes from (list_vps's id field). It does not explicitly list alternatives or exclusions, but the context is clear.

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

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

The readOnlyHint and idempotentHint annotations already cover the safety profile, so the description does not need to over-explain side effects. It adds useful workflow context by noting this should be called before creating a backup, but it does not disclose response details or edge cases.

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

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

The description is only one short sentence with no filler. It front-loads the action and includes the key timing note about create_vps_backup.

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

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

For a simple one-parameter read-only operation with annotations covering safety, the description is largely complete. It clearly states purpose and timing, though it omits return format or units, which would be helpful but not essential for this tool.

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

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

Schema coverage is 0%, so the description carries the burden of explaining vps_id. The phrase 'of this VPS' only weakly maps to the parameter, and no additional detail is given about the ID format, required ownership, or how the cost is calculated.

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 identifies the operation as retrieving the cost of a new backup for a specific VPS. The phrase 'before calling create_vps_backup' distinguishes it from listing existing backups or querying general VPS pricing.

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

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

It explicitly frames the tool as a pre-step to create_vps_backup, giving the agent clear timing context. It does not explicitly discuss when not to use it or list alternatives, but there is no closely competing sibling for this specific task.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds the 'historical' context, indicating this returns past data rather than real-time or current stats. However, it does not disclose response format, time granularity, or error behavior, which would add value beyond annotations.

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

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

The description is a single concise sentence that front-loads the core purpose ('Historical bandwidth usage'). It is efficient with no fluff, though it could be slightly more informative without losing brevity.

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

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

Given there is no output schema, the description should indicate what the agent can expect from the response (e.g., total bandwidth, time series, units). It does not, and it also lacks details on optional parameters (like time range) or how to interpret the data. For a read-only tool, the description is incomplete.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented vps_id parameter. It only says 'for one VPS', which is already implied by the parameter name. No format, required context, or relationship to the data is explained, adding minimal value over 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 fetches historical bandwidth usage for a single VPS. It specifies a resource (VPS) and the nature of the data (historical bandwidth). It distinguishes itself from broader overview tools like get_bandwidth_overview, but doesn't explicitly name alternatives, so it's not fully self-differentiating.

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

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

The description provides no guidance on when to use this tool vs similar ones like get_vps_stats or get_vps_metrics_history. It does not mention exclusions or alternatives, leaving the agent to infer context from the tool name and sibling list.

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

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

Annotations already declare readOnlyHint true, openWorldHint false, and idempotentHint true, so the safety profile is covered. The description adds no extra behavioral details (e.g., return format, date range, cost breakdown), but it does not contradict the annotations.

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

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

The description is six words with no filler, and the core scope ('one specific VPS') is front-loaded. It earns its place, though it is notably spare.

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

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

For a single-parameter read-only tool, this is almost sufficient, but it leaves ambiguity about what 'billing breakdown' contains (current month, historical, line items) and does not distinguish itself from similar billing tools. The safety annotations reduce the need for more behavioral disclosure.

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

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

Schema coverage is 0% and vps_id has no description, so the description must compensate. 'One specific VPS' implies the target, but it adds no details about the format, accepted values, or relationship to the parameter beyond the parameter name.

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

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

The phrase 'billing breakdown for one specific VPS' names the resource and identifies the key distinguishing scope—single-VPS versus account-level billing. It is clear, though it does not use a verb and does not explicitly differentiate from close siblings like get_usage_billing or get_vps_pricing.

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 explicit usage guidance or alternative tools. It implies a per-VPS billing scope but never says when to use this over account-level billing tools 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?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds a real behavioral constraint: the log is only available while building or shortly after. However, it does not disclose return format, pagination, or what 'recently built' means, so the added behavioral context is modest.

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, tight sentence that front-loads the resource and availability scope, then adds the diagnostic purpose. There is no filler, repetition, 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?

For a one-parameter, read-only log fetch with no output schema, the description conveys what log is returned, when it is available, and why an agent might call it. It leaves the return value shape unstated, but the simplicity of the tool and the read-only/idempotent annotations make invocation straightforward.

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

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

With schema description coverage at 0%, the description should clarify the vps_id parameter, but it only refers generically to 'a VPS', which adds little beyond the schema's property name and title. It does not mention requiredness, format, or how to obtain a valid vps_id, so it does not compensate for the coverage gap.

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

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

The description identifies the tool as returning a VPS's provisioning/build log and adds the key qualifier that it applies to in-progress or recently completed builds. It is specific enough to be understood against sibling get_* tools, though it lacks an explicit verb like 'returns' and does not explicitly differentiate from similar 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 phrase 'still building, or was recently built' gives a concrete condition for when the log exists and is relevant, and 'diagnosing a stuck/failed deploy' states a clear use case. It does not name alternative tools or exclusions, but the intended context is clear.

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

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

Annotations already declare the operation as read-only and idempotent. The description adds valuable behavioral context by specifying that the credentials are one-time and sensitive, which is beyond what annotations convey. This helps the agent treat the output cautiously without contradicting the read-only 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 a single, front-loaded sentence that states the action and key return values without wasted words. It is concise and clearly structured, making it easy for an 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?

Given the tool's low complexity (one parameter) and the lack of an output schema, the description provides essential context: it specifies the output (URL and password) and notes the sensitive nature. It does not detail the response format, but that is likely unnecessary for successful invocation. Overall, the description gives enough information to call the tool 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 0%, so the description must compensate for the lack of parameter documentation. It does not explicitly explain vps_id, leaving the parameter meaning to inference from the tool name. The description only indirectly references the VPS via 'this VPS', which is insufficient to clarify the parameter's format or purpose.

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

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

The description clearly states the tool retrieves a one-time VNC console URL and password for a VPS, which is a specific verb-resource pairing. It distinguishes itself from other VPS getter tools (e.g., get_vps, get_vps_stats) by focusing on console access, leaving no ambiguity about its function.

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

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

The description implies usage (to obtain live console access) but does not explicitly state when to choose this over other tools or list any exclusions. There is no direct sibling alternative for console access, so the lack of explicit 'use this instead of X' is acceptable, but it still does not provide any contextual conditions for use.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe read operation. The description adds the historical/time-series context, which is useful. However, it doesn't disclose details like the time range, granularity, or whether the metrics are aggregated, which would be valuable for a metrics-history 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, compact sentence that front-loads the core purpose and immediately distinguishes it from the sibling tool. Every word earns its place; no filler or redundancy.

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

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

For a simple read-only tool with one parameter and no output schema, the description is largely complete. The main gap is the lack of detail about the returned time-series data (e.g., time range, resolution), but the annotations cover the safety profile and the purpose is clear. An agent can call this tool correctly with the given information.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter meaning. The description implies the vps_id identifies which VPS to fetch history for, but it doesn't add explicit detail about the parameter format or constraints. With only one parameter and a clear name, the baseline is acceptable, but the description could have explicitly stated that vps_id is required and identifies the target VPS.

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

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

The description states a specific verb ('get'), a resource ('VPS'), and a clear scope ('historical CPU/RAM/disk metrics'). It also explicitly contrasts itself with the sibling get_vps_stats, which provides a current snapshot, making the purpose unambiguous.

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

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

The description clearly indicates when to use this tool: for graphing usage over time, not just the current snapshot. It names the alternative (get_vps_stats) and explains the distinction. It doesn't explicitly list exclusions or other alternatives, but the context is sufficient for an agent to choose correctly.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the context that this is a preview tool for resize_vps, but doesn't disclose details like whether pricing is estimated or exact, or whether it reflects current vs. projected costs. No contradiction with annotations.

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

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

The description is a single sentence that front-loads the core purpose and immediately adds usage context. Every word earns its place; no fluff or repetition.

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 read-only tool with one parameter and no output schema, the description is mostly adequate. However, it doesn't clarify what 'pricing' includes (e.g., hourly/monthly, with or without disks) or whether the returned price is for the current configuration only. Given the sibling get_vps_billing exists, a bit more distinction would help.

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

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

Schema description coverage is 0%, so the description carries the burden for parameter semantics. However, the single parameter vps_id is self-explanatory given the tool name and description. The description doesn't add detail about the format or constraints of vps_id, but with only one obvious parameter, the gap is minor.

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 returns current pricing for a VPS configuration, using a specific verb ('get') and resource ('pricing'). It distinguishes itself from the sibling resize_vps by explicitly mentioning it's useful before resizing, though it doesn't explicitly name the sibling.

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 clear context: it's useful before calling resize_vps to preview cost. This implies when to use it, but it doesn't explicitly state when not to use it or mention alternatives like get_vps_billing or get_vps_backup_cost.

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?

Beyond the annotations (readOnlyHint, idempotentHint), the description adds an edge-case behavior: it returns {"supported": false} if the VPS node doesn't support the check. This is valuable context about a plausible failure mode. It also frames the result as a policy-driven status. This goes beyond what annotations alone convey.

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 contains the main purpose and the unsupported fallback. The embedded JSON is compact and front-loaded after the main point. Zero filler; every part earns its place.

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

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

For a simple status read with one parameter and no output schema, the description explains the returned boolean and the unsupported case. It does not discuss error handling, but given the read-only annotation and simple shape, this is sufficient for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the single vps_id parameter. It only says 'this VPS', which ties the vps_id to the tool subject but provides no additional syntax, format, or selection details. The schema already labels it 'Vps Id', so the description adds little new 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's outcome: whether outbound SMTP ports are blocked on a VPS, and the unsupported fallback. It names a specific resource (VPS) and a specific feature (SMTP port status), which distinguishes it from the many get_vps_* status tools. It could be more explicit with a verb like 'Check if', but the function 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 gives no guidance about when to choose this tool over siblings like get_vps_stats or get_vps_build_log. There is no mention of alternatives, prerequisites, or use cases. The phrase 'common anti-abuse policy' hints at a troubleshooting context, but it is not enough to guide 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?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds that this returns a real-time snapshot and applies to running VPSs, but it does not disclose units, failure behavior, or what happens if the VPS is stopped. This is adequate but not rich.

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 tight, front-loaded sentence that states the resource, the timing, and the metric categories with zero filler. Every word contributes.

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

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

For a one-parameter read-only stats tool with annotations covering safety, the description is nearly complete: it says what is returned and under what condition. The main omission is explicit units or output shape, but no output schema exists and the metric list already sets expectations.

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

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

With schema description coverage at 0%, the description carries the burden, but it does not explicitly document vps_id. However, vps_id is a self-evident identifier and the description's 'running VPS' context helps clarify its referent. Minimal compensation, but enough for a single obvious 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 uses a specific verb and resource ('Real-time resource stats for a running VPS') and enumerates the exact metric categories: CPU, RAM, disk, and network. The qualifier 'right now' distinguishes this from historical siblings like get_vps_metrics_history and get_vps_bandwidth_history.

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 phrase 'for a running VPS' provides a clear context condition, and 'right now' signals that this is for current-state readings rather than history. It does not explicitly name alternatives/exclusions, so it stops short of a 5.

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?

Beyond the destructiveHint annotation, the description discloses irreversibility ('overwriting whatever's on it entirely. Irreversible — requires confirm=true'), the asynchronous nature ('Asynchronous — poll get_volume_task_status'), and the prerequisite of detaching the volume. These are not conveyed by annotations alone and provide crucial safety information.

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

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

The description is a compact set of five sentences, each adding distinct value: purpose, destructiveness, prerequisite, credential conditions, and async behavior. It is front-loaded with the core function and no filler.

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

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

For a tool with 5 parameters, no output schema, and no enums, the description covers the essential aspects: what it does, side effects, required preconditions, parameter conditions, and follow-up polling. An agent has enough information to call it safely and 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?

With 0% schema description coverage, the description compensates by explaining the conditional semantics of root_password and ssh_public_key (Windows vs. non-Windows), and confirm's role in the irreversible action. It does not explain the operating_system parameter, but that's covered by sibling tools like list_available_os_for_volume. Overall, it adds meaningful value beyond the bare names.

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

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

The description states the specific verb and resource: 'Install a fresh OS onto this standalone volume,' and clarifies the overwriting behavior. It differentiates from sibling tools like reinstall_vps (for VPS) and list_available_os_for_volume (listing) by explicitly targeting standalone volumes.

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

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

It provides clear prerequisites: the volume must be detached (detach_volume), and OS-specific credential requirements. It does not explicitly name alternative tools or say 'use this instead of X', but the context makes the intended use clear. Minor gap: no explicit when-not-to-use guidance, but overall it gives solid direction.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds valuable context: it lists the scope of actions included, specifies 'newest first' ordering, and explains the search parameter behavior. This goes beyond what annotations provide.

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 well-structured sentences: the first is front-loaded with purpose and scope, the second explains the parameter. No fluff or redundancy. Every sentence earns its place.

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

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

For a simple read-only list tool with one optional parameter and no output schema, the description covers the essential behavior: what is returned (a list newest-first) and the examples of included events. It does not detail the exact fields of each log entry, but that is a minor gap given the tool's simplicity and annotation-covered safety.

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 only parameter 'search' has no schema description, but the tool description fully compensates by stating it 'matches action/description/IP address.' This gives clear semantics, including that it's optional. The description adds all necessary meaning beyond the raw 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 lists the account's activity log with a specific verb (List) and resource (activity log), and enumerates the actions covered (sign-ins, VM changes, etc.). This distinguishes it from siblings like billing or invoice tools, which have different purposes.

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

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

The description provides clear context: it is the comprehensive audit trail for the account and VPS instances. It does not explicitly name alternatives, but no sibling tool serves the same function, so exclusion is unnecessary. The context is sufficient for an agent to know when to call 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the tool's safety profile is covered. The description adds contextual detail about filtering by region and attachment status, but no additional behavioral traits such as pagination, sorting, or special cases. This is adequate but not exceptional given the annotation coverage.

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

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

A single, well-structured sentence with no filler. The core action and object are front-loaded, and the eligibility conditions are placed at the end without 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?

For a one-parameter read-only list operation, the description plus annotations are nearly sufficient. It states what is listed and the key filtering criteria, and the output is straightforward enough to infer (a list of IPs). The only small gap is not describing the output shape, but that is mitigated by the tool's simple 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?

The schema has 0% description coverage and one required parameter, vps_id. The description indirectly clarifies that vps_id refers to the specific VPS to which the IPs are attachable ('this specific VPS'), and adds eligibility context, but it does not explain the expected format, how to obtain the ID, or any additional constraints beyond that.

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 identifies the operation (list), the resource (this account's standalone IP addresses), and the specific eligibility constraints (same region, not already attached). It distinguishes itself from sibling tools like list_ip_addresses and list_attachable_vps_for_ip by focusing on IPs attachable to a specific VPS.

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 clear context: this is for finding standalone IPs that can be attached to a particular VPS, with eligibility criteria stated. It does not explicitly name alternatives or say 'use this before attach_ip', but the phrase 'eligible to attach to this specific VPS' conveys the intended use case well enough.

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

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

Annotations already mark the operation as readOnly, openWorld=false, and idempotent. The description adds behavioral meaning beyond those hints by disclosing the eligibility rule (same region as the IP), which is not inferable from the schema or annotations.

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

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

A single sentence that is front-loaded with the operation and resource, and includes the essential eligibility constraint without filler. Every word earns its place.

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

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

For a simple one-parameter list operation with strong readOnly/idempotent annotations, the description is nearly complete. It gives the purpose, the IP reference, and the region criterion; the only minor gap is not describing the returned VPS fields or pagination, but no output schema exists to clarify that.

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

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

Schema coverage is 0%, so the description must compensate. It refers to 'this IP' and 'the IP', which maps ip_id to the IP whose attachable VPSs are returned, but it does not clarify the expected value format or that ip_id is an ID rather than an address. Some meaning is added, but the parameter remains under-specified.

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

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

The description states a specific verb ('List') and resource ('this account's VPS instances eligible to attach this IP'), and adds a key scoping constraint ('same region as the IP'). This clearly differentiates it from the inverse sibling list_attachable_ips_for_vps.

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 conveys the intended use case: finding candidate VPS instances for attaching a particular IP. It does not explicitly name alternatives or exclusions, but the 'eligible to attach' and region constraint make the selection context clear enough for an agent.

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

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

Annotations already signal readOnly and idempotent behavior. The description adds useful behavioral context beyond that: it scopes to 'this account's' VPS instances and discloses the eligibility filters (same region, stopped where required). The phrase 'stopped where required' is slightly vague but still conveys nontrivial filtering 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?

A single, front-loaded sentence with no filler. Every clause contributes meaning: scope, eligibility, region, and required state.

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 read-only single-parameter list tool, the description provides enough to invoke the tool correctly: purpose, scope, and eligibility criteria. The main gap is the ambiguous 'stopped where required,' and with no output schema, return-value shape is not described but is inferable as a list of VPS instances.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining volume_id. It only refers to 'this volume' indirectly; it does not clarify the expected format, how to obtain a volume_id, or the relationship to the volume resource beyond the parameter name. Minimal value added over 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 uses a specific verb ('List') and resource ('VPS instances eligible to attach this volume to'), and states the key constraints (same region, stopped where required). It is clearly distinct from siblings like list_attachable_vps_for_ip and other list 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 makes clear the intended context: discovering which VPS instances can be attached to a given volume. It does not explicitly name alternatives or exclusions, but the purpose is specific enough that an agent can select it correctly without inferring much.

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

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

Annotations already declare readOnlyHint and idempotentHint, so no repetition is needed. The description adds the volume-scoped/install-relevant constraint but does not disclose behaviors such as response shape or handling of invalid volumes; given the strong annotation coverage this is acceptable but not rich.

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-loads the primary action, and contains no filler.

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

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

For a simple read-only, single-parameter list operation, the description gives enough context: what is listed, for which resource, and how the result connects to install_os_on_volume. It does not describe output details, but no output schema exists and the required info is otherwise minimal.

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?

There is one parameter, volume_id, with no schema description (0% coverage). The phrase 'onto this volume' ties volume_id to its role as the target volume, and 'via install_os_on_volume' explains why the list is relevant, but the description does not explicitly define the parameter or its expected format/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 identifies a specific verb (List), a clear resource (operating systems for a given volume), and names the downstream operation install_os_on_volume, which distinguishes it from similar siblings such as list_vps_available_os and list_os_images. It is not a tautology and the resource scope is unmistakable.

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

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

It establishes clear context: this is the enumeration to consult before calling install_os_on_volume for a volume. It does not explicitly state when not to use it or name alternatives like list_vps_available_os, so it falls short of a 5.

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 readOnlyHint=true and idempotentHint=true annotations, the safety profile is already disclosed. The description adds a useful behavioral hint about the parameter source (list_regions), but it does not detail return format, error behavior, or pagination. This adds some value beyond annotations but is not exhaustive.

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

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

The description is a single, focused sentence with no filler. It front-loads the action and resource, and includes the parameter source in a parenthetical note. Every word earns its place.

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

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

For a simple read-only listing tool with one parameter and no output schema, the description is sufficient. It clearly states what the tool returns and the source of the required input. It could optionally mention its role in the volume purchase workflow, but that is not essential for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the 'pop' parameter. It does so by explaining that it is a Point of Presence id from list_regions, giving the parameter meaningful context beyond the bare schema type. This is valuable and goes beyond what the schema provides.

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

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

The description clearly states the action ('List'), the resource ('volume sizes/kinds'), and the scope ('purchasable in a given region'). It is specific and distinguishes itself from siblings like purchase_volume or list_available_os_for_volume by focusing on volume size/kind availability.

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

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

The description provides a clear prerequisite: the region is identified by a Point of Presence id from list_regions. This tells the agent where to get the input parameter. However, it does not explicitly name alternatives or state when NOT to use this tool, so it falls short of an explicit routing guide.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description is not required to repeat those. It adds a slight nuance with 'currently applied' but this is essentially inherent to 'list'. No additional behavioral context (e.g., no pagination, no rate limits) is disclosed, but the safety profile is already covered by annotations.

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

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

The description is a single, concise sentence that is front-loaded with the key information. Every word earns its place, and there is no redundancy or fluff.

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

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

This is a simple read-only operation with one required parameter and no output schema. The description is sufficient for an agent to understand what to call, though it does not specify the return format (e.g., an array of rule objects). Given the simplicity and annotation coverage, the description is almost complete but leaves a minor gap about the response shape.

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

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

Schema description coverage is 0% – the schema only provides the parameter name 'vps_id' with type string. The description says 'this VPS', which implicitly references the parameter but does not explain its meaning, format, or constraints beyond what the name conveys. Given the low coverage, the description should compensate but does not add meaningful detail.

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

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

The description states a specific action ('List'), a resource ('firewall rules'), and a scope ('currently applied to this VPS'). It clearly distinguishes from siblings like update_firewall_rules (which modifies) and list_vps (which lists VPSs). The verb and resource are unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites, and no exclusions. It does not reference update_firewall_rules or explain that this is the read-only counterpart to modifications. An agent must infer usage context from the name and siblings.

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

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

Annotations already convey read-only, idempotent, and complete-world behavior. The description adds valuable behavioral context beyond annotations by specifying that all statuses are included, results are sorted most recent first, and which fields appear. This is meaningful for a zero-parameter listing 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?

A single, well-structured sentence packs in scope, filtering coverage, ordering, and output fields with no filler. Every clause adds useful information, and the most important scope statement is front-loaded.

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

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

For a parameterless read-only listing tool, the description covers what the tool does, what data it returns, and the ordering. Annotations cover safety and idempotency, and no output schema exists, so the description carries the full burden for return-value expectations and satisfies it well.

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?

There are zero parameters, so the schema fully covers parameter semantics by having none. Per baseline, zero-parameter tools receive a 4; the description also clarifies what the returned data contains, which further helps the agent understand the call's effect.

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

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

The description states a specific verb and resource: 'List every invoice on this account', and adds scope details (paid, unpaid, cancelled), ordering (most recent first), and returned fields (amount, status, due date, line items). This clearly distinguishes it from sibling tools like list_transactions and get_transaction.

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

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

The description clearly implies when to use it: whenever a full list of account invoices is needed. It does not explicitly name alternatives or exclusions, but the scope 'every invoice on this account' is unambiguous enough for an agent to select it correctly among siblings.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate safety. The description adds useful context about scope (account-wide, standalone, attached or not), but it does not disclose any additional behavior such as pagination, ordering, or filtering. This is adequate but not rich.

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 front-loads the action and resource, then adds the clarifying scope. Every word earns its place.

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

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

For a zero-parameter, read-only list operation, the description provides enough context to invoke the tool correctly. Since there is no output schema, the description could optionally mention the response shape, but the scope statement itself is complete for the tool's purpose.

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

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

The tool has zero parameters, so there are no parameter semantics to clarify. The description's scope note is sufficient, and the schema contains no properties to document.

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

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

The description states a specific verb and resource: 'List every standalone IP address on this account', with an explicit scope qualifier '(attached to a VPS or not)'. This clearly distinguishes it from single-IP tools like get_ip_address and from VPS-scoped IP tools like list_attachable_ips_for_vps.

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

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

The description makes the usage context clear: it is the account-wide listing for standalone IP addresses, regardless of attachment status. It does not explicitly name alternatives or say when not to use it, but the scope leaves little ambiguity about when this tool is appropriate.

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

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

Annotations already declare read-only and idempotent behavior, so the description needs only to add behavioral context. It does so by disclosing that recently-completed events (within the last 24h) are included alongside active ones, and by explaining account-scoping rules. It does not describe response format or ordering, but for a read-only list this is still a solid behavioral profile.

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 compact sentences front-load the core purpose and add only high-value details about scope and event recency. There is no filler, restatement of the tool name, or redundant information.

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

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

For a zero-parameter, read-only tool with no output schema, the description provides all necessary selection context: what counts as relevant, account-wide scoping, and the inclusion of recently-completed events. Nothing an agent needs to choose or invoke this tool is missing.

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

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

The tool has no parameters, so schema coverage is trivially 100% and there is no parameter-semantics gap. The baseline of 4 for a 0-parameter tool applies; the description adds no parameter-specific detail because none is needed.

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

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

The description uses a specific verb ('List') and resource ('maintenance events relevant to this account') and precisely defines the scope: anything affecting account infrastructure in a VPS/region plus account-wide events. This clearly distinguishes it from sibling tools like list_activity_logs or get_vps.

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 clear context for when the tool should be used: retrieving maintenance events that affect account infrastructure or are scoped account-wide. It does not explicitly name alternatives or give when-not-to-use guidance, but the scoping criteria make the intended usage evident.

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 annotations already declare readOnlyHint=true and idempotentHint=true, and the description's 'List' wording is consistent with those. It adds helpful scope detail via 'every' and the parenthesized output fields, but it does not disclose pagination, ordering, or any special list behavior. This is adequate but not extensive.

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: it states the action, resource, and output attributes with no filler words. It earns its place completely.

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

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

For a zero-parameter read-only list with no output schema, the description adequately names both the scope and return fields, so an agent can call it correctly. It stops short of full completeness by not mentioning pagination or clarifying when the sibling 'list_vps_available_os' is more appropriate.

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?

There are zero parameters and the schema coverage is 100%, so the schema carries no input ambiguity. The description reinforces that the list is unfiltered with the word 'every', which is sufficient for a no-argument tool.

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

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

The description clearly names the verb and resource: it 'List every operating system image available to deploy a VPS' and names output fields. It is not a tautology, but it does not explicitly distinguish itself from similarly named siblings like list_vps_available_os or list_available_os_for_volume.

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 phrase 'available to deploy a VPS' implies the intended use case is selecting an OS image for VPS deployment. However, it gives no when-not-to-use guidance or alternative routing, despite the similar sibling list_vps_available_os existing.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, read-only operation. The description adds the detail that it returns all Points of Presence, but doesn't disclose return format, ordering, or whether the list is exhaustive. With annotations covering the safety profile, a 3 is appropriate.

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

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

The description is a single, front-loaded sentence that states the action and resource without any wasted words. It is appropriately sized for a zero-parameter list 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?

For a zero-parameter, read-only list tool with annotations covering safety, the description is nearly complete. It could mention the return format (e.g., array of region objects), but the absence of an output schema and the simplicity of the tool make this a minor gap. The description fully explains what the tool does.

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

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

The tool has zero parameters, so the schema provides no parameter semantics to clarify. The description doesn't need to explain parameters, and the baseline for 0 params is 4. The description's focus on the resource being listed is sufficient.

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

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

The description states a specific verb ('List') and resource ('every Point of Presence (region/data-center location)'), and clarifies the purpose: showing where VPS instances can be deployed. This clearly distinguishes it from sibling tools like list_vps or list_os_images, which list different resources.

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

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

The description implies usage context: call this when you need to know available deployment regions for VPS instances. It doesn't explicitly name alternatives or exclusions, but the resource is specific enough that an agent can infer when to use it versus other list tools. A clear context is provided, though no explicit when-not-to-use guidance is 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?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds valuable behavioral context beyond annotations by stating that only titles are returned, not public key material or anything private. This helps the agent set expectations properly.

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

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

The description is a single, well-structured sentence. It front-loads the operation and resource, and the parenthetical earns its place by clarifying important output constraints without adding 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?

For a zero-parameter, read-only list operation with no output schema, the description is complete. It tells the agent what is returned (titles only), what is not returned (public key material or private data), and the account scope. Annotations cover safety and idempotency, so nothing essential is missing.

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

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

The tool has zero parameters, so there is no parameter schema to explain. The description correctly avoids adding unnecessary parameter details. The baseline for a zero-parameter tool is 4, and no information is missing.

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

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

The description states a specific verb ('List'), a specific resource ('SSH public keys'), and an account scope. The parenthetical 'title only' further defines the data returned, leaving no ambiguity about the operation's purpose or distinguishing it from create/delete key 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 clearly implies when to use this tool: whenever an agent needs the list of SSH public keys on the account. It doesn't explicitly mention alternatives or when-not-to-use, but the account-scoped, read-only list context is clear and distinct from the create/delete siblings.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the description doesn't need to restate safety. It adds the useful cross-reference to create_ticket, but doesn't disclose any additional behavior such as authentication needs, rate limits, or output details.

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 tight sentence that front-loads the action and resource, then adds the key relationship to create_ticket. Every word earns its place with no filler.

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

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

For a zero-parameter, read-only list tool, this description is complete: it explains what is listed and why the agent would call it. The annotations cover safety and idempotency, and the department_id reference gives the agent the essential output contract.

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 is empty and schema coverage is 100%, so there are no parameters to document. The description adds conceptual value by explaining that the output is the source of department_id for create_ticket, which corresponds to the baseline 4 for zero-parameter tools.

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

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

The description uses a specific verb and resource: 'List support departments a ticket can be filed under.' It also names its role as the department_id source for create_ticket, which clearly distinguishes it from sibling ticket tools like list_tickets or create_ticket.

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 frames this tool as the source for department_id when creating a ticket, giving clear context for when to call it. It doesn't discuss exclusions or alternatives, but no sibling tool lists departments, so that omission is not material.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that this is the paginated version, which is useful behavioral context beyond annotations, though it doesn't explain how pagination works (e.g., cursor or page parameters).

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

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

Two sentences with the action front-loaded and no wasted words. The parenthetical adds necessary distinction without bloat.

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

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

The tool is simple (one parameter, read-only), but the description does not clarify the pagination mechanism or the return format. Since there is no output schema, an agent cannot know how to handle pagination responses or whether all replies are returned in one call. This leaves a meaningful gap for a 'paginated version' 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 only parameter, ticket_id, is self-explanatory from its name, and schema description coverage is 0%. The description does not add any additional meaning about the parameter, but since it's the sole required field and clearly named, the gap is minor.

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

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

States a specific verb and resource: 'List every reply on a ticket' and differentiates from get_ticket by noting it's the paginated version. This is clear and distinguishes it from siblings like get_ticket and reply_to_ticket.

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

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

Explicitly says when to use this over the alternative: it includes the same data as get_ticket's 'replies' field but is for long conversations requiring pagination. This gives a clear condition and names the sibling 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?

Annotations already convey that the operation is read-only and idempotent, so the description does not need to restate that. The description adds useful behavioral context beyond the schema by disclosing the sort order ('most recently updated first') and the specific fields the search applies to ('subject/department/status'), which helps an agent predict response ordering. It does not mention pagination or limits, but the annotation coverage keeps this from being a major 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 one compact, front-loaded sentence: first the core action and scope, then ordering, then the optional parameter behavior. Every clause earns its place and there is no repetition or filler.

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

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

For a simple read-only list operation with one optional parameter, the description provides the necessary orientation: what the ticket list covers, the ordering, and what the search filter can match. It does not explain pagination or the response shape, but the tool is simple and the annotations already cover the safety profile. It is complete enough for an agent to invoke competently.

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

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

The schema provides only a raw 'search' string with a default, and there is no property description in the schema. The description meaningfully compensates by marking the parameter optional and explaining it matches 'subject/department/status,' which an agent would not know from the schema alone. It is not exhaustive, as it doesn't specify case sensitivity or substring matching, but for a single parameter this is solid coverage.

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

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

The description uses a specific verb ('List') and a specific resource ('this account's support tickets'), so an agent immediately understands the tool's scope. It also says tickets are sorted 'most recently updated first,' which differentiates it from siblings like get_ticket, list_ticket_replies, and create_ticket even without explicitly naming them.

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

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

The description gives solid context for when the tool is relevant — listing all support tickets and optionally filtering via search — but it does not explicitly say when to prefer this over get_ticket, list_ticket_replies, or list_ticket_departments. The choice of tool is implied by the name and resource, but not explicitly routed. There is no guidance about exclusions or prerequisites.

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

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

Annotations already declare the operation read-only and idempotent, so the description does not need to restate safety. It adds the wallet scope, included categories, and sort order, which is useful, but it does not disclose pagination, response shape, or any limits. This matches a safe read tool with modest added 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?

A single sentence front-loads the verb and resource, adds concise parenthetical detail about transaction categories, and ends with ordering. Every word earns its place; there is no repetition of schema or annotation values.

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

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

For a zero-parameter read-only list tool, this description is nearly complete: it states scope, content categories, and ordering. It falls just short of perfect by not mentioning pagination or the return-value shape, though those are less critical for selecting and invoking the tool.

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

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

There are zero parameters and the schema coverage is 100%, so there is nothing for the description to document. The baseline of 4 applies because no parameter meaning is missing.

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

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

The description names a specific operation ('List every transaction') on a specific resource (the account's wallet), enumerates included transaction types, and specifies ordering ('most recent first'). This distinguishes it from sibling get_transaction and list_invoices by 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 scope is clear, but the description never says when to choose this over get_transaction or list_invoices, nor does it state exclusions. Usage is implied ('every transaction on wallet') rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false. The description adds behavioral value by nailing down what 'every' means: attached or not and boot or non-boot. It does not contradict annotations and needs no additional safety caveats for a read-only list 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?

A single, front-loaded sentence starts with the action verb 'List' and the main object, with a parenthetical that precisely expands the scope. Every word earns its place; there is no fluff or redundant restatement of the tool name.

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

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

For a parameterless, read-only list tool with clear annotations, the description is largely sufficient: it tells the agent what is returned (the set of standalone volumes) and how broad that set is. It does not detail output shape or pagination, but the simple resource concept and safe operation make this a minor gap.

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

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

The input schema has zero properties, so there are no parameters for the description to explain. With 0 parameters, the baseline of 4 applies, and the description appropriately gives no parameter information because none is needed.

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

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

The description states a specific verb ('List') and resource ('standalone storage volume'), and the parenthetical further clarifies scope: 'attached to a VPS or not, boot or non-boot'. This clearly differentiates it from siblings like list_vps (VPS instances) and get_volume (single volume) without needing to inspect schemas.

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

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

The description provides clear context: use this tool when you need to enumerate every volume on the account, regardless of attachment or boot status. It does not explicitly name alternatives or exclusion criteria, but the scope is unambiguous enough to route the agent correctly among the many 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description doesn't need to repeat that. It adds value by specifying exactly what fields are returned, which helps the agent understand the output. No contradiction with annotations.

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

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

The description is a single sentence that is front-loaded with the main action ('List every VPS instance') and immediately details the returned fields. 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 no-parameter list tool, the description is complete: it states the scope (all VPS instances), the exact fields returned, and even notes the possible machine_status values. With no output schema, it provides sufficient information for an agent to call it correctly and understand the result.

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

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

The tool has zero parameters, so the baseline is 4. The description doesn't need to explain parameters, and it doesn't. It correctly adds no param info since none exist.

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

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

The description clearly states the tool lists every VPS instance on the account, enumerating specific fields (hostname, status, specs, IPs, OS, node, machine_status). This distinguishes it from sibling tools like get_vps (single VPS) and list_vps_backups (backups).

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

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

The description implicitly indicates when to use this tool: to retrieve all VPS instances. It doesn't explicitly state exclusions like 'use get_vps for a single VPS', but the sibling names make this obvious. The context is clear, though not spelled out.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description doesn't need to restate safety. It adds useful behavioral context beyond annotations: availability is specific to the VPS's node and narrower than the global OS catalog.

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 with all essential information front-loaded, followed by a clarifying contrast with list_os_images. No filler or repetition of schema details.

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

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

For a one-parameter read-only list tool with no output schema, the description covers scope, relationship to reinstall_vps, and why the global catalog is not the same. Nothing an agent needs to choose and invoke this tool correctly 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 0%, and the only parameter is vps_id, which the description touches only as 'this specific VPS.' The parameter is self-descriptive from its name and type, but the description adds no detail on format, ownership, or how the ID should be obtained.

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 says exactly what the tool does: list the operating systems available to reinstall onto a specific VPS. It also differentiates from list_os_images by noting this is per-node availability rather than the full catalog, so an agent can tell them apart.

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 clearly anchors the tool to reinstall_vps and contrasts it with list_os_images' full catalog. The 'not every OS is available on every node' clause tells the agent when the per-VPS list is the right choice.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds only 'every' to signal exhaustive listing; it does not mention pagination, ordering, auth, or return-size limits, but for a simple list tool under rich annotations this is acceptable.

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 compact sentence front-loads the action and scope with zero filler. Every word earns its place.

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

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

For a low-complexity, read-only, idempotent list operation with one required parameter, the definition is nearly complete. The only notable gap is the absence of an output schema, so the exact return shape of the backup list must be inferred rather than documented.

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 one required string parameter, vps_id, with 0% description coverage. The description's 'this VPS' confirms that vps_id identifies the target VPS but provides no format, example, or validation details. This is minimally adequate for a single obvious ID parameter but does not fully compensate for the missing schema description.

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

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

States a concrete verb (List), a specific resource (backups), and a clear scope (of this VPS). It is immediately distinguishable from sibling tools like create_vps_backup or restore_vps_backup without needing to inspect their schemas.

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

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

The description carries implied usage: use this when you need a read-only inventory of a VPS's backups. However, it does not explicitly name sibling alternatives or state when not to use create/delete/restore operations, so routing guidance is left to inference.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds the 'currently attached' qualifier, indicating it returns the live state of attachments, but it does not disclose response format, ordering, or pagination behavior. With the annotation scaffolding, this is adequate but not rich.

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

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

A single, front-loaded sentence that conveys the core action and scope with no superfluous words. It is highly efficient and immediately understandable.

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

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

For a simple read-only tool with one required parameter and clear annotations, the description provides sufficient context to invoke the tool correctly. The lack of an output schema is mitigated by the tool's straightforward nature, though a note on return fields would make it complete.

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

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

Schema description coverage is 0%, so the description must compensate for the sole parameter vps_id. It implicitly clarifies that 'this VPS' refers to the VPS identified by vps_id, giving the parameter contextual meaning beyond the raw schema property title. However, it does not explain the expected format or constraints of the identifier, leaving some ambiguity.

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

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

The description uses a specific verb ('List') and a clear resource ('the disks currently attached to this VPS'), which precisely identifies the operation and scope. It does not explicitly name or differentiate from the sibling list_volumes, but the VPS-specific qualifier provides enough context to distinguish it from general volume listing.

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 should be used when the agent needs to see disks attached to a specific VPS, but it does not provide explicit guidance on when to prefer it over list_volumes or when not to use it. There are no alternatives or exclusions mentioned, so the usage context is left to inference.

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

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

The annotations only indicate this is not read-only and not marked destructive, but the description adds important operational context: no clean guest OS shutdown, equivalent to unplugging the machine. This goes beyond the structured annotation fields and helps an agent understand the risk profile.

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

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

Two short sentences, front-loaded with the core behavior, followed by a clear alternative. Every sentence earns its place and there is 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?

For a simple one-parameter mutation tool, the description covers the operation's nature, the risk, and the graceful alternative. It lacks explicit mention of return values, but no output schema exists and the behavior is sufficiently clear for correct invocation.

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

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

With only one parameter, vps_id, the schema's property name and title are sufficiently self-explanatory. However, schema description coverage is 0% and the description provides no additional parameter guidance, so the description itself adds nothing beyond the schema.

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

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

The description states the exact operation ('Hard power-off a VPS'), conveys the physical-world equivalent ('pulling the plug'), and distinguishes itself from stop_vps. There is no ambiguity about what action the tool performs.

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

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

It explicitly says when to use this tool and which sibling to use instead: 'Use stop_vps for a graceful shutdown instead.' This gives an agent clear routing between poweroff_vps and stop_vps.

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 annotations only indicate non-read-only and non-idempotent behavior, so the description carries the burden of explaining side effects. It does so thoroughly: 'Spends real money', checked against balance and quota, requires confirm=true, operates synchronously, and returns purchased addresses directly with no task to poll. This is exceptional behavioral disclosure beyond what annotations provide.

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

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

Three tightly packed sentences, each earning its place: what is purchased, limits and confirmation, and synchronous behavior. The most critical operational constraints are front-loaded, with no filler or redundant restating of the tool name.

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 no output schema, the description tells the agent exactly what to expect: purchased addresses are returned directly and no polling is needed. It also supplies cost, quota, confirmation, and quantity constraints, making the tool fully callable without requiring external knowledge.

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

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

Schema description coverage is 0%, so the description must compensate. It does: 'pop' is explained as a Point of Presence id from list_regions, 'quantity' is bounded by 'one or more' and 'at most 20', and 'confirm' is tied to spending real money via 'requires confirm=true'. All three parameters gain meaning beyond their bare schema 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 action ('Purchase'), the resource ('new standalone IP addresses'), and the scope ('in a region'). It differentiates this from related IP tools by emphasizing 'new standalone' addresses and the region/PoP requirement, so an agent can distinguish it from attach_ip, release_ip, or check_available_ips.

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 gives clear context: buy IPs in a region, at most 20, and only with confirm=true. It does not explicitly name alternative tools for attaching or managing existing IPs, but the 'new standalone' language implies when this tool is appropriate. The real-money warning also helps the agent decide whether to require confirmation.

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 goes well beyond the annotations by disclosing that the operation spends real money, checks balance and quota, requires explicit confirmation, behaves asynchronously by returning a task_id, and has region-dependent behavior with a notable error message. This gives the agent important expectations that annotations do not convey.

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 dense but relevant, covering purpose, cost, confirmation, kind semantics, regional caveats, and asynchronous behavior without wasted sentences. The parenthetical about the API's error message is slightly verbose but still useful. It is appropriately sized for the complexity of the operation.

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

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

For a tool with no output schema and sparse annotations, the description provides a strong operational picture: it states return behavior, follow-up polling steps, and the key constraints. The main completeness gap is the lack of guidance for required parameters pop and size_gb, which an agent would need to invoke the tool 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 0%, so the description carries the burden. It adds meaning for kind (data vs boot), confirm (real money), and vps_id (pinning in unsupported regions), but it does not explain the required pop or size_gb parameters, which remain ambiguous. Partial compensation, but with clear gaps.

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

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

The description opens with a specific verb and resource: 'Purchase a new standalone volume.' It also distinguishes itself from related volume operations by explaining that a boot volume is for a future VPS and is 'not attached to anything existing,' which differentiates it from attach_volume and related 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 gives strong context for when to use the tool, including the confirm=true requirement, the difference between data and boot volumes, and the region-specific rule requiring vps_id for data volumes where fleet-volume support is absent. It does not explicitly name alternative sibling tools, but the operational guidance makes the intended usage clear.

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