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

With no annotations provided, the description carries full burden. It states the action 'apply' which implies mutation, but doesn't disclose behavioral traits like required permissions, whether this is idempotent, potential side effects on existing configurations, rate limits, or error conditions. The examples show input format but lack operational context. Significant gaps exist 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 appropriately sized with three sentences plus examples. The first sentence states the purpose, the second adds context about resource types, and the examples provide concrete usage. No wasted words, though the examples could be integrated more smoothly. Front-loading is adequate.

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 a mutation tool with no annotations, 0% schema coverage, but with an output schema (which reduces need to describe returns), the description is moderately complete. It covers purpose and parameter usage via examples but lacks behavioral context like permissions, side effects, or error handling. For a security-related operation, more guidance would be beneficial.

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

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

Schema description coverage is 0%, so the description must compensate. It provides concrete examples that clarify the structure of the single 'params' parameter, showing how 'firewall_id' and 'resources' array work with different 'type' values. This adds substantial meaning beyond the bare schema, though it doesn't explain all possible parameter combinations or constraints.

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

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

The description clearly states the verb 'apply' and the resource 'firewall to resources', specifying 'multiple resources like servers or server groups by label'. It distinguishes from sibling 'remove_firewall_from_resources' by action but doesn't explicitly contrast with other firewall tools like 'set_firewall_rules' or 'update_firewall'. The purpose is clear but sibling differentiation is incomplete.

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

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

The description implies usage when needing to apply a firewall to multiple resources, with examples showing two scenarios (server and label selector). However, it doesn't explicitly state when to use this vs alternatives like 'set_firewall_rules' or 'update_firewall', nor does it mention prerequisites like needing an existing firewall. Guidelines are implied but not comprehensive.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool 'attaches a volume to a server and optionally mounts it,' which implies a mutation operation, but doesn't address critical behavioral aspects like permissions required, whether the operation is reversible, potential side effects, or error conditions (e.g., if volume is already attached).

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 appropriately sized and front-loaded with the core purpose in the first sentence. The examples are helpful and directly relevant, though the structure could be slightly improved by separating the optional mounting behavior into its own sentence for clarity.

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 that there's an output schema (which handles return values) but no annotations and 0% schema description coverage, the description is moderately complete. It covers the basic operation and parameters via examples, but lacks behavioral details (e.g., permissions, reversibility) and usage guidelines, which are important for a mutation tool like this.

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

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

Schema description coverage is 0%, so the description must compensate. It provides examples that illustrate the three parameters (volume_id, server_id, automount) and their usage, adding meaningful context beyond the bare schema. However, it doesn't explain parameter constraints (e.g., valid ID ranges) or the effect of automount beyond 'mounts it,' leaving some gaps.

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

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

The description clearly states the tool's purpose with a specific verb ('Attach') and resource ('a volume to a server'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from the sibling tool 'detach_volume', which would be helpful for complete clarity.

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 'detach_volume' or 'create_volume', nor does it mention prerequisites (e.g., volume/server must exist) or constraints (e.g., volume must be detached). The examples show usage but don't provide contextual guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it correctly identifies this as a creation operation, it doesn't mention important behavioral aspects: what permissions are required, whether this is an idempotent operation, what happens on duplicate names, what the response contains, or any rate limits. The examples show input formats but don't describe behavioral outcomes.

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

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

The description is well-structured with a clear purpose statement followed by helpful examples. Each sentence earns its place, though the examples could be slightly more concise. The front-loaded purpose statement is effective, and the examples provide concrete value without unnecessary 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 that there's an output schema (which means return values are documented elsewhere), the description covers the basic creation operation adequately. However, for a mutation tool with no annotations and 0% schema description coverage, it should provide more behavioral context about permissions, idempotency, and error conditions to be truly complete.

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

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

The schema description coverage is 0%, so the description must compensate. It mentions the three main parameters (name, rules, resources) and provides examples showing their usage. However, it doesn't mention the 'labels' parameter at all, and the examples don't cover all parameter combinations or explain the semantics of rule/resource structures beyond basic examples.

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

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

The description clearly states the tool's purpose: 'Create a new firewall with the specified name, rules, and resources.' This is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'update_firewall' or 'set_firewall_rules', which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when this should be used instead of 'update_firewall', or any context about when firewall creation is appropriate versus modification. The examples show usage patterns but don't provide decision-making guidance.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While it states the tool creates a server, it doesn't mention important behavioral aspects: whether this is a paid operation, what permissions are required, whether it's idempotent, what happens on failure, or what the expected response contains. The examples show input formats but don't describe behavioral outcomes.

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 appropriately sized and front-loaded with the core purpose. The first two sentences clearly state what the tool does. The examples section is well-structured with three distinct scenarios. While the examples are helpful, they could be more concise by removing redundant JSON formatting or combining similar cases.

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 creation tool with no annotations, 5 parameters (through the params object), and an output schema exists, the description is moderately complete. The examples help understand parameter usage, but significant gaps remain: no behavioral context (cost, permissions, failure modes), no guidance on when to use versus alternatives, and incomplete parameter semantics. The existence of an output schema reduces the need to describe return values, but other aspects are under-specified.

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

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

With 0% schema description coverage, the description must compensate but only partially succeeds. The examples illustrate parameter usage with concrete values, showing how parameters combine in realistic scenarios. However, it doesn't explain parameter semantics beyond what's evident from the examples - no explanation of what server types represent, what images are available, or what locations mean. The examples add value but don't fully compensate for the schema coverage gap.

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

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

The description clearly states the tool creates a new server with specified configuration, providing a specific verb ('create') and resource ('server'). It distinguishes from siblings like 'get_server' or 'delete_server' by its creation purpose. However, it doesn't explicitly differentiate from other creation tools like 'create_firewall' or 'create_ssh_key' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing SSH keys created first), when to choose different server types, or when to use location defaults versus custom values. The examples show usage patterns but don't provide contextual decision-making guidance.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a creation operation but doesn't mention whether it requires specific permissions, what happens on duplicate names, rate limits, or what the response contains. The examples show input format but don't explain behavioral outcomes.

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 appropriately sized with three sentences and two examples. It's front-loaded with the core purpose, followed by elaboration and practical examples. No wasted words, though the repetition in the first two sentences could be slightly tightened.

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 but with an output schema (which handles return values), the description covers the basic creation purpose and parameters well. However, it lacks important contextual details like permission requirements, error conditions, or how this tool relates to sibling SSH key operations, leaving some gaps for an agent.

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

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

The schema description coverage is 0%, so the description must compensate. It provides meaningful context for all parameters through examples: 'name' for identification, 'public_key' with format specification ('OpenSSH format'), and optional 'labels' for key-value pairs. This adds substantial value beyond the bare schema.

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

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

The description clearly states the tool's purpose with specific verb ('Create') and resource ('SSH key'), and distinguishes it from siblings like 'get_ssh_key', 'list_ssh_keys', 'update_ssh_key', and 'delete_ssh_key' by specifying it's for creating new keys rather than reading, updating, or deleting 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 explicit guidance on when to use this tool versus alternatives like 'update_ssh_key' for modifying existing keys, or prerequisites such as authentication requirements. It only states what the tool does without contextual usage 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?

With no annotations provided, the description carries full burden but lacks critical behavioral details. It mentions 'Creates a new volume with the specified configuration' but doesn't disclose permissions required, rate limits, whether it's idempotent, or what happens on failure (e.g., if server ID is invalid). Examples show outcomes but not operational constraints.

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?

Front-loaded with the purpose, followed by examples that efficiently illustrate parameter combinations. Each example sentence earns its place by demonstrating different use cases. However, the first two sentences are somewhat redundant ('Create a new volume' and 'Creates a new volume...'), slightly reducing efficiency.

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, 0% schema coverage, but with an output schema (implied by context signals), the description is fairly complete. It covers purpose and parameters well via examples, though it lacks behavioral context like error handling or side effects. The output schema likely handles return values, so this is adequate but not exhaustive.

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

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

Schema description coverage is 0%, so the description must compensate fully. It provides rich examples that clarify parameter usage beyond the schema: e.g., 'size' in GB with implied ranges, 'location' values like 'fsn1', 'server' as an ID, 'automount' for attachment, and 'format' options. This adds significant meaning to all parameters.

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

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

The description clearly states the action ('Create a new volume') and specifies it's for creating with configuration. It distinguishes from siblings like 'attach_volume' or 'resize_volume' by focusing on creation. However, it doesn't explicitly contrast with 'create_server' or other creation tools, keeping it at 4 rather than 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 on when to use this tool versus alternatives like 'create_server' (which might include storage) or 'attach_volume' (for existing volumes). The examples imply usage but don't state explicit contexts or prerequisites, such as needing a server ID for attachment or location availability.

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

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

With no annotations provided, the description carries full burden. It discloses the destructive nature ('permanently deletes') which is critical, but lacks other behavioral traits: no mention of authentication requirements, error conditions (e.g., if firewall is in use), rate limits, or what the output schema returns. The example shows parameter format but doesn't explain behavioral outcomes.

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 three short sentences and an example. Every sentence adds value: first states action, second clarifies permanence and identifier, third provides concrete usage. No wasted words, and it's front-loaded with the core 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 high complexity (destructive operation), no annotations, and 0% schema coverage, the description is incomplete. It mentions permanence but misses critical context: prerequisites, side effects, error handling, and output details (though output schema exists, the description doesn't reference it). For a deletion tool with siblings like 'remove_firewall_from_resources', more guidance 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 0%, so the description must compensate. It adds that the firewall is 'identified by its ID' and provides an example with 'firewall_id', giving basic semantic context. However, it doesn't explain ID format constraints, validation rules, or where to obtain the ID, leaving gaps. With 1 parameter, baseline would be 4 if fully covered, but partial coverage justifies 3.

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

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

The description clearly states the verb 'delete' and resource 'firewall', making the purpose unambiguous. It distinguishes from siblings like 'remove_firewall_from_resources' by specifying permanent deletion rather than detachment. However, it doesn't explicitly contrast with 'delete_server' or other delete operations, keeping it at 4 rather than 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'remove_firewall_from_resources' or 'update_firewall'. It mentions the firewall must be identified by ID but doesn't specify prerequisites (e.g., whether the firewall must be detached first) or warn about irreversible consequences beyond stating 'permanently deletes'.

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 is permanent ('Permanently deletes'), which is crucial for a destructive operation. However, it lacks details on permissions required, rate limits, error conditions, or what the output schema returns. For a high-stakes deletion tool, 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 appropriately concise with three sentences: a simple statement, a clarification of permanence, and an example. Each sentence adds value without redundancy. The structure is front-loaded with the core action. Minor improvement could come from integrating the example more seamlessly.

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

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

Given the tool's high complexity (destructive operation) and lack of annotations, the description is incomplete. It covers the basic action and permanence but misses critical context like prerequisites, error handling, and output details. The presence of an output schema helps, but the description doesn't leverage it to explain return values or success/failure indicators.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions the parameter ('server_id') in the example but doesn't explain its semantics beyond identification. The description adds minimal value over the schema, which already defines 'server_id' as an integer. With only one parameter, the baseline is 4, but the lack of semantic enrichment lowers the score.

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

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

The description clearly states the action ('Delete') and resource ('a server'), making the purpose immediately understandable. It distinguishes from siblings like 'get_server' or 'list_servers' by specifying deletion rather than retrieval. However, it doesn't explicitly differentiate from other destructive operations like 'delete_firewall' or 'delete_volume' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., server must be powered off), consequences (e.g., data loss), or relationships with other tools (e.g., use after 'power_off'). The example shows parameter usage but offers no contextual decision-making help.

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 'Permanently deletes', which implies irreversibility and destructive action, but doesn't cover other critical aspects like authentication requirements, error conditions (e.g., what happens if the key doesn't exist), rate limits, or confirmation prompts. The example helps but doesn't fully compensate for missing behavioral details.

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

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

The description is perfectly concise and well-structured: a brief statement of purpose, clarification of permanence, and a helpful example. Every sentence adds value without redundancy. The front-loaded purpose statement makes it immediately scannable.

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 destructive nature and lack of annotations, the description is minimally adequate. It covers the core action and parameter, and an output schema exists (though not shown), reducing need to describe returns. However, for a permanent deletion tool, more warnings about consequences or dependencies would improve completeness. The example partially fills gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It clearly explains that the parameter 'ssh_key_id' identifies the SSH key to delete, and the example provides concrete syntax. This adds meaningful context beyond the bare schema, though it doesn't elaborate on ID format or validation rules. With only 1 parameter, this is sufficient for a high score.

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

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

The description clearly states the verb ('Delete') and resource ('SSH key'), making the purpose immediately understandable. It distinguishes from siblings like 'update_ssh_key' or 'get_ssh_key' by specifying deletion. However, it doesn't explicitly contrast with all siblings (e.g., 'delete_server'), so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing the SSH key ID from 'list_ssh_keys'), consequences of deletion, or when to choose deletion over other operations like updating. This leaves the agent without contextual usage 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the deletion is 'permanent', which is crucial context, but lacks other important details like authentication requirements, rate limits, error conditions, or what happens to associated data. The example helps but doesn't cover behavioral traits comprehensively.

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

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

The description is extremely concise with only three sentences, all essential. It's front-loaded with the core action, followed by critical behavioral detail ('permanently'), and ends with a helpful example. Zero wasted words.

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

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

For a destructive mutation tool with no annotations, 0% schema coverage, and an output schema (which helps but doesn't replace description), the description is incomplete. It misses critical context like permissions needed, irreversible consequences, error handling, and differentiation from sibling tools, making it inadequate for safe 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?

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description adds minimal semantics by mentioning 'volume identified by its ID' and showing an example with 'volume_id', but doesn't explain ID format, validation rules, or where to find the ID. This partially compensates but leaves gaps.

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

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

The description clearly states the action ('Delete') and resource ('a volume'), making the purpose immediately understandable. It distinguishes from siblings like 'detach_volume' by specifying permanent deletion, though it doesn't explicitly contrast with all alternatives like 'resize_volume' or 'get_volume'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., volume must be detached), consequences of deletion, or when to choose other tools like 'detach_volume' or 'resize_volume' instead.

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

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

No annotations are provided, so the description carries full burden. It states the action is 'detach' which implies a destructive/mutative operation, but doesn't disclose behavioral traits like whether this requires specific permissions, if it's reversible, potential data loss, or rate limits. The example shows the parameter format but doesn't explain the outcome.

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 appropriately sized with two sentences plus an example. The first sentence states the purpose clearly, the second reinforces it, and the example provides concrete usage. No unnecessary information is included, though it could be more front-loaded with critical details.

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

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

Given 1 parameter with 0% schema coverage and no annotations, the description is minimally complete for a simple destructive operation. The presence of an output schema means return values don't need explanation. However, for a mutation tool with safety implications, more behavioral context would be beneficial.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description adds minimal value through the example showing 'volume_id' usage, but doesn't explain what a volume ID is, where to find it, or format constraints. With only 1 parameter, this is adequate but not comprehensive.

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

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

The description clearly states the action ('detach') and target resource ('volume from a server'), making the purpose immediately understandable. It distinguishes from sibling 'attach_volume' by specifying the opposite operation. However, it doesn't explicitly mention the server context beyond 'from a server', which could be slightly more specific.

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

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

The description provides no guidance on when to use this tool versus alternatives or prerequisites. It doesn't mention that the volume must be currently attached, what happens to data, or any dependencies. With sibling tools like 'attach_volume' and 'delete_volume', clear usage boundaries are missing.

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 the tool returns detailed information, which implies a read-only operation, but doesn't disclose behavioral traits like authentication requirements, rate limits, error handling, or what 'detailed information' includes. The description is minimal and lacks critical context for safe invocation.

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

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

The description is appropriately sized and front-loaded: the first sentence states the purpose, the second elaborates on returns, and the third provides a clear example. Every sentence adds value without redundancy, and the structure is efficient for quick comprehension.

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

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

Given the tool's low complexity (single parameter) and the presence of an output schema (which handles return values), the description is somewhat complete but lacks depth. It covers the basic purpose and parameter use but misses behavioral details (e.g., error cases, permissions) and usage context, making it adequate but with clear gaps for a read 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?

The input schema has 0% description coverage, with one parameter 'firewall_id' undocumented in schema. The description adds meaning by specifying that the firewall is 'identified by its ID' and provides an example with 'firewall_id': 12345, clarifying the parameter's role. However, it doesn't explain ID format, constraints, or sourcing, leaving gaps in semantic 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 tool's purpose: 'Get details about a specific firewall' and 'Returns detailed information about a firewall identified by its ID.' This specifies the verb ('Get'), resource ('firewall'), and scope ('specific firewall' by ID). It distinguishes from sibling 'list_firewalls' by focusing on a single entity rather than listing multiple, though it doesn't explicitly name the sibling.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_firewalls' for browsing or 'get_server' for related resources, nor does it specify prerequisites (e.g., needing a firewall ID). The example shows usage but doesn't explain 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation ('get details'), which implies it's non-destructive, but doesn't cover aspects like authentication requirements, rate limits, error handling, or what 'detailed information' includes. 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 appropriately sized and front-loaded: the first sentence states the purpose clearly, the second elaborates, and the example provides concrete usage without unnecessary details. Every sentence adds value, and there's no redundancy or fluff, making it efficient and well-structured.

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

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

Given the tool's low complexity (single parameter) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose and parameter usage adequately. However, the lack of annotations and minimal behavioral context (e.g., no mention of permissions or errors) prevents a perfect score, as some gaps remain for a tool with zero annotation coverage.

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

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

The schema description coverage is 0%, so the description must compensate. It adds meaning by specifying that the parameter is 'server_id' and provides an example with a numeric ID, which clarifies the parameter's role beyond the schema's basic type definition. However, it doesn't explain constraints like valid ID ranges or format, leaving some ambiguity. With low coverage, this partial compensation earns a baseline score.

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

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

The description clearly states the tool's purpose: 'Get details about a specific server' and 'Returns detailed information about a server identified by its ID.' This specifies the verb ('get details') and resource ('server'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'list_servers' or 'get_firewall', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_servers' (for listing multiple servers) or 'get_firewall' (for similar get operations on different resources), nor does it specify prerequisites or exclusions. The example shows usage but doesn't contextualize it relative to other options.

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 this is a read operation ('Get details'), which implies it's non-destructive, but doesn't cover other aspects like authentication requirements, rate limits, error conditions, or what 'detailed information' includes beyond the ID. The example helps but is minimal.

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

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

The description is appropriately sized and front-loaded: the first sentence states the purpose, the second elaborates on the return, and the third provides a concise example. Every sentence adds value without redundancy, making it efficient and well-structured.

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

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

Given the tool's low complexity (one parameter) and the presence of an output schema (which handles return values), the description is mostly adequate. However, it lacks context on usage versus siblings and behavioral details like error handling, which are important for a read operation in a server 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?

The description adds meaning beyond the input schema, which has 0% description coverage. It explains that the parameter 'ssh_key_id' is used to identify a specific SSH key, and the example illustrates its usage. Since there's only one parameter, the description adequately compensates for the schema's lack of documentation.

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

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

The description clearly states the tool's purpose: 'Get details about a specific SSH key' and 'Returns detailed information about an SSH key identified by its ID.' This specifies the verb ('Get') and resource ('SSH key'), though it doesn't explicitly differentiate from sibling tools like 'list_ssh_keys' or 'update_ssh_key' beyond the 'specific' qualifier.

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_ssh_keys' (for listing all keys) or 'update_ssh_key' (for modifying keys), nor does it specify prerequisites such as needing an existing SSH key ID.

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

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

No annotations are provided, so the description carries the full burden. It states this is a read operation ('Get details'), but doesn't disclose behavioral traits like authentication requirements, rate limits, error conditions, or what 'detailed information' includes. The description is minimal and lacks important context for a tool that presumably accesses sensitive infrastructure 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 appropriately sized with three sentences: purpose statement, elaboration on return value, and an example. It's front-loaded with the core purpose. The example is helpful but could be more integrated. No wasted words, though it could be slightly more structured.

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

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

Given the tool's low complexity (single parameter read operation) and the presence of an output schema (which handles return values), the description is somewhat complete. However, with no annotations and minimal behavioral disclosure, it leaves gaps in understanding permissions, errors, and operational context. It's adequate but could better address the read-only nature and resource-specific considerations.

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

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

The schema description coverage is 0%, so the description must compensate. It adds meaning by specifying that the volume_id parameter identifies 'a specific volume' and provides an example showing usage. However, it doesn't explain parameter constraints (e.g., valid ID ranges) or format details beyond what's implied. With one parameter and an example, it meets the baseline but doesn't fully compensate for the schema gap.

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

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

The description clearly states the tool's purpose: 'Get details about a specific volume' and 'Returns detailed information about a volume identified by its ID.' This is a specific verb+resource combination (get + volume details). However, it doesn't distinguish this tool from other 'get_' siblings like get_firewall or get_server, which likely have similar patterns but for different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like list_volumes (which might retrieve multiple volumes) or differentiate from other 'get_' tools. The example shows usage but doesn't provide contextual decision-making criteria.

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 returns a list with details, which is helpful, but lacks critical information such as pagination behavior, rate limits, authentication requirements, or error handling. For a read operation in a cloud API context, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is concise and front-loaded, with the core purpose in the first sentence. The second sentence adds useful detail about the return value, and the example is minimal but illustrative. There's no wasted text, though it could be slightly more structured (e.g., bullet points for key points).

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

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

Given the tool's simplicity (0 parameters, output schema exists), the description is adequate but incomplete. It covers the basic purpose and return value, but with no annotations and missing behavioral details (e.g., pagination), it doesn't fully prepare an agent for robust use. The output schema likely handles return values, so that gap is mitigated.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description correctly omits parameter details, and the example 'list_firewalls()' reinforces the lack of parameters. This is efficient and appropriate, though not a 5 since it doesn't add any semantic value beyond the schema (which is fine given the context).

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

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

The description clearly states the verb ('List') and resource ('all firewalls in your Hetzner Cloud account'), making the purpose unambiguous. It distinguishes from siblings like 'get_firewall' (singular) by emphasizing 'all' firewalls. However, it doesn't explicitly contrast with other list tools (e.g., 'list_servers'), so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use 'list_firewalls' instead of 'get_firewall' (for a single firewall) or other list tools, nor does it specify prerequisites or exclusions. The example shows basic usage but lacks contextual advice.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it states the tool returns a list and gives a basic example, it doesn't cover important behavioral aspects like pagination, rate limits, authentication requirements, error conditions, or whether the list is filtered or complete. For a read operation with zero annotation coverage, this is insufficient.

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

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

The description is appropriately concise with three sentences: a purpose statement, elaboration on the return value, and a simple example. Each sentence adds value, and the structure is front-loaded with the core purpose. Minor deduction because the example could be more informative about typical use cases.

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 that the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description is minimally adequate. However, for a list operation that likely returns structured data (images with attributes like ID, name, size), the description doesn't explain what information is included in the returned list or how to interpret it, leaving gaps despite the 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 tool has 0 parameters, and schema description coverage is 100% (though empty). The description appropriately doesn't discuss parameters since none exist, which is correct. A baseline of 4 is appropriate for zero-parameter tools when the description doesn't need to compensate for schema gaps.

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

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

The description clearly states the tool's purpose with a specific verb ('List') and resource ('available OS images'), and explains what the images are used for ('to create servers'). However, it doesn't explicitly differentiate from sibling tools like list_servers or list_server_types, which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate, what prerequisites might exist, or how it relates to sibling tools like list_server_types or create_server. The example only shows syntax, not 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 full burden but only states it 'returns information' without detailing format, pagination, or error behavior. It mentions 'all available' but doesn't clarify if this includes inactive locations or requires specific permissions.

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

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

The description is front-loaded with the core purpose, followed by a clarifying sentence and example. It's efficient with three brief sentences, though the example adds minimal value beyond the first sentence.

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 0 parameters, 100% schema coverage, and an output schema exists, the description is minimally adequate. However, as a read-only tool with no annotations, it should ideally mention safety or data format, but the output schema reduces this need.

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

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

The tool has 0 parameters with 100% schema coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, earning a baseline high score for not adding unnecessary information.

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

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

The description clearly states the verb 'List' and resource 'available locations', specifying it returns information about datacenter locations. It distinguishes from siblings like list_servers or list_volumes by focusing on locations, but 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 on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites, timing, or context for selecting list_locations over other list_* tools, leaving usage 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 the full burden of behavioral disclosure. It states the tool returns a list of server instances with details, which is helpful, but lacks critical information such as pagination behavior, rate limits, authentication requirements, or error conditions. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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 appropriately sized and front-loaded: the first sentence states the core purpose, the second explains the return value, and the example illustrates usage. There's minimal waste, though the example could be more informative (e.g., showing output structure). It efficiently conveys key information in three sentences.

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

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

Given the tool's low complexity (0 parameters, read-only operation) and the presence of an output schema (which handles return values), the description is mostly adequate. However, with no annotations, it should ideally mention authentication needs or data scope (e.g., all servers in the account). It covers the basics but lacks depth for a tool 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?

The input schema has 0 parameters with 100% coverage, so the schema fully documents the absence of parameters. The description adds no parameter-specific information, which is appropriate since there are none. It correctly implies no filtering or arguments are needed, aligning with the schema. Baseline is 4 for zero parameters.

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

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

The description clearly states the tool's purpose: 'List all servers in your Hetzner Cloud account.' It specifies the verb ('List') and resource ('servers'), and distinguishes it from sibling tools like 'get_server' (which retrieves a specific server) and 'create_server' (which creates a new server). However, it doesn't explicitly differentiate from other list tools like 'list_firewalls' or 'list_volumes' beyond the resource 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), compare it to similar tools like 'get_server' for retrieving a single server, or indicate scenarios where it might be preferred over other list tools. The example only shows basic usage without 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 full burden for behavioral disclosure. While it mentions the tool returns 'information about all available server configurations,' it doesn't specify what information is included, whether there's pagination, rate limits, authentication requirements, or any other behavioral characteristics. The example is helpful but doesn't compensate for the lack of behavioral details.

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

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

The description is appropriately concise with three short sentences that each serve a purpose: stating the action, describing the return value, and providing an example. It's front-loaded with the core purpose and could potentially be slightly more efficient by combining the first two sentences.

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 that this is a read-only listing tool with no parameters and an output schema exists, the description is adequate but minimal. It covers the basic purpose and return value but lacks important context about when to use it versus sibling tools and what specific information is returned. The existence of an output schema reduces the burden, but more behavioral context would be helpful.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't waste space discussing non-existent parameters. The baseline for this situation is 4 since there are no parameters to explain.

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

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

The description clearly states the tool's purpose with a specific verb ('List') and resource ('available server types'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'list_servers' or 'list_images' which might cause confusion about what distinguishes server types from servers themselves.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'list_servers' and 'list_images' that might provide overlapping or related information, there's no indication of when this specific tool is appropriate versus those other listing tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('List all SSH keys') and return value ('list of all SSH key instances with their details'), which covers the core behavior. However, it lacks details on pagination, rate limits, authentication needs, or error handling, which are important for a cloud API tool. The example adds minimal practical 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 front-loaded with the core purpose, followed by return details and a simple example. It's efficient with three sentences, though the example is very basic and could be more informative (e.g., mentioning output format). There's no wasted text, but it could be slightly more structured for clarity.

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

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

Given the tool has 0 parameters, 100% schema coverage, and an output schema (implied by 'Returns a list'), the description is reasonably complete. It covers what the tool does and what it returns, which is sufficient for a simple list operation. However, it misses behavioral nuances like pagination or error cases, which could be relevant in a cloud context.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description correctly doesn't discuss parameters, focusing instead on the tool's purpose and output. This aligns well with the schema, earning a high score for not adding unnecessary information.

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

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

The description clearly states the verb ('List') and resource ('all SSH keys in your Hetzner Cloud account'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_ssh_key' (which presumably retrieves a single key), leaving room for minor confusion 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 'get_ssh_key' or other list tools (e.g., 'list_servers'). It mentions a basic example but lacks explicit context, prerequisites, 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 mentions the return type ('list of all volume instances with their details') but lacks critical details like pagination, rate limits, error handling, or authentication requirements, which are essential for a cloud API 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 front-loaded with the core purpose, followed by return details and an example. It's efficient with three sentences, though the example could be more informative (e.g., showing output format) to enhance clarity without adding bulk.

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

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

Given the tool's simplicity (0 parameters, output schema exists), the description is adequate but incomplete. It covers the basic operation and return type but misses behavioral aspects like pagination or error cases, which are important even for simple list tools in cloud contexts.

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

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

The tool has 0 parameters, and the input schema coverage is 100%, so there's no need for parameter details in the description. The description correctly avoids redundant information, earning a high baseline score for not adding unnecessary content.

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

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

The description clearly states the verb ('List') and resource ('all volumes in your Hetzner Cloud account'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'list_firewalls' or 'list_servers' beyond the resource type, which is a minor gap.

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, such as authentication or account setup, or compare it to other list tools like 'list_volumes' vs. 'get_volume' for specific details.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It excellently explains the destructive nature ('equivalent to pulling the power plug'), warns about data loss, and provides a concrete example of usage. This gives the agent crucial context about the tool's impact that isn't captured elsewhere.

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

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

The description is perfectly structured: a clear purpose statement, important behavioral warnings, usage guidance, and a concrete example. Every sentence earns its place, with no redundancy or wasted words. The information is front-loaded with the most critical details first.

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

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

For a destructive operation with no annotations and an output schema present, this description provides excellent completeness. It covers purpose, behavioral risks, usage considerations, and parameter demonstration. The existence of an output schema means return values don't need explanation in the description, making this fully adequate.

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

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

The schema has 0% description coverage, but the description compensates well by providing a clear example showing the server_id parameter in context. While it doesn't explain parameter constraints or validation rules, the example demonstrates the expected structure and data type (integer ID), adding significant value beyond the bare schema.

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

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

The description clearly states the action ('power off') and resource ('a server'), making the purpose immediately understandable. It distinguishes from sibling 'reboot' by specifying a complete shutdown rather than restart, though it doesn't explicitly contrast with 'power_on' beyond the obvious inverse relationship.

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

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

The description provides clear contextual guidance about when to use this tool ('Consider using a graceful shutdown if possible') and warns about potential data loss, which helps the agent understand this is a forceful option. However, it doesn't explicitly name alternative tools like 'reboot' or mention prerequisites such as server state requirements.

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 ('Power on') and prerequisite ('currently powered off'), but lacks details on permissions required, side effects (e.g., boot time, cost implications), error conditions, or response format. 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 front-loaded with the core action, followed by a clarifying sentence and a concise example. Every sentence earns its place without redundancy, making it efficient and well-structured 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 the tool's complexity (simple mutation), 0% schema coverage, and the presence of an output schema (which handles return values), the description is minimally adequate. It covers the basic action and parameter example but lacks behavioral details like permissions or error handling, making it incomplete for safe invocation.

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

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

The description includes an example showing the parameter usage ('server_id': 12345), which adds practical meaning beyond the schema's minimal description ('The ID of the server'). With 0% schema description coverage and only 1 parameter, this example sufficiently compensates, though it doesn't explain parameter constraints or validation.

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 ('Power on') and resource ('a server'), making the purpose specific and understandable. It distinguishes from sibling 'power_off' by specifying opposite state change. However, it doesn't explicitly differentiate from 'reboot' or other power-related tools, preventing 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 minimal guidance by mentioning 'a server that is currently powered off,' which implies a prerequisite state but doesn't explicitly state when to use this tool versus alternatives like 'reboot' or 'create_server.' No explicit alternatives or exclusions are provided, leaving usage context incomplete.

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 successfully communicates this is a mutation operation (reboot), specifies the type of reboot (soft/graceful), and provides an example. It doesn't mention potential side effects, permissions needed, or time estimates, but covers the core behavioral trait adequately.

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

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

The description is perfectly structured: a clear purpose statement first, followed by important behavioral detail, then a practical example. Every sentence earns its place with zero wasted words, making it easy to scan and understand 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, 0% schema coverage, but with an output schema present, the description does well. It covers purpose, behavior type, and provides an example. The output schema existence means return values don't need explanation. It could benefit from mentioning potential impacts or prerequisites for completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It provides an example showing the server_id parameter usage, which adds meaningful context beyond the bare schema. However, it doesn't explain parameter constraints, valid ranges, or where to find server IDs, leaving some gaps in parameter understanding.

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

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

The description clearly states the specific action ('reboot') and target resource ('a server'), distinguishing it from sibling tools like power_on/power_off. It provides a complete verb+resource statement that leaves no ambiguity about what this tool does.

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

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

The description provides clear context by specifying it performs a 'soft reboot (graceful shutdown and restart)', which helps differentiate it from hard resets or power cycling. However, it doesn't explicitly state when to use this versus alternatives like power_off/power_on or mention prerequisites like server state requirements.

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 ('removes') but doesn't mention important behavioral aspects: whether this operation requires specific permissions, whether it's reversible, potential side effects (e.g., network disruption), rate limits, or what happens if resources are already detached. The examples help but don't cover behavioral traits.

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

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

The description is appropriately sized with three sentences: a clear purpose statement, a reinforcing sentence, and two helpful examples. The structure is front-loaded with the core purpose first. The examples could be slightly more concise but overall it's efficient.

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

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

Given this is a mutation tool with no annotations, 0% schema description coverage, but with an output schema (which reduces need to describe returns), the description is minimally adequate. It covers the basic operation and provides examples, but lacks important context about permissions, side effects, and error conditions that would be needed for safe 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 0%, so the description must compensate. The examples provide concrete parameter usage (firewall_id and resources with type-specific fields), adding meaningful context beyond the bare schema. However, it doesn't explain all parameter semantics comprehensively (e.g., what happens with empty resources array, validation rules for label_selector).

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 ('Remove a firewall from resources') and specifies it works on multiple resources, which distinguishes it from simpler single-resource operations. However, it doesn't explicitly differentiate from sibling tools like 'detach_volume' or other firewall operations beyond the obvious name-based distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'delete_firewall' (which might remove the firewall entirely) or 'set_firewall_rules' (which might modify rules rather than detachment). The examples show usage patterns but don't explain the context or prerequisites for using this operation.

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

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

With no annotations provided, the description carries full burden. It discloses the irreversible 'increase-only' behavior and provides an example, but lacks critical details: whether this requires specific permissions, if it causes downtime, what happens to data, rate limits, or what the output contains. For a mutation tool with zero annotation coverage, this is insufficient.

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

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

The description is appropriately brief with three sentences: purpose statement, behavioral constraint, and example. Each sentence adds value, though the example could be more informative. It's front-loaded with the core action.

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 a mutation tool with no annotations but an output schema (which handles return values), the description covers the basic operation and constraint. However, it misses important context like permissions, side effects, or error cases that would be crucial for safe agent invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'volume_id' and 'size' in the example and clarifies that size must be greater than current size, adding meaning beyond the bare schema. However, it doesn't explain parameter formats, constraints beyond the increase requirement, or error handling for invalid inputs.

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 ('resize a volume') and specifies the direction ('size can only be increased, not decreased'), which distinguishes it from generic volume modification tools. However, it doesn't explicitly differentiate from sibling tools like 'update_firewall' or 'create_volume' beyond the obvious resource focus.

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_volume' for new volumes or other volume-related tools. It mentions the size increase constraint but doesn't address prerequisites, error conditions, or integration with sibling operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key traits: it's a mutation operation ('Set rules'), specifies that it overwrites existing rules, and explains how to remove all rules. This covers critical aspects like destructive behavior and usage patterns, though it could add more on error handling or permissions.

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

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

The description is front-loaded with the core action and key behavioral notes, followed by a helpful example. Each sentence adds value, such as clarifying the overwrite behavior and removal method, making it efficient. It could be slightly more structured by separating guidelines from examples, but overall it's well-organized and avoids redundancy.

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

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

Given the complexity of a mutation tool with no annotations and an output schema present, the description does a solid job. It covers the purpose, behavioral traits, and parameter usage through the example. The output schema likely handles return values, so the description focuses on input and behavior, making it reasonably complete for agent use, though it could benefit from more explicit sibling differentiation.

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

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

The schema description coverage is 0%, so the description must compensate. It includes an example that illustrates the parameters ('firewall_id' and 'rules' array with nested properties like 'direction'), adding practical meaning beyond the bare schema. However, it doesn't fully explain all parameter details (e.g., optional fields like 'destination_ips'), leaving some gaps in 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 action ('Set rules for a firewall') and specifies the resource ('firewall'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'update_firewall' or 'create_firewall', which could handle similar operations, leaving some ambiguity about when to choose this specific tool.

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

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

The description implies usage by noting that 'All existing rules will be overwritten' and 'Pass an empty rules array to remove all rules', which provides some context for when to use it (e.g., for full replacements or clearing). However, it lacks explicit guidance on alternatives like 'update_firewall' or prerequisites, leaving the agent to infer the best choice among siblings.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states this is an update operation (implying mutation) and provides examples, but doesn't disclose permissions needed, whether changes are reversible, rate limits, error conditions, or what the output contains. 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 perfectly front-loaded with a clear purpose statement, followed by specific details and practical examples. Every sentence earns its place with zero wasted words, 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 this is a mutation tool with no annotations but with an output schema (which handles return values), the description covers basic purpose and parameters well. However, it lacks critical context about behavioral traits (e.g., permissions, side effects) and usage guidelines, making it minimally adequate but incomplete for safe 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 0%, so the description must compensate. It effectively explains the three parameters: 'firewall_id' (implied as required), 'name' (new name), and 'labels' (user-defined key-value pairs), with clear examples showing usage. This adds significant meaning beyond the bare schema, though it doesn't cover all edge cases like null handling.

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 ('Update') and resource ('firewall'), specifying it updates 'name or labels of an existing firewall'. This distinguishes it from sibling tools like 'create_firewall' or 'delete_firewall', though it doesn't explicitly differentiate from 'set_firewall_rules' which might update different aspects.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'set_firewall_rules' or other update operations. It mentions updating 'existing firewall' but doesn't specify prerequisites, constraints, or when-not-to-use scenarios, leaving the agent without contextual 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. It states this is an update operation, implying mutation, but doesn't disclose behavioral traits such as required permissions, whether changes are reversible, rate limits, or error conditions. The examples show input formats but don't describe the response or 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 appropriately sized and front-loaded: it starts with the core purpose, adds a clarifying sentence, and includes relevant examples. There's minimal waste, though the examples could be slightly more concise. Overall, it's efficient and well-structured 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 the tool's complexity (a mutation with 3 parameters), no annotations, and an output schema present (which reduces the need to describe return values), the description is moderately complete. It covers the basic purpose and parameters through examples but lacks behavioral details and usage guidelines. It's adequate for a simple update tool but could be more comprehensive.

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

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

The schema description coverage is 0%, so the schema provides no parameter descriptions. The description compensates by listing updatable fields (name or labels) and providing examples that illustrate usage with 'ssh_key_id', 'name', and 'labels'. However, it doesn't fully explain all parameters (e.g., the purpose of 'ssh_key_id' is only implied, and 'labels' structure is shown but not detailed). This adds some value but doesn't fully cover the semantics.

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

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

The description clearly states the tool's purpose: 'Update an SSH key' and elaborates with 'Updates the name or labels of an existing SSH key.' This specifies the verb (update), resource (SSH key), and scope (name or labels). However, it doesn't explicitly differentiate from sibling tools like 'create_ssh_key' or 'delete_ssh_key' beyond the update action, though the context is reasonably clear.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing SSH key ID), exclusions (e.g., what cannot be updated), or comparisons to sibling tools like 'create_ssh_key' or 'delete_ssh_key'. Usage is implied through the examples but not explicitly stated.

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