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. 'Acquire' implies a write operation that creates or assigns an IP, but it doesn't specify permissions needed, whether it's idempotent, rate limits, or what happens on failure. This is a significant gap for a mutation tool with zero 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 a single, efficient sentence that front-loads the core action without any wasted words. It's appropriately sized for a tool with a straightforward purpose, making it easy to parse quickly.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'Acquire' entails (e.g., allocation, assignment), the return value, or error conditions. For a 3-parameter tool in a cloud infrastructure context, more detail is needed to guide effective 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?

Schema description coverage is 100%, with all three parameters (networkid, vpcid, zoneid) documented in the schema. The description adds no additional meaning about these parameters, such as their relationships or optionality. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Acquire') and resource ('new public IP address'), making the tool's purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_public_ip_addresses' or 'enable_static_nat', which might handle IP addresses differently, so it doesn't reach the highest 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 siblings like 'list_public_ip_addresses' for viewing IPs and 'enable_static_nat' for configuring them, there's no indication of prerequisites, context, or exclusions for this acquisition 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't describe what happens during attachment (e.g., whether the VM needs to be stopped, if data persists, potential downtime, or error conditions). For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding the tool's behavior.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resources, making it immediately understandable without unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool returns, error conditions, side effects, or operational constraints. Given the complexity of attaching storage volumes in cloud environments, more context is needed for safe and effective 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?

Schema description coverage is 100%, so the schema already documents all three parameters (deviceid, id, virtualmachineid) with basic descriptions. The description doesn't add any additional meaning about parameter usage, relationships, or constraints beyond what's in the schema, meeting the baseline for high 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 ('Attach') and target resources ('volume to virtual machine'), providing a specific verb+resource combination. It distinguishes from sibling tools like 'detach_volume' by specifying the opposite operation, though it doesn't explicitly mention all sibling differences.

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. While the name implies it's for attaching volumes, there's no mention of prerequisites (e.g., volume must be detached, VM must be stopped), constraints, or comparison with related tools like 'create_volume' or 'detach_volume'.

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 insight. It states the action is a 'change' (implying mutation) but doesn't disclose whether this requires specific permissions, if the VM needs to be in a particular state, potential downtime, side effects, or response format. For a mutation tool 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 a single, efficient sentence with zero wasted words. It's appropriately sized for a simple tool and front-loads the core purpose immediately.

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 this is a mutation tool with no annotations, no output schema, and 2 parameters, the description is incomplete. It lacks critical context about behavioral traits (e.g., VM state requirements, side effects), usage guidelines compared to siblings, and what constitutes a service offering. The 100% schema coverage helps with parameters but doesn't compensate for other 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 100%, with both parameters ('id' as VM ID, 'serviceofferingid' as new service offering ID) clearly documented in the schema. The description adds no additional parameter context beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the action ('change service offering') and target resource ('for virtual machine'), making the purpose understandable. It doesn't distinguish from siblings like 'scale_virtual_machine' or 'migrate_virtual_machine' which might have overlapping functionality, but the verb+resource combination is specific enough for basic understanding.

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. There's no mention of prerequisites (e.g., VM must be stopped), comparison to similar tools like 'scale_virtual_machine', or context about what service offerings represent. The agent must infer usage from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to do so. It does not mention whether this operation is idempotent, requires specific permissions, has side effects (e.g., affecting network traffic), or returns any output. This is inadequate for a mutation tool with zero 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 extremely concise with a single sentence ('Create a firewall rule'), which is front-loaded and wastes no words. However, this conciseness comes at the cost of under-specification, but per scoring rules, it earns a 5 for brevity and structure.

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

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

For a mutation tool with 5 parameters, no annotations, and no output schema, the description is severely incomplete. It lacks essential context such as behavioral traits, usage guidelines, and output expectations, making it inadequate for effective tool invocation by an AI agent.

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

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

Schema description coverage is 100%, with all parameters documented in the schema (e.g., 'cidrlist' as 'CIDR list (comma-separated)'). The description adds no parameter information beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage without compensating 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 'Create a firewall rule' is a tautology that restates the tool name without adding meaningful context. It specifies the verb ('Create') and resource ('firewall rule'), but lacks differentiation from sibling tools like 'create_security_group_rule' or details about what a firewall rule entails in this system.

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_security_group_rule' or other network-related tools. The description offers no context about prerequisites, typical scenarios, or exclusions, leaving the agent with no usage 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?

No annotations are provided, so the description carries full burden. It states 'Create a new network', implying a write/mutation operation, but doesn't disclose behavioral traits like required permissions, whether it's idempotent, rate limits, or what happens on failure. This is a significant gap for a creation tool with zero 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 a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for a basic tool definition, though this conciseness comes at the cost of detail in other dimensions.

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/mutation with 6 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, usage context, or return values, leaving the agent under-informed for a non-trivial operation.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters (e.g., name, gateway, zoneid). The description adds no meaning beyond the schema—it doesn't explain parameter relationships, dependencies, or provide examples. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description 'Create a new network' clearly states the action (create) and resource (network), but it's vague about what kind of network (e.g., virtual, physical, cloud) and doesn't distinguish from siblings like 'list_networks' or 'create_firewall_rule'. It provides basic purpose but lacks specificity.

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 offers no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing zone or network offering IDs), exclusions, or relationships with sibling tools like 'list_networks' for reference. This leaves 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Create' implies a mutation operation, the description doesn't address critical behavioral aspects: whether this requires specific permissions, what happens on success/failure, if the rule takes effect immediately, or potential side effects. For a security-related mutation tool, this represents significant gaps in transparency.

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

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

The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for a tool with good schema documentation and gets straight to the point with zero wasted text.

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

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

For a security-related mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what constitutes a successful creation, what format the response takes, or any error conditions. Given the complexity of security group rules and the lack of structured behavioral information, the description should provide more context about the operation's behavior and outcomes.

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

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

The input schema has 100% description coverage, providing clear documentation for all 6 parameters. The description adds no additional parameter information beyond what's already in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the 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?

The description clearly states the action ('Create') and the resource ('security group ingress rule'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'create_firewall_rule', which appears to serve a similar network security function, leaving some ambiguity about when to choose one over the other.

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 'create_firewall_rule' or other network-related tools. There's no mention of prerequisites, dependencies, or typical use cases, leaving the agent to infer usage context solely from the tool name and parameters.

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 snapshot' which implies a write/mutation operation, but doesn't mention any behavioral traits such as whether this is an asynchronous operation, if it requires specific permissions, potential impacts on the volume (e.g., brief performance degradation), or what the expected output might be. For a mutation tool 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 extremely concise at just 5 words, front-loading the essential information ('Create a snapshot of a volume') with zero wasted words. Every element earns its place, making it efficient for quick understanding.

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 this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after creation (e.g., snapshot state, return values), potential side effects, or usage constraints. For a tool that creates resources in a system, more context about behavior and outcomes is needed.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('name' and 'volumeid') with their descriptions. The tool description adds no additional parameter semantics beyond what's in the schema, but since the schema coverage is complete, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Create a snapshot') and the target resource ('of a volume'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_snapshots' or 'create_volume', which would require mentioning this is a write operation that creates a new snapshot rather than listing existing ones.

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., the volume must exist and be in a suitable state), when not to use it (e.g., during certain operations), or how it differs from related tools like 'list_snapshots' or 'create_volume'.

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. 'Create' implies a mutation, but the description doesn't state whether this requires specific permissions, what happens on failure, if the key pair is stored or returned, or any rate limits. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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 waste. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place without redundancy or unnecessary elaboration.

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

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

Given the complexity of creating an SSH key pair (a mutation with security implications), no annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like return values, error handling, or dependencies, leaving critical gaps for an agent to use this tool effectively in a cloud management context.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('name' and 'publickey') with clear descriptions. The description adds no additional meaning beyond what the schema provides, such as explaining naming conventions or public key format. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('Create') and resource ('new SSH key pair'), making the purpose immediately understandable. It distinguishes from sibling tools like 'list_ssh_key_pairs' by focusing on creation rather than listing. However, it doesn't specify what an SSH key pair is used for in this context, which could help differentiate from other creation tools like 'create_volume' or 'create_network'.

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., needing admin permissions), use cases (e.g., for VM access), or when not to use it (e.g., if an existing key pair suffices). With many sibling tools available, this lack of context leaves the agent guessing about appropriate scenarios.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Create a new volume' implies a write operation, but it does not disclose critical traits such as required permissions, whether the creation is asynchronous, potential costs or resource limits, or what happens on failure (e.g., error handling). This leaves significant gaps for an AI agent to understand the tool's behavior.

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

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

The description is extremely concise with just three words, making it front-loaded and easy to parse. However, it may be overly terse, as it lacks necessary context that could be added without sacrificing brevity. Every word earns its place, but more information could enhance usability without becoming verbose.

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

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

Given the complexity of a creation tool with no annotations and no output schema, the description is incomplete. It does not cover behavioral aspects (e.g., permissions, async nature), usage guidelines, or what to expect upon success/failure. For a tool that likely involves resource allocation and mutation, this minimal description is insufficient for an AI agent to use it effectively.

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

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

Schema description coverage is 100%, with clear descriptions for each parameter (e.g., 'Disk offering ID', 'Volume size in GB'). The description adds no additional meaning beyond the schema, such as explaining parameter interactions (e.g., 'size' is only for custom disk offerings) or constraints. Since the schema is well-documented, a baseline score of 3 is appropriate, but no extra value is provided.

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

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

The description 'Create a new volume' clearly states the action (create) and resource (volume), making the purpose understandable. However, it lacks specificity about what a 'volume' entails in this context (e.g., storage volume, data volume) and does not differentiate from sibling tools like 'attach_volume' or 'resize_volume', which are related but distinct 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?

No guidance is provided on when to use this tool versus alternatives. For example, it does not mention prerequisites (e.g., needing a disk offering or zone), when to use 'create_volume' vs. 'attach_volume' (for existing volumes), or 'resize_volume' (for modifying size). The description only states the action without context or exclusions.

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

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

With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose that this is a destructive/write operation, potential costs, time requirements, authentication needs, or what happens on failure. For a complex deployment tool, this leaves critical behavioral traits 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 a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource. While it lacks detail, what's present is structurally sound and appropriately concise for a tool name that clearly indicates the 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?

For a complex deployment tool with 9 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'deploy' means operationally, what happens after deployment, error conditions, or return values. The context demands more guidance about this significant infrastructure operation.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds no parameter-specific information beyond implying deployment involves some configuration. It doesn't explain relationships between parameters or provide usage examples, but the schema provides adequate baseline 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 'Deploy a new virtual machine' clearly states the action (deploy) and resource (virtual machine), but it's vague about scope and doesn't distinguish from siblings like 'create_volume' or 'create_network'. It specifies 'new' which helps differentiate from mutation tools like 'change_service_offering_virtual_machine', but lacks detail on what deployment entails.

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. For example, it doesn't mention prerequisites like needing a template or service offering, or when to use 'deploy_virtual_machine' versus 'scale_virtual_machine' or 'migrate_virtual_machine'. The description offers no context for 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?

With no annotations provided, the description carries full burden. It clearly states the tool is destructive and irreversible, and that it handles VMs in any state including Error. This is good transparency, though it could mention how associated resources are affected. The description adds significant behavioral context beyond the 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?

The description is a single sentence plus a parenthetical note, with no wasted words. It is front-loaded with the core action and uses a clear workflow arrow format. Every phrase 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?

For a destructive tool with two parameters and no output schema, the description covers the essential behavioral information: workflow, state handling, and irreversibility. It is complete enough for an agent to decide when to invoke this tool over others. Minor gap: no mention of return behavior, but not required without output schema.

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

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

The schema has 100% coverage for both parameters (id and expunge). The description does not add significant extra meaning beyond the schema; it mentions the workflow but does not tie it to the expunge parameter. At baseline 3, this is adequate since the schema already documents parameters clearly.

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 'Destroy a virtual machine' with a specific verb and resource, and includes the workflow 'stop → destroy → expunge'. It distinguishes from siblings like stop_virtual_machine by implying that this is the final destructive action, and mentions handling VMs in any state including Error.

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 (for permanent destruction) and that it handles the full workflow. It does not explicitly state when not to use it or name alternatives, but the context of sibling tools (e.g., stop_virtual_machine, reboot_virtual_machine) provides implicit guidance. The 'DESTRUCTIVE - cannot be undone' warning further clarifies the use case.

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 only states the basic action. It doesn't disclose critical behavioral traits such as whether this operation is reversible, requires specific permissions, affects VM availability, or has side effects like data loss—essential for a destructive-seeming operation.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately understandable without unnecessary elaboration.

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

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

For a tool that appears to perform a potentially destructive operation (detaching a volume) with no annotations and no output schema, the description is inadequate. It lacks information on consequences, success indicators, error conditions, or relation to sibling tools, leaving significant gaps in understanding.

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

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

Schema description coverage is 100%, so the parameter 'id' is documented in the schema as 'Volume ID'. The description adds no additional meaning about this parameter, such as format examples or where to find the ID, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('detach') and target resource ('volume from virtual machine'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'attach_volume' beyond the obvious directionality, missing explicit contrast in scope or effects.

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 or prerequisites. While the name implies it's the inverse of 'attach_volume', the description doesn't mention this relationship, leaving usage context entirely implicit.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It states the action ('Enable') but doesn't clarify if this is a mutating operation, what permissions are required, whether it's reversible, or any side effects like network disruption. This is a significant gap for a tool that likely modifies network configurations.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the key action and resources, making it easy to parse quickly.

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

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

Given the complexity of a networking tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'static NAT' entails, the expected outcome, error conditions, or how it interacts with other tools. For a mutating operation in this context, more detail is needed to guide the agent effectively.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the input schema (e.g., 'Public IP address ID', 'VM ID'). The tool description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 for adequate but not enhanced 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 ('Enable static NAT') and the resources involved ('for an IP to a VM'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'associate_ip_address' or 'create_firewall_rule', which might handle similar networking functions, so it doesn't reach the highest 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, such as 'associate_ip_address' or other networking tools in the sibling list. It lacks context about prerequisites, typical scenarios, or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves details but doesn't specify what details are included, whether it's a read-only operation, if authentication is required, or how errors are handled. This leaves significant gaps in understanding the tool's behavior beyond the basic action.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action, making it easy to parse quickly.

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

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

For a simple read operation with one parameter and no output schema, the description is minimally adequate but lacks completeness. It doesn't explain what details are returned, potential error conditions, or how it differs from similar tools, leaving the agent with incomplete context for effective 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 input schema has 100% description coverage, with the 'id' parameter clearly documented as 'VM ID'. The description adds no additional meaning beyond this, as it doesn't elaborate on ID format, sourcing, or validation. Given the high schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('Get details') and resource ('of a specific virtual machine'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_virtual_machines' (which presumably lists multiple VMs) or 'list_virtual_machine_metrics' (which might provide performance data), so it doesn't fully distinguish from alternatives.

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 sibling tools like 'list_virtual_machines' for browsing or 'deploy_virtual_machine' for creation, nor does it specify prerequisites or appropriate contexts for retrieving details of a specific VM.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal insight. 'List accounts' implies a read-only operation, but it doesn't specify authentication requirements, rate limits, pagination behavior, or what happens if no accounts match the filters, leaving critical behavioral traits undocumented.

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

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

The description is extremely concise with just two words, 'List accounts', which is front-loaded and wastes no space. However, this conciseness comes at the cost of under-specification, but based on the scoring criteria, it earns full points for brevity and structure.

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

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

Given the tool's complexity (3 parameters, no output schema, no annotations), the description is incomplete. It fails to explain the tool's purpose in context, usage guidelines, or behavioral aspects, leaving significant gaps for an AI agent to understand 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?

The input schema has 100% description coverage, clearly documenting all three parameters (accounttype, domainid, state). The description adds no additional meaning beyond what the schema provides, such as how filters interact or default behaviors, so it meets the baseline score of 3 for high schema coverage.

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

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

The description 'List accounts' is a tautology that merely restates the tool name without adding specificity. It doesn't clarify what type of accounts (e.g., user accounts, system accounts) or what scope (e.g., all accounts, filtered accounts) are being listed, nor does it distinguish this tool from sibling list tools like 'list_users' or 'list_domains'.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites, appropriate scenarios, or comparisons to sibling tools such as 'list_users', making it unclear when this tool is the correct choice for an AI 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'List system alerts' but does not describe any behavioral traits, such as whether this is a read-only operation, if it requires specific permissions, how results are returned (e.g., pagination, format), or any rate limits. This leaves significant gaps in understanding how the tool behaves in practice.

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 'List system alerts' is extremely concise, consisting of just three words that directly state the tool's function. It is front-loaded with no unnecessary details, making it easy to parse quickly. This efficiency is appropriate for a simple tool, though it may sacrifice completeness for 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 the complexity (a list operation with potential filtering), no annotations, and no output schema, the description is incomplete. It does not explain what 'system alerts' includes, how results are structured, or any behavioral aspects like safety or performance. For a tool in a server with many sibling operations, more context is needed to ensure proper use without relying on 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?

The input schema has 1 parameter with 100% description coverage ('Alert type'), so the schema already documents the parameter. The description does not add any meaning beyond this, such as examples of alert types or how filtering works. With high schema coverage, the baseline score is 3, as the description does not compensate but also does not detract from the schema's 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 'List system alerts' clearly states the verb ('List') and resource ('system alerts'), making the basic purpose understandable. However, it lacks specificity about what 'system alerts' entails (e.g., types, severity, source) and does not distinguish this tool from sibling list_* tools like list_events or list_async_jobs, which might also involve alert-like data. This results in a vague but not tautological 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 provides no guidance on when to use this tool versus alternatives. It does not mention any context, prerequisites, or exclusions, such as how it differs from other list_* tools (e.g., list_events for historical events vs. alerts for current issues). Without such information, users must infer usage from the tool name alone, which is insufficient for effective decision-making.

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 but only states the action without details on permissions, rate limits, pagination, or output format. It doesn't explain what 'asynchronous jobs' entail in this context or how results are returned, leaving significant gaps for a tool that likely involves operational data.

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 wasted words. It's front-loaded with the core purpose and appropriately sized for a simple listing tool, making it easy to parse quickly.

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

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

Given the complexity of listing jobs (which may involve status tracking and search), no annotations, and no output schema, the description is insufficient. It doesn't cover behavioral aspects like what constitutes a job, how results are structured, or error handling, leaving the agent with incomplete information for proper tool 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 100%, so the input schema fully documents both parameters (jobstatus and keyword). The description adds no additional parameter semantics beyond what's in the schema, but this is acceptable given the high coverage, resulting in a baseline score of 3.

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

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

The description 'List asynchronous jobs' clearly states the verb ('List') and resource ('asynchronous jobs'), making the tool's purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_accounts' or 'list_virtual_machines' beyond the resource type, missing specific scope or filtering characteristics that would distinguish it more clearly.

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, context for job listing, or compare it to other list tools in the sibling set, leaving the agent to infer usage based on the name alone.

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

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

No annotations are provided, so the description carries full burden. It states 'List system capacity information', implying a read-only operation, but doesn't disclose behavioral traits such as authentication requirements, rate limits, pagination, or what the output format looks like (e.g., JSON structure, units). This is a significant gap 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 a single, efficient sentence with no wasted words. It's front-loaded and appropriately sized for a simple listing tool, making it easy to parse quickly.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'capacity information' includes (e.g., metrics, units), how results are structured, or any prerequisites. For a tool in a complex system with many siblings, this leaves too much ambiguity for effective 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 input schema has 100% description coverage, with clear documentation for 'type' and 'zoneid' parameters. The description adds no additional semantic meaning beyond the schema, such as explaining how these parameters affect the listing (e.g., filtering logic). Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description 'List system capacity information' clearly states the action (list) and resource (system capacity information), which is adequate. However, it lacks specificity about what 'capacity information' entails (e.g., metrics, limits, usage) and doesn't differentiate from siblings like 'list_storage_pools' or 'list_hosts' that might overlap in resource monitoring contexts.

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. With many sibling tools for listing resources (e.g., 'list_storage_pools', 'list_hosts'), the description doesn't clarify if this is for overall system metrics, capacity planning, or filtering specific types, leaving usage context ambiguous.

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. 'List clusters' gives no indication of whether this is a read-only operation, what permissions are required, whether it's paginated, what the output format is, or any rate limits. For a tool with no annotation coverage, this is a significant gap in transparency.

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 at just two words, with zero wasted text. It's front-loaded and to the point, though this conciseness comes at the cost of completeness. Every word earns its place by directly stating the action, but it lacks necessary detail.

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

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

Given the complexity of a list operation with filtering parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what 'clusters' are in this context, how results are returned, or any behavioral aspects. For a tool with 2 parameters and no structured guidance, this description fails to provide adequate context for an AI agent.

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

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

The input schema has 100% description coverage, with clear parameter descriptions for 'hypervisor' and 'zoneid.' The tool description adds no additional parameter semantics beyond what's already in the schema. According to the rules, when schema_description_coverage is high (>80%), the baseline score is 3 even with no param info in the 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?

The description 'List clusters' is a tautology that merely restates the tool name without adding any meaningful context. It doesn't specify what type of clusters (compute, storage, network?) or what resource scope (all clusters? filtered?). While it includes the verb 'list,' it lacks the specificity needed to distinguish this tool from other list_* siblings like list_hosts or list_zones.

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 any prerequisites, context for filtering (e.g., hypervisor or zoneid parameters), or relationship to sibling tools like list_hosts or list_zones that might overlap in functionality. This leaves 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. 'List domains' gives no indication of whether this is a read-only operation, what permissions might be required, whether it's paginated or returns all results at once, or any error conditions. For a tool with no annotation coverage, this description fails to provide essential behavioral context that would help an agent invoke it correctly.

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

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

The description is extremely concise—just two words—and front-loaded with the core action. There's no wasted language or unnecessary elaboration. While this conciseness comes at the cost of completeness, it efficiently communicates the basic intent without verbosity.

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

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

Given the lack of annotations and output schema, the description is incomplete for a tool with parameters. It doesn't explain what 'domains' refers to in this context, what the tool returns, or any behavioral aspects. For a list operation with filtering parameters, this minimal description leaves too many open questions for effective use by an AI agent.

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

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

The input schema has 100% description coverage, with clear documentation for both parameters ('level' and 'name'). The description adds no additional information about these parameters, such as example values, constraints, or how they interact. Since the schema already does the heavy lifting, the baseline score of 3 is appropriate—the description neither compensates for gaps nor adds value beyond the schema.

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

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

The description 'List domains' is a tautology that merely restates the tool name without adding any meaningful context. It doesn't specify what kind of domains (e.g., network domains, DNS domains, organizational domains) or what scope is involved. While it does include a verb ('List') and resource ('domains'), it lacks the specificity needed to distinguish this tool from potential alternatives or clarify its exact function beyond the obvious.

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 any prerequisites, context for usage, or relationship to sibling tools (e.g., other 'list_' tools like list_networks or list_users). Without this information, an AI agent would have to infer usage from the tool name alone, which is insufficient for informed decision-making.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'List system events' implies a read-only operation, but doesn't disclose important behavioral traits: whether this requires specific permissions, what format the listing returns (pagination, sorting, default ordering), rate limits, or whether it's a real-time vs historical query. The description provides minimal behavioral context beyond the basic 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 maximally concise at just three words ('List system events'), with zero wasted language. It's front-loaded with the core action and resource. While potentially under-specified, it achieves perfect conciseness for what it does communicate.

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 no annotations and no output schema, the description provides insufficient context for a tool with 4 filtering parameters. For a listing operation that likely returns structured data, the description should at minimum indicate the scope of 'system events' and basic return characteristics. The combination of minimal description with no structured metadata leaves significant gaps in understanding how to effectively use this tool.

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

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

Schema description coverage is 100%, with all 4 parameters well-documented in the schema itself (date formats, event level values, event type). The description adds no parameter semantics beyond what's already in the schema - it doesn't explain relationships between parameters (like date range filtering), default behaviors, or parameter constraints. With complete schema coverage, the baseline of 3 is appropriate.

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

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

The description 'List system events' clearly states the verb ('List') and resource ('system events'), which provides basic purpose. However, it doesn't differentiate this tool from other list_* siblings (like list_alerts, list_async_jobs, list_security_groups), leaving ambiguity about what specifically distinguishes 'system events' from other listable entities in this system.

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 multiple list_* tools available (including list_alerts and list_async_jobs which might overlap with 'events'), there's no indication of when this specific listing is appropriate versus other listing tools. No prerequisites, exclusions, or alternatives are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List hosts' gives no information about whether this is a read-only operation, if it requires authentication, what the output format might be, or any rate limits. It fails to describe any behavioral traits beyond the basic action implied by the name.

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

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

While 'List hosts' is extremely concise, it's under-specified rather than efficiently informative. The single phrase doesn't front-load critical information or provide any structure. It fails to earn its place by adding value beyond the tool name, making it inadequate despite its 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 the complexity of a tool with 4 parameters and no output schema or annotations, the description is completely inadequate. It doesn't explain what 'hosts' are in this context, what the listing includes, or how to interpret results. For a tool that likely returns structured data about infrastructure resources, this leaves significant gaps in understanding.

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

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

The input schema has 100% description coverage, with clear parameter descriptions (e.g., 'Hypervisor type', 'Host state'). The tool description adds no additional parameter semantics beyond what the schema already provides. According to the rules, when schema coverage is high (>80%), the baseline score is 3 even without param info in the 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?

The description 'List hosts' is a tautology that merely restates the tool name without adding any meaningful context. It doesn't specify what kind of hosts (e.g., virtual machine hosts, network hosts) or what information is included in the listing. While it indicates a listing action, it lacks the specificity needed to distinguish it from other list tools in the sibling set.

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 any prerequisites, context for filtering hosts, or how it differs from other list tools like 'list_virtual_machines' or 'list_system_vms' in the sibling set. This leaves the agent with no usage 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action 'List' without detailing traits like whether it's read-only, paginated, rate-limited, or what the output format might be. For a tool with no annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that is front-loaded with the core action. It avoids unnecessary words, making it appropriately concise. However, it lacks structure that could enhance clarity, such as separating purpose from usage notes.

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 listing operations in a cloud environment, no annotations, and no output schema, the description is incomplete. It fails to address behavioral aspects like pagination, error handling, or output format, leaving gaps that could hinder an agent's ability to use the tool effectively.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters (publicipid and zoneid as filters). The description adds no additional parameter semantics beyond what the schema provides, but since the schema adequately covers the parameters, the baseline score of 3 is appropriate.

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

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

The description 'List load balancer rules' restates the tool name with minimal elaboration, making it a tautology. It specifies the verb 'List' and resource 'load balancer rules' but lacks differentiation from sibling tools like 'list_networks' or 'list_security_groups', failing to clarify what makes this listing operation unique or its scope beyond the name.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, context, or exclusions, such as whether it requires specific permissions or how it relates to other list tools. This leaves the agent without direction on appropriate usage scenarios.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure but offers none. 'List networks' doesn't indicate whether this is a read-only operation, what permissions are required, whether results are paginated, or what format the output takes. For a tool with 3 parameters and no output schema, this leaves significant behavioral questions unanswered.

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 maximally concise with just two words. While this represents under-specification rather than ideal conciseness, according to the scoring framework, 'Process' received a 2 for being under-specified, while this is even more minimal. However, given the explicit scoring guidance that 'Process' got 2 for conciseness, this similarly minimal description should receive a comparable score for being appropriately sized but lacking substance.

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

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

For a listing tool with 3 parameters, no annotations, and no output schema, the description is severely incomplete. It doesn't explain what 'networks' means in this context, what information is returned, or how results are structured. The agent would need to guess about the tool's behavior and output format based solely on the parameter schema.

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

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

The schema has 100% description coverage, providing clear documentation for all 3 parameters (isdefault, type, zoneid). The description adds no parameter information beyond what's already in the schema. According to scoring rules, with high schema coverage (>80%), the baseline is 3 even when the description provides no 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 'List networks' is a tautology that merely restates the tool name without adding any meaningful context. It doesn't specify what kind of networks, from what system, or what scope is involved. While it's clear this is a listing operation, it lacks the specificity needed to distinguish it from potential alternatives.

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. Given the sibling tools include 'create_network' and various other network-related operations, there's no indication whether this is for inventory, discovery, or configuration purposes. The agent must infer usage from context 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. 'List public IP addresses' implies a read-only operation, but it doesn't specify whether this requires authentication, returns paginated results, includes metadata, or has rate limits. For a tool with zero annotation coverage, this leaves significant behavioral gaps, though it doesn't contradict any 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 extremely concise with just three words, front-loading the core action and resource. There's no wasted language or redundancy, making it easy to parse quickly. However, this conciseness comes at the cost of completeness, as noted in other dimensions.

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 (3 parameters, no output schema, no annotations), the description is incomplete. It lacks details on behavioral traits, usage context, and output format, which are crucial for an AI agent to invoke it correctly. Without annotations or an output schema, the description should provide more context to compensate, but it doesn't.

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

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

The input schema has 100% description coverage, with clear documentation for all three parameters (allocatedonly, isstaticnat, zoneid). The description adds no parameter information beyond what's in the schema, so it doesn't enhance semantics. According to the rules, when schema coverage is high (>80%), the baseline score is 3 even without param details in the 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?

The description 'List public IP addresses' clearly states the verb ('List') and resource ('public IP addresses'), making the basic purpose understandable. However, it lacks specificity about scope or format, and doesn't differentiate from sibling tools like 'associate_ip_address' or 'enable_static_nat' that also involve IP addresses. The purpose is stated but remains vague about what exactly gets listed.

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, context (e.g., for monitoring, allocation checks), or comparisons to sibling tools like 'list_networks' or 'list_virtual_machines' that might relate to IP addresses. Usage is implied only by the name, with no explicit when/when-not instructions.

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. 'List security groups' implies a read-only operation but does not specify whether it returns all security groups, requires permissions, supports pagination, or has rate limits. For a tool with potential security implications, this lack of detail is a significant gap in transparency.

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

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

The description is extremely concise with just three words, making it front-loaded and waste-free. However, it is overly terse to the point of under-specification, lacking necessary context for effective use. While efficient, it sacrifices clarity for 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 no annotations and no output schema, the description is incomplete for a tool that lists security groups—a critical security resource. It fails to explain return values, error conditions, or how parameters interact (e.g., filtering by name vs. VM association). In a server with many infrastructure management tools, this leaves too much undefined for reliable agent operation.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the input schema (e.g., 'Security group name to filter', 'VM ID to show associated security groups'). The tool description adds no parameter information beyond the schema, but the schema adequately documents the two optional parameters, meeting the baseline for high 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 'List security groups' is a tautology that restates the tool name without adding meaningful context. It specifies the verb 'list' and resource 'security groups', but lacks details about scope, format, or differentiation from sibling tools like 'create_security_group_rule' or 'list_networks'. This minimal statement provides no insight beyond the obvious.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention filtering capabilities (via parameters), prerequisites, or related tools for creating or modifying security groups. With many sibling tools for managing virtual machines and networks, the absence of usage context leaves the agent guessing about appropriate scenarios.

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

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

With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't disclose if this is a read-only operation, pagination behavior, rate limits, authentication needs, or what 'compute plans' entail, which is insufficient for a tool with potential complexity.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly, which is ideal for conciseness.

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

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

Given no annotations and no output schema, the description is incomplete. It lacks details on return values, error handling, or operational context (e.g., how offerings relate to other resources), making it inadequate for a tool that might be part of a larger provisioning workflow.

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 adds no parameter information beyond the input schema, which has 100% coverage with clear descriptions for both parameters. This meets the baseline of 3, as the schema adequately documents the parameters without needing extra detail from the 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?

The description clearly states the verb ('List') and resource ('service offerings'), with additional context in parentheses ('compute plans') that clarifies the domain. It distinguishes from siblings like 'list_virtual_machines' or 'list_templates' by specifying the resource type, though it doesn't explicitly contrast with them.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., for provisioning resources), or exclusions, leaving the agent to infer usage from the tool name alone among many list-related 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?

With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose whether this is a read-only operation, if it requires authentication, what the output format looks like (e.g., list structure, pagination), or any rate limits—critical gaps for a tool with potential data access.

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 wasted words—'List volume snapshots' directly conveys the core action and resource. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.

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

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

Given the complexity (a list operation with filtering parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain return values, error conditions, or behavioral traits, leaving significant gaps for the agent to operate effectively in 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?

Schema description coverage is 100%, so the schema fully documents both parameters (intervaltype, volumeid) with descriptions. The tool description adds no additional parameter semantics beyond what's in the schema, meeting the baseline for high coverage but not enhancing 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 ('List') and resource ('volume snapshots'), making the purpose immediately understandable. However, it doesn't distinguish this tool from other list_* siblings (like list_volumes, list_virtual_machines) beyond the specific resource type, missing explicit differentiation about scope or relationship to create_snapshot.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing volume access), exclusions, or how it relates to sibling tools like create_snapshot or list_volumes, leaving the agent to infer 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, the description carries the full burden of behavioral disclosure. It only states the action without details on permissions, rate limits, pagination, or output format. This is inadequate for a tool with potential complexity in listing operations.

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

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

The description is extremely concise with a single sentence, 'List SSH key pairs', which is front-loaded and wastes no words. It efficiently conveys the core action without unnecessary elaboration.

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

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

Given no annotations, no output schema, and a tool that likely returns a list of key pairs, the description is incomplete. It fails to explain behavioral traits, return values, or usage context, leaving significant gaps for an AI agent to understand the tool fully.

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

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

The input schema has 100% description coverage, documenting both 'fingerprint' and 'name' as filters. The description adds no parameter semantics beyond what the schema provides, so it meets the baseline for high schema coverage without compensating 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 'List SSH key pairs' states the verb ('List') and resource ('SSH key pairs'), providing a basic purpose. However, it lacks specificity about scope (e.g., all key pairs or filtered) and does not distinguish it from sibling tools like 'create_ssh_key_pair', making it vague but functional.

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, such as filtering options or prerequisites. The description does not mention sibling tools or contexts, leaving usage unclear beyond the basic action.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'List storage pools' implies a read-only operation but doesn't specify whether it returns all pools or requires filtering, pagination behavior, authentication needs, rate limits, or error conditions. For a tool with no annotation coverage, this minimal description fails to provide necessary operational context.

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

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

The description is extremely concise at just two words, with zero wasted language. It's front-loaded with the core action ('List') and resource ('storage pools'), making it easy to parse. While under-specified, every word earns its place by stating the basic function 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 (a list operation with filtering parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what a storage pool is, how results are returned, whether filtering is required, or any behavioral aspects. For a tool in a crowded namespace of list_* siblings, this minimal description leaves significant gaps for agent understanding.

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

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

Schema description coverage is 100%, with both parameters (clusterid, zoneid) clearly documented in the schema. The description adds no parameter information beyond what's in the schema, so it doesn't compensate but also doesn't detract. According to scoring rules, when schema coverage is high (>80%), the baseline score is 3 even with no param info in the 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?

The description 'List storage pools' is a tautology that merely restates the tool name without adding specificity. It doesn't distinguish this tool from its many sibling list_* tools (like list_volumes, list_networks, etc.), nor does it clarify what a 'storage pool' is in this context. While the verb 'List' is clear, the resource 'storage pools' lacks differentiation from similar resources in the sibling set.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention any prerequisites, context for filtering (e.g., when to use clusterid vs zoneid), or relationships to other tools (like list_volumes or list_capacity). With many list_* siblings, this omission leaves the agent without direction on tool selection.

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

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

No annotations are provided, so the description carries full burden. It only states what the tool does (listing) without disclosing behavioral traits like pagination, rate limits, authentication requirements, or what happens if no VMs match filters. For a listing operation with zero annotation coverage, this is insufficient transparency.

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

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

The description is extremely concise - a single sentence that efficiently communicates the core purpose. Every word earns its place, with no redundant information. The structure is front-loaded with the main action and resource.

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 no annotations, no output schema, and multiple parameters, the description is incomplete. It doesn't explain what the tool returns, how results are formatted, or important behavioral aspects. For a listing tool in a complex infrastructure management context with many sibling tools, more context is needed for the agent to use it effectively.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description doesn't add any parameter-specific information beyond what's in the schema. According to guidelines, when schema coverage is high (>80%), the baseline score is 3 even with no param info in 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?

The description clearly states the verb ('List') and resource ('system VMs') with specific examples of what types are included ('console proxy, secondary storage'). It distinguishes from generic VM listing tools like 'list_virtual_machines' by focusing on system infrastructure VMs. However, it doesn't explicitly contrast with all sibling tools, keeping it at 4 instead of 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, appropriate contexts, or exclusions. With many sibling tools for managing VMs and infrastructure, the lack of usage guidance leaves the agent uncertain about when this specific listing 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List templates' implies a read-only operation, but it doesn't specify whether this requires authentication, what permissions are needed, if there are rate limits, pagination behavior, or what the output format looks like. For a tool with zero annotation coverage, this leaves critical behavioral traits undocumented.

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 at just two words, with zero wasted language. It is front-loaded with the core action, though this brevity comes at the cost of clarity and completeness. Every word earns its place, but there are too few words to be helpful.

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

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

Given the lack of annotations and output schema, the description is incomplete for a tool with three parameters. It fails to explain the purpose, usage context, or behavioral traits, leaving significant gaps. While the schema covers parameters well, the overall context for tool selection and invocation is inadequate.

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

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

The input schema has 100% description coverage, with clear documentation for all three parameters (hypervisor, templatefilter, zoneid), including a default value and allowed values for templatefilter. The description adds no parameter semantics beyond what the schema already provides, so it meets the baseline score of 3 for high schema coverage.

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

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

The description 'List templates' is a tautology that merely restates the tool name without adding any meaningful context. It doesn't specify what kind of templates (VM templates, configuration templates, etc.) or what scope (all templates, filtered templates). While it includes the verb 'list,' it lacks the specificity needed to distinguish this tool from other list_* siblings in the server.

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 multiple list_* tools in the sibling list (e.g., list_virtual_machines, list_volumes), but no indication is given about how list_templates differs or when it should be selected. No context, exclusions, or prerequisites 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 the full burden of behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't clarify permissions, rate limits, pagination, or output format. For a tool with billing data, this lack of detail on sensitivity or access constraints is a significant gap.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and avoids unnecessary elaboration, making it easy for an agent to parse quickly.

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

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

Given the complexity of billing data and lack of annotations or output schema, the description is insufficient. It doesn't explain what 'usage records' include, how results are structured, or any behavioral traits like error handling. For a tool with potential financial implications, more context is needed.

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

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

The input schema has 100% description coverage, clearly documenting all three parameters (startdate, enddate, type) with formats and requirements. The description adds no additional parameter semantics beyond implying date-range filtering for billing records. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb ('List') and resource ('usage records for billing'), making the purpose unambiguous. It distinguishes itself from siblings by focusing on billing-related usage records rather than infrastructure components like virtual machines or networks. However, it doesn't specify the exact scope or format of the listing, 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, context for billing analysis, or how it differs from other list tools like list_events or list_accounts. The agent must infer usage from the name and parameters 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. 'List users' gives no information about permissions required, pagination, rate limits, output format, or whether this is a read-only operation. For a tool with 3 parameters and no output schema, this is critically 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 extremely concise at just two words. While this reflects severe under-specification in other dimensions, from a pure conciseness perspective it's minimal with zero wasted words. Every word earns its place, though there are too few words overall.

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 (3 parameters, no output schema, no annotations), the description is completely inadequate. It doesn't explain what 'users' means in this context, what the output looks like, or any behavioral characteristics. The agent would struggle to use this tool effectively based solely on the description.

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

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

Schema description coverage is 100%, so all parameters (account, domainid, state) are documented in the schema. The description adds no additional parameter context beyond what the schema provides. According to guidelines, when schema coverage is high (>80%), the baseline score is 3 even with no param info in the 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?

The description 'List users' is a tautology that merely restates the tool name without adding specificity. It doesn't distinguish this tool from other list_* tools in the sibling set (like list_accounts, list_virtual_machines, etc.) or clarify what type of users are being listed (e.g., system users, cloud users, account users).

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's no mention of prerequisites, context, or comparison to other tools in the sibling set (like list_accounts which might relate to user accounts). The agent receives no usage 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action ('List') without detailing whether this is a read-only operation, if it requires specific permissions, what the output format looks like (e.g., metrics types, time ranges), or any rate limits. This is inadequate for a tool that likely returns performance data.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded with the core purpose, making it easy to scan and understand quickly, which is ideal for conciseness.

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

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

Given the complexity of performance metrics (which could include CPU, memory, network data, etc.), no annotations, and no output schema, the description is insufficient. It doesn't explain what metrics are returned, their format, or any behavioral aspects like pagination or authentication needs, leaving significant gaps for the agent.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('id' and 'zoneid') with clear descriptions. The description adds no additional meaning beyond implying metrics are for VMs, which is already inferred from the tool name and schema. Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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') and resource ('virtual machine performance metrics'), making the purpose understandable. However, it doesn't distinguish this tool from its sibling 'list_virtual_machines', which might list VMs themselves rather than their metrics, leaving some ambiguity about differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get_virtual_machine' or 'list_virtual_machines'. The description lacks context about prerequisites, such as needing VM IDs from other tools, or exclusions, leaving the agent without clear usage 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the basic action ('List') without mentioning whether this is a read-only operation, if it requires authentication, what the output format looks like, or if there are pagination or rate limits. This leaves significant gaps for a tool that interacts with 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 a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It's front-loaded and wastes no space, making it easy to parse quickly.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't address behavioral aspects like safety, authentication, or output format, which are critical for a tool listing virtual machines in a cloud environment. The high schema coverage helps with parameters, but overall context is insufficient.

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

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

The schema description coverage is 100%, with all three parameters ('keyword', 'state', 'zoneid') clearly documented in the schema. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline for high schema coverage without compensating with extra 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 resource ('virtual machines in CloudStack'), making the purpose immediately understandable. It distinguishes itself from siblings like 'get_virtual_machine' (singular) and 'list_virtual_machine_metrics' (metrics-focused), though it doesn't explicitly mention these distinctions.

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 sibling tools like 'get_virtual_machine' for single VM details or 'list_virtual_machine_metrics' for performance data, nor does it specify prerequisites or exclusions for usage.

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. 'List storage volumes' implies a read-only operation, but it doesn't specify whether this requires authentication, returns paginated results, has rate limits, or what happens on errors. For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is extremely concise with just three words, front-loading the essential information without any waste. It efficiently communicates the core purpose in a minimal format, making it easy for an agent to parse quickly.

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

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

Given the complexity of a list operation with three optional parameters and no annotations or output schema, the description is incomplete. It doesn't address key aspects like return format, pagination, error handling, or authentication requirements. For a tool that likely returns structured data, more context is needed to guide the agent effectively.

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

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

The input schema has 100% description coverage, with clear documentation for each parameter (type, virtualmachineid, zoneid). The description adds no additional meaning beyond what the schema provides, such as explaining how filters combine or default behaviors. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description 'List storage volumes' clearly states the action (list) and resource (storage volumes), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_snapshots' or 'list_storage_pools' that might list related but different resources, so it doesn't reach the highest 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. For example, it doesn't mention if this is the primary way to retrieve volume information or if other tools like 'list_snapshots' serve different purposes. Without any context or exclusions, the agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'List' implies a read-only operation, but it doesn't specify whether this requires authentication, has rate limits, returns paginated results, or what format the output takes. 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 perfectly concise at just three words, front-loading the essential information with zero wasted words. Every element ('List', 'availability', 'zones') earns its place by contributing directly to understanding the tool's 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?

Given the lack of annotations and output schema, the description should do more to compensate. As a read operation in a complex cloud management context with many sibling tools, it should explain what availability zones are, typical use cases, and what information the listing provides. The current description is too minimal for adequate 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?

The input schema has 100% description coverage, with the single parameter 'available' clearly documented as 'Show only available zones'. The description doesn't add any additional parameter information beyond what the schema provides, which is acceptable given the high schema coverage, resulting in the baseline score of 3.

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

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

The description 'List availability zones' clearly states the verb ('List') and resource ('availability zones'), making the tool's purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_accounts', 'list_clusters', or 'list_domains' which follow the same 'list_[resource]' pattern, so it doesn't achieve full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., for deployment planning), or how it relates to sibling tools like 'list_capacity' or 'list_hosts' that might provide overlapping information about infrastructure 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 full burden but only states the basic action. It doesn't disclose critical behavioral traits such as whether the migration is live or requires downtime, permission requirements, potential impacts on VM state, or any rate limits. This leaves significant gaps for an agent to understand the operation's implications.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core action and efficiently communicates the essential purpose without unnecessary elaboration, making it easy for an agent to parse quickly.

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

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

Given the complexity of a VM migration operation, no annotations, and no output schema, the description is insufficient. It lacks details on behavioral aspects, error conditions, return values, or integration with sibling tools like 'list_hosts'. For a potentially disruptive operation, more context is needed to guide safe and effective 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?

Schema description coverage is 100%, with clear parameter descriptions in the schema itself. The tool description adds no additional parameter semantics beyond implying migration involves a source VM and target host. Since the schema already documents both parameters well, the baseline score of 3 is appropriate as the description doesn't enhance or contradict 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 action ('migrate') and resource ('virtual machine'), specifying the destination ('to another host'). It distinguishes from siblings like 'deploy_virtual_machine' or 'scale_virtual_machine' by focusing on migration rather than creation or resizing. However, it doesn't explicitly differentiate from all similar operations like 'change_service_offering_virtual_machine' which might involve host changes.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., VM must be stopped), constraints (e.g., compatible hosts), or suggest other tools for related tasks like 'list_hosts' for host selection. The description is purely functional without contextual usage advice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Reboot' implies a destructive operation that will interrupt VM services, but the description doesn't specify whether this requires specific permissions, if it's reversible, what happens to running processes, or any rate limits. This is a significant gap 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 extremely concise at just four words, front-loading the essential information with zero wasted language. Every word earns its place by clearly communicating the core 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?

For a destructive operation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what 'reboot' entails behaviorally, what the expected outcome is, or any constraints. Given the complexity of VM management and the lack of structured data, more context is needed.

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 100%, with the single parameter 'id' clearly documented as 'VM ID to reboot'. The description doesn't add any additional meaning beyond what's in the schema, but since the schema is complete, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('reboot') and target resource ('virtual machine'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'stop_virtual_machine' or 'reset_password_virtual_machine' that also operate on virtual machines, so it's not fully distinctive.

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 'stop_virtual_machine' or 'start_virtual_machine', nor does it mention prerequisites or context for rebooting. The description only states what it does, not when it should be used.

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 insight. It implies a mutation (password reset) but doesn't disclose critical details like whether this requires admin permissions, if it triggers a reboot, what happens to existing sessions, or error conditions. This is inadequate for a mutation tool with zero 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 a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., side effects, permissions), expected outcomes, or error handling, leaving significant gaps for the agent to operate safely and effectively.

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

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

The schema description coverage is 100%, with the single parameter 'id' documented as 'VM ID' in the schema. The description adds no additional parameter context beyond what's already in the schema, so it meets the baseline score of 3 for high schema coverage.

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

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

The description clearly states the verb ('Reset password') and resource ('for virtual machine'), making the purpose immediately understandable. It doesn't specifically differentiate from siblings like 'reboot_virtual_machine' or 'stop_virtual_machine', but the action is distinct enough that confusion is unlikely.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., VM state), exclusions, or related tools like 'deploy_virtual_machine' for initial setup, leaving the agent to infer 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. 'Resize a volume' implies a mutation operation, but it doesn't describe critical behaviors: whether resizing is immediate or asynchronous, if it requires the volume to be detached or stopped, potential data loss risks (especially with shrinking), permissions needed, or rate limits. This leaves significant gaps for safe and effective use.

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 waste—'Resize a volume' is front-loaded and directly states the purpose. Every word earns its place, making it easy to parse quickly.

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

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

Given the complexity of a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., side effects, prerequisites), usage context, and expected outcomes. For a tool that modifies infrastructure, this leaves the agent under-informed about risks and proper 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 100%, so the schema already documents all parameters (id, shrinkok, size) with clear descriptions. The description adds no additional meaning beyond what's in the schema, such as explaining the implications of 'shrinkok' or units for 'size'. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Resize a volume' clearly states the action (resize) and resource (volume) with a specific verb. It distinguishes from siblings like 'create_volume' or 'attach_volume' by focusing on modification rather than creation or attachment. However, it doesn't specify whether this is for increasing or decreasing size, which could help differentiate it further from other volume 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., volume must be detached or in a specific state), exclusions, or related tools like 'create_volume' for initial sizing. The agent must infer usage from the tool name and parameters 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 full burden for behavioral disclosure. It mentions 'scale' and 'change service offering' which implies a mutation operation, but doesn't specify whether this requires downtime, affects billing, has permission requirements, or what the expected outcome is. For a mutation tool with zero annotation coverage, this leaves significant behavioral 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 - a single phrase that communicates the core function without any wasted words. It's front-loaded with the essential information and doesn't contain unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'scale' means operationally, what happens during the scaling process, whether there are limitations or side effects, or what the tool returns. The context signals show this is a 2-parameter tool with good schema coverage, but the behavioral aspects are completely undocumented.

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

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

Schema description coverage is 100%, with both parameters clearly documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema (VM ID and service offering ID). This meets the baseline expectation when schema coverage is complete.

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 ('scale') and resource ('virtual machine'), with additional clarification about changing service offering. It distinguishes from siblings like 'change_service_offering_virtual_machine' by using different terminology, though the distinction isn't explicitly explained. The purpose is specific and actionable.

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 'change_service_offering_virtual_machine' (which appears to be a sibling with similar function) or other VM management tools. There's no mention of prerequisites, constraints, or typical 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, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits like whether this requires admin permissions, if it's asynchronous, potential side effects, or what happens on failure. 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 a single, direct sentence with zero wasted words. It's front-loaded with the core action, making it highly 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on permissions, side effects, error handling, or return values, leaving the agent with insufficient context to use it safely and effectively.

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

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

Schema description coverage is 100%, so the parameter 'id' is documented in the schema as 'VM ID to start'. The description adds no additional meaning beyond this, such as format examples or constraints, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('Start') and resource ('a virtual machine'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'reboot_virtual_machine' or 'stop_virtual_machine', 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 on when to use this tool versus alternatives like 'reboot_virtual_machine' or 'deploy_virtual_machine'. The description lacks context about prerequisites (e.g., VM must be stopped) or exclusions, offering minimal usage 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Stop') but doesn't explain what 'stop' entails (e.g., graceful shutdown vs. power-off, effect on billing or resources, whether it's reversible via 'start_virtual_machine', or any side effects). 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 a single, direct sentence with no wasted words. It's front-loaded with the core action and resource, making it efficient and easy to parse, though this brevity contributes to gaps in other dimensions.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects (e.g., safety, reversibility), usage context, or output expectations, leaving the agent with insufficient information to use the tool effectively beyond basic syntax.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters ('id' and 'forced'). The description adds no additional parameter semantics beyond what's in the schema, such as explaining when to use 'forced' or format examples for 'id'. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Stop') and resource ('a virtual machine'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'reboot_virtual_machine' or 'start_virtual_machine' beyond the obvious verb difference, missing an opportunity to clarify scope or behavior distinctions.

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 'reboot_virtual_machine' or 'start_virtual_machine'. It lacks context about prerequisites (e.g., VM must be running), consequences (e.g., stops all processes), or typical use cases (e.g., maintenance vs. emergency stop).

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