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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the shutdown prerequisite, which is a key behavioral trait, but lacks details on permissions needed, potential errors, or what happens if the instance isn't shut down. This leaves significant gaps for a mutation tool.

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

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

The description is well-structured and front-loaded with the core purpose, followed by a critical note and clear parameter/return sections. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool's complexity (a mutation with prerequisites), no annotations, and an output schema present (which handles return values), the description does a solid job. It covers purpose, key usage rule, and parameter meanings, but could improve by addressing permissions or error cases to be fully complete.

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

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

The description explicitly lists both parameters with brief explanations ('volume_id: The ID of the volume to attach', 'instance_id: The ID of the instance to attach to'), adding meaningful context beyond the schema's 0% coverage. This compensates well for the lack of schema descriptions, though it doesn't elaborate on format or validation rules.

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 'attach' and the resources 'volume' and 'instance', making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'detach_volume', but the action is specific enough to infer the distinction.

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

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

The description provides explicit guidance with 'Note: The instance must be shut down first,' which is crucial context for when to use this tool. However, it doesn't mention alternatives like 'detach_volume' or prerequisites beyond the shutdown requirement, leaving some gaps in full usage context.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral context. It mentions that returns include 'SSH connection info if running', which adds some value about conditional output. However, it doesn't disclose authentication needs, rate limits, error conditions, or what 'status' entails beyond SSH info, leaving significant gaps for a tool that presumably queries cloud infrastructure.

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 perfectly structured and concise: a clear purpose statement followed by well-organized Args and Returns sections. Every sentence earns its place, with no redundant or vague language. It's front-loaded with the core functionality.

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 moderate complexity (checking instance status in cloud infrastructure), the description is minimally adequate. The presence of an output schema means it doesn't need to detail return values, but with no annotations and incomplete behavioral context, it leaves the agent to guess about permissions, errors, and operational constraints. It meets the baseline for a read-only status check tool.

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

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

Schema description coverage is 0%, but the description compensates well by explaining the single parameter 'instance_id' as 'The ID of the instance to check', adding clear meaning beyond the schema's generic 'Instance Id' title. Since there's only one parameter and the description covers it fully, this earns a high score despite 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 clearly states the verb 'check' and the resource 'status of a specific instance', making the purpose unambiguous. It distinguishes from siblings like 'list_instances' (which lists multiple) and 'monitor_spot_availability' (which checks spot pricing). However, it doesn't explicitly differentiate from 'show_config' which might also show instance details, so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'list_instances' for status information, or whether it should be used before operations like 'start_instance' or 'delete_instance'. The agent must infer usage from the purpose alone.

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

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

With no annotations provided, the description carries the full burden. It discloses that it 'checks across all locations' and uses a specific SDK method, which adds useful behavioral context. However, it doesn't mention rate limits, authentication requirements, whether this is a read-only operation (implied but not stated), or what happens when parameters are omitted (defaults from config). The description adds some value but leaves significant behavioral aspects unspecified.

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 well-structured with clear sections: purpose statement, implementation detail, parameters, and return value. Each sentence earns its place by adding distinct information. At 5 sentences, it's appropriately sized for a tool with 2 parameters and important behavioral context. The front-loaded purpose statement immediately communicates the tool's function.

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 moderate complexity (2 parameters, no annotations, but with output schema), the description provides good coverage. It explains the purpose, parameters, and return value at a high level. Since an output schema exists, the description doesn't need to detail the return structure. The main gap is lack of explicit behavioral constraints (rate limits, auth), but overall it's reasonably complete for this context.

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

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

With 0% schema description coverage, the description must compensate for the schema's lack of documentation. It successfully explains both parameters: 'gpu_type' is described as 'GPU type to check' with examples, and 'gpu_count' as 'Number of GPUs' with examples. The description also clarifies that defaults come from config when parameters are omitted. This adds meaningful semantic context beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Check if spot GPU instances are available' with specific resource (spot GPU instances) and verb (check). It distinguishes from siblings like 'monitor_spot_availability' by focusing on a single availability check rather than ongoing monitoring. However, it doesn't explicitly contrast with 'deploy_spot_instance' which would be the logical next step after availability confirmation.

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 through the mention of 'spot GPU instances' and the SDK method, suggesting this is for checking availability before deployment. However, it doesn't provide explicit guidance on when to use this vs alternatives like 'monitor_spot_availability' (for continuous monitoring) or 'deploy_spot_instance' (for actual deployment). The context is clear but lacks explicit when/when-not statements.

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

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

With no annotations, the description carries full burden. It discloses key behaviors: creation of a new script, mutation of config.yaml, and effect on future deployments. However, it misses details like whether the operation is idempotent, permission requirements, or potential side effects on existing instances.

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 purpose, followed by brief elaboration and structured Arg/Return sections. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given 2 parameters, no annotations, and an output schema (which covers return values), the description is mostly complete. It explains the tool's dual action and parameters well, but could improve by addressing behavioral nuances like error conditions or config backup implications.

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 by explaining 'name' as 'Name for the new script' and 'content' as 'Bash script content', which clarifies their roles beyond schema titles. However, it doesn't specify constraints like name uniqueness or content length limits.

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 specific action: 'Create a new startup script and set it as the default for new instances.' It distinguishes from sibling tools like 'create_startup_script' (which only creates) and 'set_default_script' (which only sets default), making the combined purpose explicit.

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 ('for future instance deployments') and distinguishes from siblings by combining creation and default-setting. However, it lacks explicit guidance on when to use this vs. alternatives like 'create_startup_script' followed by 'set_default_script', or prerequisites like checking existing scripts.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Create a new startup script' which implies a write operation, but doesn't cover permissions needed, whether the script is immediately active, if it can be edited later, or any rate limits. The return value is mentioned but lacks detail on format or error handling. For a mutation tool with zero annotation coverage, this is insufficient.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by structured sections for Args and Returns. Every sentence earns its place by providing essential information without redundancy. It's appropriately sized for a simple tool with two parameters.

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 moderate complexity (creation operation), no annotations, and an output schema (implied by 'Returns'), the description is partially complete. It covers the basic purpose and parameters but lacks behavioral details like permissions or side effects. The output schema existence means return values don't need full explanation, but other gaps remain. This is adequate but with clear room for improvement.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful context by explaining that 'name' is for the script and 'content' is Bash script content, which clarifies the purpose and format beyond the bare schema. However, it doesn't cover constraints like name uniqueness or content length limits. With 2 parameters and low schema coverage, this is good but 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 verb 'Create' and resource 'startup script', making the purpose immediately understandable. It distinguishes this from siblings like 'get_instance_startup_script' (read) and 'list_scripts' (list), though it doesn't explicitly mention these alternatives. The purpose is specific but could be more differentiated from 'create_and_set_default_script'.

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

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

No guidance is provided on when to use this tool versus alternatives like 'create_and_set_default_script' or 'set_default_script'. The description doesn't mention prerequisites, context (e.g., after creating an instance), or exclusions. Usage is implied from the name and purpose but not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions the tool creates a volume and returns details, it lacks critical information such as permissions required, whether the volume is immediately usable, potential costs, rate limits, or error conditions. This is a significant gap for a creation tool with no 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?

The description is well-structured and front-loaded with the core purpose, followed by clear sections for arguments and returns. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool's complexity (creation operation), lack of annotations, and presence of an output schema (which handles return values), the description is moderately complete. It covers parameters well but lacks behavioral context like permissions or error handling, leaving gaps that could hinder effective use by an agent.

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

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

Schema description coverage is 0%, so the description must compensate. It effectively adds meaning by explaining each parameter: 'name' is for identification, 'size' is in GB with a default from config, and 'volume_type' is a string with a default. This clarifies semantics beyond the bare schema, though it doesn't specify allowed values or constraints for 'volume_type'.

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 'Create' and the resource 'block storage volume', making the purpose specific and unambiguous. It distinguishes this tool from siblings like 'attach_volume' or 'list_volumes' by focusing on creation rather than attachment or 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether a volume can be created independently or requires an instance), nor does it differentiate from other volume-related tools like 'attach_volume' or 'detach_volume' in terms of use cases.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a deletion operation and includes a safety check parameter, but doesn't mention permissions required, whether deletion is reversible, what happens to associated resources, or any rate limits. For a destructive tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is efficiently structured with a clear purpose statement followed by parameter and return explanations. Every sentence serves a purpose, though the 'Returns' section could be more specific given the output schema exists.

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

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

For a destructive tool with no annotations but with an output schema, the description covers the basic operation and parameters adequately. However, it lacks important context about irreversible consequences, dependencies, and permissions that would help an agent use this tool safely and appropriately.

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 well by explaining both parameters: 'instance_id' identifies what to delete and 'confirm' serves as a safety check. It adds meaningful context beyond the bare schema, though it doesn't specify format requirements for the ID.

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 'Delete' and resource 'instance', making the purpose unambiguous. However, it doesn't differentiate this destructive operation from sibling tools like 'shutdown_instance' or 'detach_volume', which also affect instances but in different ways.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'shutdown_instance' or 'detach_volume'. It mentions a safety check parameter but doesn't explain the broader context or prerequisites for deletion.

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

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

No annotations are provided, so the description carries full burden. It mentions that the tool returns 'Instance details and SSH connection info when ready' and that 'wait_for_ready' defaults to True, but doesn't disclose critical behavioral aspects like cost implications, spot instance reliability characteristics, permissions required, error handling, or what happens if spot capacity isn't available.

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?

Perfectly structured with a clear purpose statement followed by organized Args and Returns sections. Every sentence adds value with no redundancy. The information is front-loaded with the core purpose immediately stated.

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

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

Given the complexity of deploying spot instances with 7 parameters and no annotations, the description provides good parameter documentation but lacks important behavioral context. The existence of an output schema means return values don't need explanation, but critical operational details about spot instances are missing.

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

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

With 0% schema description coverage and 7 parameters, the description provides excellent parameter semantics. It explains each parameter's purpose, default behavior (e.g., 'default from config'), and practical implications (e.g., 'auto-generated if not provided'). This significantly compensates for the lack of schema descriptions.

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

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

The description clearly states the specific action ('Deploy a new spot GPU instance') with the resource type specified. It distinguishes from siblings like 'start_instance' or 'check_spot_availability' by focusing on deployment of spot instances with GPU capabilities.

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

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

No guidance is provided about when to use this tool versus alternatives. With siblings like 'start_instance', 'check_spot_availability', and 'list_instances', there's no indication of when spot deployment is preferable or what prerequisites might be 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the prerequisite ('instance must be shut down first'), which is useful context, but lacks details on permissions, side effects, error handling, or rate limits. It adequately describes the core action but misses broader behavioral traits.

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

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

The description is well-structured and front-loaded with the core purpose, followed by a note and clear sections for Args and Returns. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool's complexity (a destructive operation with a prerequisite), no annotations, and an output schema (which handles return values), the description is mostly complete. It covers purpose, usage guidelines, and parameters, but could improve by addressing permissions or error scenarios for full contextual understanding.

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

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

Schema description coverage is 0%, so the description must compensate. It explains 'volume_id' as 'The ID of the volume to detach', adding meaning beyond the schema's title 'Volume Id'. However, it doesn't specify format or constraints, leaving some gaps in parameter understanding.

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

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

The description clearly states the specific action ('detach') and resource ('a volume from its current instance'), distinguishing it from siblings like 'attach_volume' and 'create_volume'. It precisely defines the tool's function without ambiguity or tautology.

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 use this tool ('The instance must be shut down first') and implies alternatives by distinguishing from 'attach_volume'. It provides clear prerequisites and context for invocation, guiding the agent effectively.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves script details or a message if none exists, which covers basic output behavior. However, it lacks critical details: whether this is a read-only operation (implied but not stated), authentication requirements, error handling (e.g., invalid instance_id), rate limits, or data freshness. For a tool with no annotation coverage, this leaves significant gaps in understanding its operational traits.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by structured 'Args' and 'Returns' sections. Each sentence adds value: the purpose, parameter meaning, and return details. It avoids redundancy and is appropriately sized for a simple retrieval tool, though the 'Args' and 'Returns' labels could be integrated more smoothly into prose.

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 (1 parameter, no nested objects) and the presence of an output schema (which handles return value documentation), the description is reasonably complete. It covers purpose, parameter semantics, and high-level return behavior. However, it lacks context on authentication, errors, and sibling tool relationships, which are minor gaps in an otherwise straightforward tool.

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

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

The input schema has 0% description coverage, with only a title 'Instance Id' for the parameter. The description compensates by explaining that 'instance_id' is 'The ID of the instance', adding essential semantic context beyond the schema. It doesn't specify format (e.g., numeric vs. string) or sourcing (e.g., from 'list_instances'), but given the single parameter and low schema coverage, this is adequate for baseline understanding.

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

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

The description clearly states the verb 'Get' and the resource 'startup script attached to a specific Verda Cloud instance', making the purpose evident. It distinguishes from siblings like 'list_scripts' (which lists all scripts) and 'create_startup_script' (which creates new scripts) by focusing on retrieval for a specific instance. However, it doesn't explicitly contrast with 'show_config' or other instance-related tools, keeping it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., instance must exist), compare to 'list_scripts' for broader script discovery, or specify scenarios like debugging instance startup issues. Without such context, users must infer usage from the purpose alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action and return type, lacking details on permissions, rate limits, pagination, or error handling. This is insufficient for a tool with no 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?

The description is front-loaded with the core purpose in the first sentence and uses a second sentence to clarify the return value. It's efficient with no wasted words, though the structure could be slightly improved by integrating the return information more seamlessly.

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

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

Given the tool's simplicity (0 parameters, output schema exists), the description covers the basics but lacks depth. With no annotations and an output schema, it should ideally provide more behavioral context (e.g., sorting, filtering options) to be fully complete for agent use.

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 0 parameters with 100% schema description coverage, so the schema fully documents the inputs. The description doesn't need to add parameter details, and it appropriately avoids redundancy, earning a baseline score of 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 clearly states the tool's purpose with a specific verb ('List') and resource ('available OS images'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'list_instances' or 'list_volumes' beyond the resource type, which prevents a perfect score.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites, context, or comparison with other listing tools in the sibling set, leaving the agent to infer usage scenarios independently.

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

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

With no annotations provided, the description carries full burden. It discloses the return format and fields (ID, hostname, status, type, IP), which is valuable. However, it doesn't mention behavioral aspects like pagination, rate limits, authentication requirements, or whether this is a read-only operation (though 'List' implies safety).

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 waste. First sentence states purpose clearly, second describes return format. Both sentences earn their place by providing essential information without redundancy.

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

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

Given the tool's simplicity (0 parameters, read-only list operation) and the presence of an output schema, the description is reasonably complete. It explains what the tool does and what it returns. However, for a tool with no annotations, it could benefit from explicitly stating it's a read-only operation or mentioning any limitations.

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 with 100% schema description coverage, so the schema already fully documents the lack of inputs. The description appropriately doesn't discuss parameters, maintaining focus on the tool's purpose and output. Baseline for zero parameters is 4.

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

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

The description clearly states the verb ('List') and resource ('all your Verda Cloud instances') with specific scope ('with their status'). It distinguishes from siblings like 'check_instance_status' (single instance) and 'list_images' (different resource).

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

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

The description implies usage context by specifying 'all your instances' and 'with their status', suggesting this is for inventory overview rather than detailed status checks. However, it doesn't explicitly state when to use alternatives like 'check_instance_status' for single instances or 'list_volumes' for different resources.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return format ('A list of scripts with ID and name'), which is helpful, but lacks critical details like whether this is a read-only operation, if it requires authentication, how many scripts it returns (e.g., pagination limits), or if it includes default scripts. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 very concise with two short sentences that are front-loaded: the first states the purpose, and the second clarifies the return value. There's no wasted text, and it efficiently conveys key information. However, the structure could be slightly improved by integrating the return info more seamlessly, but it's still highly efficient.

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

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

Given the tool's simplicity (0 parameters, no annotations, but with an output schema that likely defines the return structure), the description is reasonably complete. It states what the tool does and what it returns, which covers the basics. The output schema should handle return value details, so the description doesn't need to elaborate further. For a simple list tool, this is adequate, though it could benefit from more behavioral context given the lack of annotations.

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

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

The tool has 0 parameters, and the schema description coverage is 100% (though empty). The description doesn't need to explain parameters, so it appropriately focuses on the output. Since there are no parameters to document, a baseline of 4 is justified as the description doesn't miss any parameter details.

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

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

The description clearly states the verb 'List' and the resource 'your startup scripts', making the purpose immediately understandable. It distinguishes from siblings like 'create_startup_script' or 'get_instance_startup_script' by focusing on listing all scripts rather than creating or fetching a specific one. However, it doesn't explicitly differentiate from 'list_instances' or 'list_volumes' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when you'd want to list scripts (e.g., before creating or setting a default) or clarify that this lists all scripts without filtering, unlike 'get_instance_startup_script' which fetches a specific script for an instance. No exclusions or prerequisites are stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the return format ('A list of SSH keys with ID and name'), which is helpful, but lacks critical details such as pagination, authentication requirements, rate limits, or error handling for a read operation.

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

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

The description is brief and front-loaded, with the core purpose stated first and return details following. Both sentences are relevant, though the return format could be integrated more seamlessly for slightly better structure.

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

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

Given the tool's simplicity (0 parameters, read-only operation) and the presence of an output schema, the description is adequate but minimal. It covers the basic purpose and return format, but for a tool with no annotations, it could benefit from more behavioral context like scoping or limitations.

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 0 parameters, and the input schema coverage is 100%, so no parameter documentation is needed. The description appropriately omits parameter details, earning a high baseline score for not adding unnecessary information.

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

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

The description clearly states the tool's purpose with a specific verb ('List') and resource ('SSH keys'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'list_images' or 'list_instances' beyond the resource type, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are no mentions of prerequisites, context, or comparisons to sibling tools like 'list_scripts' or 'list_volumes', leaving the agent with no usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the return format, which is helpful, but lacks critical details like whether this lists all volumes or requires pagination, if there are rate limits, authentication requirements, or any side effects. For a tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is extremely concise and front-loaded, with the core purpose stated in the first sentence and additional return details in the second. Every sentence earns its place by providing essential information without 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?

Given the tool's simplicity (0 parameters, output schema exists), the description is adequate but not fully complete. It covers the purpose and return format, but with no annotations and multiple sibling tools, it misses usage context and behavioral details that would help an agent operate effectively in this environment.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on output semantics by detailing the return fields (ID, name, size, attachment status), which adds value beyond the structured data. A baseline of 4 is justified as the description compensates for the lack of parameter complexity.

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

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

The description clearly states the verb ('List') and resource ('your block storage volumes'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'list_instances' or 'list_images' beyond the resource type, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'create_volume', 'attach_volume', and 'detach_volume', there's no indication of prerequisites, sequencing, or contextual triggers for listing volumes versus performing other volume-related operations.

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

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

No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: polling behavior ('Polls... until a spot becomes available'), default values, and conditional actions based on 'auto_deploy'. However, it lacks details on error handling, rate limits, or what happens if 'max_checks' is reached without availability, leaving some gaps.

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

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

The description is well-structured with a clear purpose statement, behavioral explanation, parameter details, and return info. It's appropriately sized for a complex tool, though the parameter section is lengthy but necessary. Minor redundancy in 'default from config' could be streamlined.

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 7 parameters, no annotations, and an output schema (which handles return values), the description is largely complete. It covers purpose, behavior, parameters, and returns. However, it could improve by addressing missing behavioral aspects like error handling or polling constraints, slightly reducing completeness.

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

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

Schema description coverage is 0%, so the description must compensate fully. It provides detailed semantics for all 7 parameters, including purpose, defaults, and conditional relevance (e.g., 'volume_id' and 'script_id' only if 'auto_deploy' is True). This adds significant value beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Monitor for spot GPU availability and optionally auto-deploy when available.' It specifies the verb ('monitor'), resource ('spot GPU availability'), and optional action ('auto-deploy'), distinguishing it from sibling tools like 'check_spot_availability' (which likely checks once) and 'deploy_spot_instance' (which deploys without monitoring).

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: monitoring for availability with optional deployment. It doesn't explicitly state when to use this tool versus alternatives like 'check_spot_availability' or 'deploy_spot_instance', but the monitoring aspect is clear. No exclusions or prerequisites are mentioned, keeping it at a 4.

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

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

No annotations are provided, so the description carries full burden. It mentions 'Set' (implying mutation) and 'Confirmation of the updated default' (hinting at a response), but fails to disclose critical behavioral traits like required permissions, whether this affects existing instances, potential side effects, or error conditions. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by structured 'Args' and 'Returns' sections. Every sentence earns its place: the purpose statement is clear, and the parameter and return explanations are necessary and concise without redundancy.

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

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

Given the tool's complexity (mutation with one parameter) and the presence of an output schema (implied by 'Returns' note), the description is moderately complete. It covers purpose and parameter semantics adequately, but lacks behavioral details like auth needs or impact scope, which are crucial for a mutation tool with no annotations.

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

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

With 0% schema description coverage (schema only provides title 'Script Id' and type 'string'), the description compensates by explaining that 'script_id' is 'The ID of an existing script to set as default', adding essential meaning beyond the bare schema. It clarifies the parameter's purpose and constraints, though it could specify format or sourcing details.

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 specific action ('Set an existing script as the default') and the target resource ('for new Verda Cloud instances'), distinguishing it from siblings like 'create_and_set_default_script' (which creates a new script) and 'get_instance_startup_script' (which retrieves). It uses precise verb+resource language without tautology.

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 specifying 'an existing script' and 'for new Verda Cloud instances', helping differentiate from 'create_and_set_default_script'. However, it lacks explicit when-not-to-use guidance or alternatives beyond what's inferred from sibling names, such as not using it for non-script resources or when creating a script from scratch.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool returns configuration 'without secrets,' which is useful behavioral context about data filtering. However, it doesn't mention other traits like whether it requires specific permissions, rate limits, or error conditions. The description adds some value but leaves gaps.

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

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

The description is two sentences with zero waste: the first states the purpose and scope, the second clarifies the return value. It's front-loaded with the core action and efficiently structured, with every sentence earning its place by adding necessary context.

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

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

Given the tool's simplicity (0 parameters, output schema exists), the description is mostly complete. It explains what the tool does and notes the 'without secrets' filter, which is crucial context. However, with no annotations, it could benefit from mentioning permission requirements or other behavioral details, but the output schema reduces the need for return value explanation.

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 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description doesn't need to add parameter information, and it appropriately focuses on the tool's purpose and output. Baseline for 0 parameters is 4, as it efficiently avoids redundant details.

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 specific action ('Show') and resource ('current MCP server configuration'), with explicit scope clarification ('without secrets'). It distinguishes from all sibling tools which manage cloud infrastructure (instances, volumes, scripts), making this a unique configuration inspection tool.

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 specifying it shows configuration 'without secrets,' suggesting it's for safe inspection. However, it doesn't explicitly state when to use this versus alternatives or mention prerequisites. The sibling tools are all infrastructure operations, so this stands alone for configuration viewing.

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

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

No annotations are provided, so the description carries full burden. It mentions the instance can be restarted later, which is useful context, but doesn't disclose required permissions, whether shutdown is immediate or graceful, potential data loss, or error conditions. For a destructive operation with zero annotation coverage, this is inadequate.

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 efficiently structured with a clear purpose statement, followed by separate Args and Returns sections. Every sentence adds value without redundancy, and it's appropriately sized for the tool's complexity.

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

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

Given the tool has an output schema (covering return values) and a simple parameter, the description is minimally complete. However, as a destructive operation with no annotations, it should provide more behavioral context about shutdown implications, permissions, or error handling.

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

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

Schema description coverage is 0%, but the description explicitly documents the single parameter 'instance_id' with a brief explanation. However, it doesn't add format details, validation rules, or examples beyond what the schema's type and title 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 clearly states the action ('shutdown') and resource ('a running instance'), and distinguishes it from permanent deletion by noting 'can be restarted later'. However, it doesn't explicitly differentiate from sibling tools like 'delete_instance' or 'start_instance' beyond the restart implication.

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 when an instance needs to be stopped temporarily rather than permanently deleted, but doesn't explicitly state when to use this vs. 'delete_instance' or 'start_instance'. No prerequisites or exclusions are mentioned.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('start') and return ('confirmation that start was initiated'), but lacks critical details: whether this requires specific permissions, if it's asynchronous, potential costs, rate limits, or what happens if the instance isn't stopped. For a mutation tool with zero annotation coverage, this is insufficient.

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

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

The description is efficiently structured with a clear purpose statement followed by Args and Returns sections. Every sentence serves a purpose, though the 'Returns' statement could be slightly more informative (e.g., mentioning what format the confirmation takes).

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 moderate complexity (starting instances), no annotations, and an output schema that presumably covers return values, the description is minimally adequate. It explains the parameter and basic behavior but misses important context like permissions, async nature, or error conditions that would be needed for robust use.

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

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

The description explicitly documents the single parameter 'instance_id' and its purpose ('The ID of the instance to start'), adding meaningful context beyond the schema's 0% coverage. Since there's only one parameter and the description fully explains it, this earns a high score despite 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 clearly states the action ('Start') and resource ('a stopped instance'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'shutdown_instance' or 'deploy_spot_instance' beyond the basic verb, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'deploy_spot_instance' or 'shutdown_instance'. It mentions the instance must be 'stopped', but this is implied by the action rather than explicit usage advice. No prerequisites or exclusions are stated.

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