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

The description goes beyond the destructiveHint annotation by explicitly warning '⚠️ Destructive' and detailing what gets destroyed ('delete all uploaded parts'). It also introduces the safety requirement 'Set confirm=true to execute', which is critical behavioral context not present in the annotation alone.

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

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

The description is a single, high-impact sentence that front-loads the destructive warning and clearly states the action and confirm requirement. No filler or redundant information; every word earns its place.

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

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

For a simple destructive action with 4 well-documented parameters and no output schema, the description covers the essential purpose, destructive effect, and confirmation gate. It lacks explicit references to related tools for obtaining uploadId, but this is not critical given the schema and name. Slight gap in usage context prevents a 5.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description reinforces the confirm parameter's necessity but does not add new meaning beyond the schema's existing descriptions for bucketName, objectName, uploadId, or confirm. Baseline 3 is appropriate.

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

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

The description clearly states the action: 'Abort a multipart upload and delete all uploaded parts.' This specifies the verb (abort), resource (multipart upload), and the effect (delete parts), distinguishing it from sibling operations like complete_multipart_upload or upload_part.

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

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

The description implies usage for cancelling an in-progress multipart upload, but does not explicitly contrast with alternatives (e.g., complete_multipart_upload) or provide when-to-use/when-not-to-use guidance. The name and warning make the primary use case clear, but no exclusions or alternatives are mentioned.

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

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

With no annotations, the description must carry the behavioral burden. It clearly indicates a mutating action (accept/reject), but does not disclose any consequences, reversibility, or permission requirements. The action itself is simple, but the description adds little beyond the name and schema.

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

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

The description is a single, concise sentence that clearly communicates the tool's purpose. It is front-loaded with the action verb and resource, with no redundant 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?

The tool is simple, and the schema fully documents both parameters. The description covers the action and adds the 'pending' requirement. While there is no output schema, for a binary accept/reject action the lack of return value documentation is acceptable. It is complete enough for typical use.

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

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

The schema already provides 100% coverage for both parameters with clear descriptions (isAccept: true to accept, false to reject; vpcPeeringInstanceNo: VPC Peering instance number). The tool description adds only the 'pending' context, which is already implied by the word 'pending' in the description. No additional parameter meaning is provided.

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

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

The description clearly states the action (accept or reject), the resource (VPC Peering request), and the condition (pending). It distinguishes this tool from sibling tools like create/delete/describe peering by focusing on the response to a pending request.

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

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

The phrase 'pending VPC Peering request' provides clear context that this tool is for responding to requests in a specific state. It does not explicitly name alternatives or exclusions, but the context is strong enough to know when to use it.

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

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

The description adds no behavioral context beyond what the destructiveHint=false annotation already conveys. It does not state whether the rule is immediately applied, whether duplicate rules are prevented, or what the API response contains. For a mutation tool, this is a minimal level of transparency.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately communicates the action and target, making it easy to scan.

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

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

Given the rich input schema, the description is minimally viable but lacks operational context. It does not mention return values (no output schema) or the distinction from outbound rule addition, which would help an agent fully understand the tool's role. The moderate complexity (7 params, conditional rules) is partially addressed by the schema, but the description alone would be insufficient for a new user.

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 provides 100% coverage with descriptions for all seven parameters, including conditional requirements (e.g., portRange required for TCP/UDP) and mutual exclusivity (ipBlock vs accessControlGroupSequence). The tool description itself does not add any parameter semantics, so the baseline score of 3 applies.

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 'Add' and the resource 'inbound rule to an Access Control Group'. The word 'inbound' differentiates it from the sibling tool ncloud_add_acg_outbound_rule, making the tool's specific role unmistakable.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as ncloud_add_acg_outbound_rule. It also does not mention any prerequisites (e.g., needing an existing ACG or VPC). The only implied usage is from the tool name itself, which is insufficient for an agent to choose confidently.

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

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

Annotations include destructiveHint: false, which provides a safety signal. The description adds that this is an additive mutation ('Add'), but does not disclose potential side effects (e.g., whether rules are appended, duplicate handling, or permission requirements). With annotations present, the baseline is lower, and the description adds minimal context beyond the action.

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

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

The description is a single sentence with no unnecessary words. It is appropriately terse and front-loaded.

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

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

Given the tool's moderate complexity (7 params, mutual exclusions) and the absence of an output schema, the description only covers the basic purpose. While the schema documents parameters, the description lacks preconditions, expected behavior, or result information, leaving important 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?

All 7 parameters have rich descriptions in the schema, including mutual exclusions (ipBlock vs. accessControlGroupSequence) and conditional requirements (portRange for TCP/UDP). The tool description itself adds no parameter information, so it does not exceed the schema baseline.

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

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

The description uses a specific verb 'Add' and a specific resource 'outbound rule to an Access Control Group', clearly distinguishing it from inbound rule tools like ncloud_add_acg_inbound_rule. It precisely conveys the action and target.

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

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

No guidance is provided about when to use this tool vs. alternatives such as ncloud_add_acg_inbound_rule, nor are prerequisites (e.g., existing ACG and VPC) mentioned. The description gives no context for selection.

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

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

Annotations only include destructiveHint=false, and the description adds no behavioral context beyond the basic action. It does not disclose whether the operation is idempotent, whether the server must be running, or what the response contains.

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

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

The description is a single sentence with no redundant words, front-loading the verb and object. It is concise 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?

The tool has no output schema, and the description omits return value details and preconditions. It is minimal for a mutation tool, lacking context about plugin replacement behavior or server requirements.

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 fully describes all three parameters (instanceNo, configList, type) with descriptions, and the description adds no additional parameter semantics. Since schema coverage is 100%, the baseline of 3 applies.

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

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

The description uses a specific verb ('add') and identifies the resource ('file monitoring plugin(s)') and target ('server instance'), distinguishing it from sibling tools like add_process_plugin and add_port_plugin.

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, such as whether it appends to existing plugins or replaces them, nor any alternatives. No context about prerequisites or comparison to sibling tools like set_file_plugins is given.

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

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

Annotations provide destructiveHint=false, but description adds no additional behavioral context. For example, does it replace existing certificates? Are there limits? What permissions are required? The description is minimal.

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

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

The description is a single sentence, front-loaded with the key verb and resource. It is concise with no unnecessary words, though could benefit from slight expansion.

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

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

For a simple add operation with no output schema, the description adequately states the purpose. However, it lacks any mention of return values, effects (e.g., certificate added to listener's list), or related actions, which would help the agent understand the tool's role.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description does not add any extra meaning beyond what is in the schema, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Add'), the resource ('SNI-based TLS certificate'), and the target ('load balancer listener'). It distinguishes from sibling tools like 'remove_lb_listener_certificate' and 'list_lb_listener_certificates'.

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

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

No guidance on when to use this tool vs alternatives. It does not mention prerequisites (e.g., listener and certificate must exist) or scenarios where adding a certificate is preferred over other operations like changing listener config.

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

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

Annotations only declare destructiveHint=false, but the tool is still a mutation operation. The description does not disclose whether sharing is additive or replaces existing permissions, whether the operation is idempotent, or what happens if permissions already exist. It adds no behavioral context beyond the basic action.

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

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

The description is a single, concise sentence that front-loads the core action and resource. There is no redundancy or filler; every word contributes to 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?

For a mutation tool with no output schema and minimal annotations, the description is too sparse. It omits important contextual details such as whether the operation is additive, whether target accounts must exist, or any error conditions. The agent lacks sufficient information to predict side effects or verify success.

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

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

Schema description coverage is 100%, with both parameters clearly documented in the schema. The description's phrase 'specified accounts' maps to targetLoginIdList but adds no additional semantic detail beyond what the schema already provides.

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

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

The description clearly states the action ('Add sharing permission'), the resource ('member server image'), and the target ('specified accounts'). It distinguishes itself from sibling tools like ncloud_add_server_image_sharing by explicitly naming 'member server image'.

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

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

Usage context is implied by the action verb 'Add' - an agent can infer this is for granting sharing access. However, there is no explicit comparison with alternatives like ncloud_set_member_server_image_sharing or ncloud_remove_member_server_image_sharing, and no prerequisites or exclusions are mentioned.

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

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

The only annotation is destructiveHint: false, which conflicts with nothing. The description adds no behavioral details beyond what the name suggests, such as idempotency, error scenarios, or prerequisites. With annotations covering the safety profile, the description still offers no extra context, so a score of 2 reflects the lack of added transparency.

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

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

The description is a single sentence with no redundant information, front-loading the action and target. It earns a 5 for efficiency and 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?

For a simple add operation, the description is functional but minimal. It does not mention response behavior, side effects, or validation rules, and there is no output schema to compensate. While the schema covers parameters, the description alone provides limited context beyond the tool's purpose, so a 3 is reasonable.

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

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

Schema coverage is 100% with clear descriptions for both parameters and nested user fields. The description does not add any additional meaning or clarify parameter usage, so the baseline of 3 applies.

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

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

The description uses the specific verb 'Add' with the resource 'users' and target 'Cloud DB for MongoDB instance', clearly distinguishing it from sibling tools like ncloud_list_mongodb_users, ncloud_change_mongodb_users, and ncloud_delete_mongodb_users.

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

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

The context is clear: this tool is for adding users to a MongoDB instance. However, it lacks explicit guidance about when not to use it (e.g., for modifying existing users) or mentions of alternatives. The verb 'Add' alone implies creation, but no explicit exclusions are stated, so a 4 is appropriate.

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

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

The annotation destructiveHint=false already indicates the operation is non-destructive, and the description adds no additional behavioral context. It does not mention potential failure conditions, idempotency, or any side effects beyond the simple addition of databases. The description is consistent with the annotation but does not enrich it.

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

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

The description is a single concise sentence that directly states the tool's action and target. There is no redundant or extraneous information, and it is appropriately sized for the tool's simplicity.

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

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

The tool is simple and has full schema coverage for inputs, but there is no output schema and the description does not explain what the response conveys (e.g., status or job details). It also does not mention constraints like duplicate database names or instance state requirements. The description is minimally sufficient but leaves some gaps for a fully informed agent.

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

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

The input schema provides full descriptions for both parameters (100% coverage), so the description does not need to compensate. The description itself adds no parameter-level detail, and the schema already explains that cloudMysqlInstanceNo is the instance number and cloudMysqlDatabaseNameList is the list of database names.

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

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

The description uses a specific verb 'Add' with a clear resource ('databases') and target ('Cloud DB for MySQL instance'), making the tool's purpose unambiguous. It naturally distinguishes itself from sibling tools like ncloud_delete_mysql_databases and ncloud_list_mysql_databases through the additive action.

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

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

The description implies usage (when you need to add databases to a MySQL instance) but provides no explicit context about when to choose this tool over alternatives, nor does it mention any prerequisites or exclusions. It is minimally adequate but lacks the comparative guidance seen in stronger examples.

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

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

The description adds no behavioral context beyond what the annotations already provide (destructiveHint=false). It does not mention permissions, idempotency, error scenarios, or side effects. The one-line description simply reiterates the tool's purpose without enriching the agent's understanding of the operation's behavior.

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

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

The description is a single concise sentence that directly states the action and target. Every word is necessary, and it is front-loaded with the main purpose. There is no redundancy or filler.

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

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

For a simple add operation with a well-detailed schema, the description is minimally adequate. However, it lacks useful context such as whether the operation is idempotent, what happens if a user already exists, or any prerequisites. Given no output schema, the agent might benefit from more information, but the tool's simplicity keeps it at an acceptable level.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters (cloudMysqlInstanceNo and cloudMysqlUserList). The description does not add any extra meaning beyond the schema, so it stays at baseline. It does not clarify the allowed values for 'authority' (e.g., READ, DDL, CRUD) which are enumerated only in the schema but not as enums.

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

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

The description clearly states the action (add) and the target resource (users to a Cloud DB for MySQL instance). It distinguishes this tool from siblings like ncloud_add_mysql_databases, ncloud_change_mysql_users, and ncloud_delete_mysql_users by specifying the exact operation and object.

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

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

The description implies usage: when you need to add users to a MySQL instance. However, it does not explicitly mention when not to use it or provide alternatives such as ncloud_change_mysql_users for modifying existing users. The guidance is minimal and relies on the user understanding the verb 'add'.

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

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

The annotations only include destructiveHint: false, and the description adds only the 'NFS protocol' context. It does not disclose whether the operation is additive/overwriting, whether it requires special permissions, or what side effects it may have on existing access rules. With minimal annotation coverage, the description carries a heavier burden that it does not meet.

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

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

The description is a single, concise sentence that is front-loaded with the action verb and resource. There is no unnecessary information, making it efficient and easy to parse.

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

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

For a simple two-parameter operation with full schema coverage, the description is mostly adequate. However, it lacks guidance on usage context and behavioral details (e.g., whether this appends to existing rules, whether it's idempotent). These gaps make it only minimally complete.

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

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

Schema description coverage is 100%, with both parameters well-described in the schema ('NAS volume instance number' and 'List of server instance numbers to grant access'). The description text adds no additional parameter meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Add') and the resource ('server instance access control to a NAS volume'), and specifies the protocol (NFS). However, it does not explicitly distinguish itself from the sibling tool 'ncloud_set_nas_volume_access_control', so it falls short of 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 such as 'set_nas_volume_access_control' or 'remove_nas_volume_access_control'. It does not mention any preconditions, limitations, or context for when this operation is appropriate.

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

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

The description adds no behavioral context beyond the action itself. Annotations only declare destructiveHint=false, so the agent knows it's non-destructive, but nothing about rule evaluation order, reversibility, or conflict handling is disclosed.

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

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

The description is a single sentence with no waste, front-loading the core purpose. It is appropriately sized for a simple add-operation where schema carries the parameter detail.

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

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

While the schema covers parameters, the description omits important context like priority ordering of rules, the mutual exclusivity of ipBlock and denyAllowGroupNo, and what happens when a rule already exists. It is sufficient for a basic understanding but not fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail, but the schema already provides meaningful descriptions for all 8 parameters, including examples and alternatives.

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 'Add an inbound rule to a Network ACL' clearly states the action (add) and resource (Network ACL inbound rules). It distinguishes itself from sibling tools like ncloud_add_network_acl_outbound and ncloud_remove_network_acl_inbound by specifying the rule direction.

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 (use for inbound rules) but provides no explicit guidance on when to choose this over alternatives, nor any exclusions. It does not mention related tools like the outbound counterpart, leaving the agent to infer from the name.

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?

Annotation destructiveHint: false tells the agent this is not destructive, but the description adds no further behavioral context. It does not mention whether rules are inserted with priorities, whether duplicates are allowed, or what happens on success. The description relies entirely on the annotation for safety disclosure.

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

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

The description is a single, concise sentence that gets straight to the point with no filler. It is appropriately sized for the tool's simple 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?

For a mutation tool with 8 parameters, no output schema, and minimal annotation, the description is too sparse. It does not hint at expected response content, any ordering constraints, or typical usage prerequisites. The one-line description leaves significant contextual gaps for an agent to make informed decisions.

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

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

Schema description coverage is 100% — all 8 parameters have individual descriptions (e.g., protocolTypeCode, ruleActionCode, ipBlock). The tool description itself adds no parameter meaning, so the baseline of 3 applies as the schema carries the semantic load.

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 'Add' and the resource 'outbound rule to a Network ACL', which distinguishes it from the inbound variant at a basic level. However, it does not explicitly reference sibling tools or provide additional context about what an outbound rule entails.

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

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

The description gives no guidance on when to use this tool as opposed to alternatives like ncloud_add_network_acl_inbound or ncloud_remove_network_acl_outbound. Usage is only implied by the tool name and the word 'outbound'.

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

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

The description only restates the action already evident from the tool name and annotations. With destructiveHint:false already declaring non-destructiveness, the description adds no additional behavioral context such as idempotency, effect on existing ACGs, or required 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 a single concise sentence of eight words, front-loading the action and resource without unnecessary words.

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

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

For a simple two-parameter tool with full schema coverage and an annotation, the description is minimally adequate but lacks details about the operation's effect on existing ACGs or failure conditions, which would be valuable for correct invocation.

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

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

The input schema fully describes both parameters (networkInterfaceNo and accessControlGroupNoList). The description adds no extra meaning beyond the schema, so it meets the baseline for complete schema coverage.

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

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

The description uses a clear verb 'Add' and specifies the resource 'access control groups (ACGs)' and target 'network interface'. This unambiguously distinguishes it from sibling tools like ncloud_remove_nic_acg.

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

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

No guidance is provided on when to use this tool versus alternatives such as ncloud_remove_nic_acg. The description simply states the action without prerequisites or exclusions, leaving the agent to infer usage from the name.

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

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

The description simply states the action without disclosing additional behavioral traits beyond what the 'destructiveHint: false' annotation already implies. It does not mention side effects, reversibility, or requirements. With the annotation covering the safety profile, the description adds marginal value, so a baseline score of 3 is appropriate.

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

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

The description is a single sentence with nine words, concisely and front-loaded with the action. Every word contributes to clarity, with no filler or repetition. It is optimally sized for a simple operation.

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

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

Given the simplicity of the operation (2 parameters, no output schema), the description is adequate at a basic level. However, it does not cover potential constraints (e.g., placement group capacity, server status) or explain the response format. For an agent, this is minimally sufficient but not rich enough to handle edge cases.

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

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

The input schema provides descriptions for both parameters ('Placement group number' and 'Server instance number to add'), giving 100% coverage. The description does not add extra meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Add') and resource ('a server instance to a placement group'), clearly stating the operation. It distinguishes itself from the sibling tool 'ncloud_remove_placement_group_server' by the opposite action. The tool name and description are aligned, leaving no ambiguity about what it 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 no guidance on when to use this tool versus alternatives, prerequisites, or any exclusions. For example, it does not mention that the placement group must exist or that the server must not already be in a placement group. This leaves the agent without context for appropriate invocation.

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

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

The annotation destructiveHint=false already covers non-destructiveness. The description adds little beyond stating the add action; it does not disclose idempotency, whether existing plugins are preserved, or any server state requirements. No contradiction with annotations, but no extra behavioral 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 a single, clear sentence with no filler words. It is appropriately front-loaded and concise.

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

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

The tool has a simple 3-parameter schema and a non-destructive annotation, but no output schema. The description does not mention response format, error conditions, or how this differs from ncloud_set_port_plugins, leaving some gaps for an agent. However, the schema and annotation provide adequate baseline context for a basic add operation.

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

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

Schema description coverage is 100%, with all three properties described (type with default and enum, portList as port numbers, instanceNo as server instance number). The tool description adds no parameter-level meaning beyond the schema, matching the baseline for high coverage.

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

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

The description uses a specific verb ('Add') and resource ('port monitoring plugin(s)') and targets 'a server instance', clearly distinguishing it from sibling tools like ncloud_list_port_plugins or ncloud_remove_port_plugin. It immediately conveys the action and scope.

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

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

The description gives clear context that this tool is for adding port monitoring plugins to a server, which distinguishes it from list/remove/get/set siblings. However, it does not explicitly mention when not to use it or name alternatives, so it lacks full exclusion guidance.

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

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

Annotations already provide destructiveHint=false, which matches the additive operation. The description adds that it targets a Cloud DB for PostgreSQL instance and supports a list of databases, but does not disclose behavior such as duplicate handling, prerequisite instance states, or idempotency. This is adequate but minimal given annotation coverage.

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

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

The description is a single, concise sentence with no filler or redundant information. It is front-loaded and immediately understandable.

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

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

For a simple two-parameter mutation with full schema coverage and a non-destructive annotation, the description plus schema provides sufficient information for correct invocation. It omits details about return values or constraints, but these are not critical for a straightforward add 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 descriptions cover 100% of the parameters ('Cloud PostgreSQL instance number' and 'List of databases to add'), so the description does not need to add parameter-level details. The phrase 'Add databases' aligns with the array parameter but provides no additional semantic value beyond the schema.

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

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

The description uses a specific verb ('Add') and a specific resource ('databases to a Cloud DB for PostgreSQL instance'), clearly distinguishing it from siblings like ncloud_add_postgresql_users and ncloud_delete_postgresql_databases. It precisely states what the 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 implies the usage context (when you need to add databases to a PostgreSQL instance) but does not provide explicit when-to-use/when-not-to-use guidance or mention alternatives. It is self-evident from the operation name but lacks explicit directional 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 only destructiveHint=false provided, the description adds no behavioral context beyond the annotation. It does not disclose what happens if a user already exists, whether the operation is idempotent, or any prerequisites. The description merely restates the action without revealing operational implications.

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

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

The description is a single sentence that is front-loaded with the action and resource. It is concise, free of unnecessary words, and easy to parse.

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

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

The description is adequate for a simple add operation with full schema coverage, but it lacks usage guidelines and behavioral context. Given the presence of many sibling tools with similar names, the description alone may not fully prepare an agent to choose and invoke this tool correctly.

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

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

The input schema already provides descriptions for both parameters with 100% coverage. The tool description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description clearly states the action ('Add users') and the specific resource ('Cloud DB for PostgreSQL instance'), which distinguishes it from sibling tools for other database engines (e.g., MySQL, MongoDB) and from related PostgreSQL operations like change/delete/list users.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this creates new database users, nor does it point to change_postgresql_users for modifying existing users or delete_postgresql_users for removing them. There is no context about prerequisites or when this operation is appropriate.

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

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

The only annotation is destructiveHint=false, so the description carries the burden of behavioral disclosure. It does not mention whether existing plugins are preserved, how duplicate names are handled, or if adding a wildcard affects monitoring behavior. The simple 'Add' action lacks important side-effect 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 composed of two concise sentences: one stating the action and target, the second explaining parameter usage. Every word adds value, and the key information is front-loaded.

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

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

For a simple mutation tool, the core functionality is covered, but the description lacks guidance on how the addition interacts with existing plugins and omits any mention of the optional 'type' parameter (which defaults to vpcserver). Additional context about idempotency or the effect of wildcards would make it more complete.

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

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

The schema already documents all three parameters, but the description adds valuable detail beyond the schema by noting that process names support wildcards (e.g., *abc*). This clarifies the intended format of the configList parameter, which the schema only describes as 'Process names to monitor'.

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

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

Description clearly states a specific verb and resource: 'Add process monitoring plugin(s) to a server instance.' This action is distinct from sibling tools like remove_process_plugin and set_process_plugins, making the purpose unambiguous.

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

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

The description provides clear context for adding plugins to a server instance and notes that wildcards are allowed. However, it does not explicitly contrast with the similar 'set_process_plugins' tool or specify when NOT to use this tool, leaving some ambiguity about the choice between additive and replacement 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?

The description only restates the basic action and adds no behavioral context beyond the annotation's non-destructive hint. It does not disclose prerequisites, potential conflicts with existing routes, target validation, or side effects, which are important for a network operation.

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

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

The description is a single sentence with no wasted words. It is appropriately concise and front-loaded, conveying the essential action immediately.

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

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

The description is minimal but the schema is detailed, covering all parameters. However, it does not explain the broader context of route tables or the outcome of the operation. Given the moderate complexity of the tool (networking resource), a bit more context would be helpful, but the current description is not wholly inadequate.

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

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

Schema description coverage is 100%, with each parameter having a clear description (e.g., targetTypeCode with allowed values, destinationCidrBlock with format). The description itself adds no parameter details, so it relies on the schema, which is sufficient. Baseline 3 is appropriate.

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

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

The description "Add a route to a route table" clearly states the action (add) and the resource (route to a route table), which distinguishes it from sibling tools like ncloud_remove_route or ncloud_list_routes. It is specific and unambiguous.

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

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

The description implies usage (when you want to add a route) but does not explicitly state when not to use it or mention alternatives. It lacks explicit exclusions or comparisons with related tools such as ncloud_remove_route.

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 annotations only providing destructiveHint=false, the description adds no further behavioral context—no mention of idempotency, effects on existing associations, failure conditions, or response behavior. It does not contradict annotations, but it also does not enrich them.

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

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

A single, front-loaded sentence conveys the purpose with zero wasted words. It is efficient and easy to parse, striking the right length for the simplicity of the operation.

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

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

The tool has no output schema and minimal annotations, yet the description provides no additional context about expected responses, preconditions, or side effects. For a mutation-like operation, this is insufficient for an agent to fully anticipate the outcome.

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

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

Schema coverage is 100% with each parameter briefly described. The description adds no additional parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description 'Associate a subnet with a route table' uses a specific verb and resource, clearly stating the action. It effectively distinguishes this tool from its sibling ncloud_remove_route_table_subnet by naming the opposite operation.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites, and no exclusions. The description simply states the action without contextualizing it in a decision process.

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

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

The description adds no behavioral context beyond the destructiveHint annotation. It does not disclose whether existing sharing permissions are preserved, whether the operation is idempotent, or what authorization is required. Since the annotation already indicates non-destructiveness, the description contributes minimal extra transparency.

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

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

The description is a single concise sentence that front-loads the primary verb 'Add' and fully communicates the operation without unnecessary words.

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

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

Given the simple two-parameter nature and rich schema coverage, the description is largely complete. However, it lacks differentiation from closely related sibling tools and does not provide usage context, which slightly reduces 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?

The input schema already provides clear descriptions for both parameters (serverImageNo and targetLoginIdList), covering 100% of the parameter semantics. The description does not add meaningful detail beyond what the schema already states.

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

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

Description clearly states the action (Add), resource (server image), and recipients (specified accounts). However, it does not distinguish between server image sharing and the sibling ncloud_add_member_server_image_sharing, which may cause ambiguity in tool selection.

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

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

No guidance is provided on when to use this tool versus alternatives like ncloud_add_member_server_image_sharing or ncloud_remove_server_image_sharing. Missing prerequisites, exclusions, or context for sharing permissions.

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

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

Annotations provide destructiveHint=false, so the safety profile is covered. The description adds minor context by clarifying targets are server instances but does not disclose other behavioral traits like idempotency, failure conditions, or whether existing targets are affected.

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

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

A single concise sentence that communicates the essential purpose with no redundant wording.

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

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

For a simple mutation with two fully described parameters, no output schema, and annotations covering destructive behavior, the description is sufficient for basic use. It lacks mention of prerequisites (target group existence) or duplicate handling, but these are not critical given the tool's simplicity.

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

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

Schema coverage is 100% with both parameters described (targetNoList and targetGroupNo). The description merely restates these concepts ('targets', 'target group') without adding format, relationships, or constraints beyond the schema.

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

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

The description clearly states the action (Add) and the resource (target group), specifying that targets are server instances. This distinguishes it from siblings like ncloud_remove_target (removes) and ncloud_set_targets (likely replaces all targets).

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

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

No explicit guidance on when to use this tool versus alternatives such as ncloud_set_targets or ncloud_remove_target. The context is implied but not stated, leaving the agent to infer when additive behavior is appropriate.

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

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

Annotations declare readOnlyHint=true, and the description confirms a read operation (download). It adds value by specifying return format (URL or binary data), but does not mention side effects, rate limits, or permissions. With annotations covering safety, a 3 is reasonable.

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

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

Two sentences, no wasted words. Front-loads purpose and output. Ideal conciseness.

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

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

Given no parameters and presence of annotations, description covers purpose and output. Could mention that it downloads results for all categories, but missing potential error handling or size limitations. Still fairly complete for a simple tool.

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

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

No parameters in input schema, so description does not need to elaborate. Baseline for zero-param tools is 4.

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

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

Description clearly states the action (download check results for all categories) and output format (download URL or binary data for Excel report). It distinguishes from sibling tools like ncloud_advisor_download_category_results and ncloud_advisor_download_item_results by specifying 'all categories'.

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

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

No explicit guidance on when to use this tool vs. category/item-specific alternatives. The name and sibling context imply it's for full downloads, but the description lacks direct if/then 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?

Annotations already indicate readOnlyHint=true, so the agent knows this is a safe read operation. The description adds that the tool returns a download URL or binary data for an Excel report, providing some output behavior. However, it does not disclose potential rate limits, size constraints, or authorization requirements beyond what annotations and schema imply.

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

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

The description is a single sentence that efficiently conveys the tool's purpose and output. Every word adds value, with no redundancy or unnecessary information.

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

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

For a simple tool with one parameter, the description is adequately complete, covering the action and the return format. It could optionally mention whether the download is synchronous or asynchronous, but the description gives sufficient context for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, with the parameter categoryCode having an enum description. The description does not add additional meaning beyond the schema, so it meets the baseline of 3.

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

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

The description clearly states the tool downloads check results for all items in a category, using the verb 'Download' and specifying the resource as 'check results for all items in a category.' This distinguishes it from sibling tools like ncloud_advisor_download_item_results and ncloud_advisor_download_all_results.

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 is clear about the tool's purpose (category-level download) but does not explicitly mention when not to use it or suggest alternatives. However, the context from sibling tool names provides implicit guidance, and the description is sufficiently unambiguous for an agent to select this tool for category downloads.

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

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

Annotations already indicate readOnlyHint=true, so the description does not need to reiterate that. It adds that the tool returns 'the download URL or binary data for the Excel report', which provides some behavioral context but does not fully disclose conditions for URL vs binary response or any limitations. No contradiction with annotations.

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

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

The description is two sentences, concise and front-loaded. Every sentence adds value: first sentence defines purpose, second sentence specifies return type. No wasted words.

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

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

Given the simplicity of the tool (two parameters, read-only, no output schema), the description covers the main aspects (download, target item, return format). It could mention whether the download is immediate or async, but overall sufficient for an agent to understand the tool's function.

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

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

Schema description coverage is 100%; both parameters (itemCode, categoryCode) have descriptions in the schema. The tool description adds no additional information about the parameters beyond what the schema already provides.

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

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

The description clearly states 'Download check results for a specific check item', indicating the verb (download) and resource (check results for a specific item). It distinguishes from sibling tools like ncloud_advisor_download_category_results and ncloud_advisor_download_all_results by specifying 'specific check item'.

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 (e.g., download_category_results, download_all_results, or get_item_result_detail). There is no mention of prerequisites, context, or when not to use it.

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

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

Annotations are empty, so the description must disclose behavioral traits. It implies mutation but lacks details on reversibility, overwrite behavior, required permissions, or side effects.

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

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

Two concise sentences clearly convey the purpose without superfluous content.

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

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

For a simple mutation tool with no output schema and all parameters required, the description is minimally adequate. However, it lacks usage guidance and behavioral details that would make it complete.

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

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

Schema coverage is 100% with parameter descriptions. The tool description adds marginal value by connecting the parameters to the action (e.g., instanceKeys are the instances to exclude), but does not explain categoryCode or itemCode beyond what the schema provides.

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

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

The description clearly states the action ('set instances to exclude', 'marks specified instances to be hidden') and the resource ('from check result detail view'). It distinguishes from sibling 'ncloud_advisor_include_instances' which performs the opposite operation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'ncloud_advisor_include_instances'. There is no mention of context, prerequisites, 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?

The annotation readOnlyHint=true already signals no side effects. The description adds that the tool returns an 'available inspection category list,' which is consistent and provides additional context about the output.

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

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

The description is two concise sentences that deliver the essential information without any filler. Every word serves a purpose.

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

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

For a simple read-only tool with no parameters and a clear purpose, the description is fully adequate. It explains what the tool does and what it returns, even though there is no output schema.

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

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

Since there are zero parameters, schema coverage is 100%. The description adds value by listing example categories (SECURITY, COST), giving users an idea of what to expect. This exceeds the baseline of 3 for no-parameter tools.

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

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

The description clearly states the tool retrieves Cloud Advisor check categories, with specific examples (SECURITY, COST). It uses a specific verb-resource combination and is distinct from sibling tools that handle check items or status.

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

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

The description implies usage for listing categories but does not explicitly guide when to use this tool versus alternatives like ncloud_advisor_get_checkitems or ncloud_advisor_get_category_status. No exclusion criteria or context hints are provided.

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

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

Annotations already provide readOnlyHint=true. The description adds that the tool returns counts but does not elaborate on other behavioral traits (e.g., data freshness, pagination). No contradiction.

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

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

Two concise sentences, front-loaded with the main action, no unnecessary words.

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

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

For a simple tool with one optional parameter and no output schema, the description adequately explains the return type (counts). Could be slightly more explicit about output format.

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 covers 100% of the parameter. Description explains the optionality and default behavior (returns all categories if omitted), adding value beyond the schema.

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

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

The description clearly states it retrieves a grade summary (GREEN/YELLOW/RED counts) for categories, which distinguishes it from sibling tools like ncloud_advisor_get_category_status. However, it does not explicitly differentiate from all siblings.

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

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

No guidance on when to use this tool vs alternatives like ncloud_advisor_get_checkitems or ncloud_advisor_get_category_result_summary. The description implies usage for summary counts but lacks explicit usage context.

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

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

Annotations declare readOnlyHint=true, indicating a safe read operation. The description confirms by stating it returns data, which aligns with the annotation. However, the description does not disclose additional behavioral traits such as whether results are paginated, what happens if the category has no items, or any rate limits. Beyond confirming read-only behavior, it adds only the return field details, which are part of the expected output. With annotations already covering the safety profile, the description provides marginal extra value.

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

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

The description is extremely concise: two sentences that front-load the core action ('Get check result summary for all items in a category') and then list the key return fields. Every word adds value, and there is no redundant or extraneous content. The structure is optimal for quick parsing by an agent.

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 is no output schema, the description partially specifies the return structure by naming three fields (alert level, summary text, last check time). However, it does not indicate whether the result is a list, an object, or how items are identified. For a tool that summarizes multiple items, the lack of structure detail could lead to incorrect parsing of the response. The description is adequate but not fully complete for a tool with no output schema.

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

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

The input schema has one parameter (categoryCode) with 100% description coverage via enum and description. The tool description does not add any additional meaning or context beyond what the schema provides. For instance, it doesn't explain the implications of each enum value or how the categoryCode relates to other advisor tools. Since the schema already documents the parameter fully, the description adds nothing to parameter semantics, meeting the baseline.

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

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

The description clearly states the tool gets a check result summary for all items in a category, specifying the verb 'Get' and resource 'check result summary'. It distinguishes from sibling tools like ncloud_advisor_get_category_status (which likely returns aggregated category status) and ncloud_advisor_get_item_result_summary (which returns detailed item results) by focusing on per-item alert levels, summary text, and last check time. However, it could be more explicit about how it differs from these siblings.

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

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

The description provides no guidance on when to use this tool versus alternatives such as ncloud_advisor_get_item_result_summary or ncloud_advisor_get_category_status. It does not mention prerequisites, typical use cases, or context where this tool is preferred. This leaves the agent to infer usage from the tool name and description alone, which is insufficient for correct selection.

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

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

Annotations indicate readOnlyHint=true, and description confirms read behavior. No additional behavioral details like caching or pagination are provided, but no contradictions exist.

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

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

Two concise sentences, front-loaded with purpose. No extraneous information, every word adds value.

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

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

Given simple parameter and readOnly annotation, description adequately explains what the tool returns. Could mention result structure but not essential 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?

Schema already defines categoryCode with enums. Description does not add meaning beyond what schema provides. Baseline score due to full schema coverage.

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

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

The description clearly states it retrieves check request availability status for all items in a category, distinguishing it from single-item or refresh tools. Verb 'Get' is specific and resource is well defined.

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

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

No explicit guidance on when to use this tool versus alternatives like ncloud_advisor_get_item_status or refresh tools. Usage is implied but not clarified with exclusion 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?

Annotations already declare readOnlyHint=true, so the safe-read nature is clear. The description adds what the output contains (item codes, names, etc.), which is useful beyond annotations. However, it omits behavioral details like potential error conditions, data freshness, or pagination (if any). With annotations covering safety, a 3 is appropriate.

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

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

The description is a single sentence, directly stating the purpose and output. No extraneous words, and it is front-loaded with the core action. Every part earns its place.

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

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

Given the tool's simplicity (1 required enum parameter, no output schema), the description is mostly complete. It explains what the tool does and what is returned. However, it does not clarify what 'result table header info' means or whether results are paginated. Minor gap, but overall sufficient.

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

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

Schema coverage is 100%, and the parameter 'categoryCode' is fully documented with enum values and descriptions in the schema. The description does not add further meaning; it only references 'a specific category'. Baseline 3 is correct.

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

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

The description clearly states the action ('Get'), the resource ('Cloud Advisor check items'), and the scope ('for a specific category'). It also lists the returned fields (item codes, names, descriptions, recommendations, header info), distinguishing it from sibling tools like ncloud_advisor_get_categories or ncloud_advisor_get_item_status.

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

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

The description does not provide guidance on when to use this tool versus alternatives. Among many sibling advisor tools (e.g., get_categories, get_item_status, refresh_item), there is no explicit context for selection. While it implies needing a category code, it lacks usage conditions 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?

Annotations already declare readOnlyHint=true. The description adds value by revealing that results are paginated and include instance status (GREEN/YELLOW/RED). This goes beyond the annotation to clarify the output format.

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

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

The description is two short sentences, immediately stating the purpose and key behavioral details (pagination, status). No unnecessary words; front-loaded with critical information.

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

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

For a read-only, paginated tool with fully described parameters, the description covers the main aspects: purpose, pagination, and status output. Missing details like default page/size or display filter options are already in the schema, so the description is sufficient.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add additional meaning beyond the schema; it only generally references 'specific check item', which is already covered by the itemCode and categoryCode parameter descriptions.

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

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

The description clearly states the tool retrieves detailed per-instance check results for a specific check item, using clear verb ('Get') and resource. It differentiates from sibling tools like ncloud_advisor_get_item_result_summary by specifying 'per-instance' detail level.

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

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

The description implies usage context (requires a check item and category) but does not explicitly guide when to use this tool over alternatives like ncloud_advisor_get_item_result_summary or ncloud_advisor_get_item_status. No when-not or exclusion criteria are provided.

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

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

Annotations declare readOnlyHint=true, which the description does not contradict. The description adds that it returns alert level, summary text, and last check time, but does not disclose any additional behavioral traits beyond what annotations provide.

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

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

Two concise sentences with no extraneous information. Every word adds value; the description is front-loaded with the main action and supported by expected output fields.

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

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

For a simple read-only tool with well-defined schema and annotations, the description adequately covers the return structure (alert level, summary text, last check time). No output schema exists, so the description compensates by listing fields. Minor improvement: could mention ordering or filtering, but sufficient for basic 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?

Input schema covers 100% of parameters (itemCode with examples, categoryCode with enum). Description adds no extra meaning beyond the schema, earning the baseline score of 3.

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

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

The description clearly states the verb ('Get') and resource ('check result summary for a specific check item'), and lists return fields (alert level, summary text, last check time). It distinguishes from sibling tools by focusing on a single item, but does not explicitly contrast with other advisor tools.

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

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

No guidance on when to use this tool versus alternatives (e.g., ncloud_advisor_get_category_status, ncloud_advisor_get_item_status). Missing context about prerequisites or when not to use it.

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

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

Annotations declare readOnlyHint=true, and the description confirms it shows status information (availability and processing state). Adds context beyond annotations by specifying what data is returned, without contradiction.

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

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

Two concise sentences that efficiently communicate the tool's function without redundancy. Every sentence adds value.

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

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

Adequately describes the function for a read-only tool without output schema. Lacks explicit return value structure but sufficient for an agent to understand the outcome.

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

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

Schema coverage is 100% with descriptions for both parameters (itemCode with examples, categoryCode with enum). The description does not add further parameter semantics, meeting baseline.

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

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

Clearly states the verb 'Get' and resource 'check request availability status for a specific check item'. Distinguishes from sibling advisor tools like ncloud_advisor_get_checkitems (list) and ncloud_advisor_get_categories by specifying it's for a single item with availability and processing state.

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

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

No explicit guidance on when to use this tool versus alternatives like ncloud_advisor_get_checkitems for listing or ncloud_advisor_refresh_item. The description does not provide context for selection.

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

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

Annotations are empty, so the description carries full burden. It only states the basic action without disclosing side effects, idempotency, permissions, or whether it adds to or replaces existing inclusions. For a modification tool, the behavioral transparency 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 extremely concise with two short sentences. It front-loads the action and provides the key purpose immediately. Every word serves a purpose.

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

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

Given the tool's simplicity (3 params, no output schema, no annotations), the description lacks context about the broader advisor workflow, persistence, or what happens after inclusion. The agent would benefit from knowing how this tool interacts with the check result detail view and the exclude 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 coverage is 100%, so the baseline is 3. The description adds no extra meaning beyond the schema; it merely refers to 'specified instances'. It does not elaborate on what categoryCode, itemCode, or instanceKeys represent in 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 tool's action: setting instances to include in the check result detail view. It explicitly mentions that it reverses exclusion, distinguishing it from the sibling tool 'ncloud_advisor_exclude_instances'. The verb 'Set' is specific and the resource is well-defined.

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 stating it 'reverses exclusion', which tells the agent when to use this tool (e.g., after an exclusion has been applied). However, it does not explicitly guide when not to use it or mention alternative approaches beyond the implied contrast with the exclude tool.

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

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

With no annotations, the description carries full burden. It fails to disclose key behavioral traits: whether the refresh is synchronous or asynchronous, if it returns immediately, or how to track progress. The statement is too brief for an action 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 concise with two short sentences and no unnecessary words. However, it could be restructured to fit more information into the same space.

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 trigger action with no output schema and no annotations, the description lacks important context: whether the operation is async, what the return value is, and how to monitor completion. This leaves the agent underinformed.

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 documentation covers 100% of parameters with description and enum values. The description adds no extra meaning beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description uses specific verbs 'request a check (refresh)' and 'triggers inspection', clearly indicating it initiates a refresh for all items in a category. It distinguishes from siblings like 'ncloud_advisor_refresh_item' which refreshes a single item.

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 (e.g., 'ncloud_advisor_refresh_item'). It does not mention prerequisites or typical use cases.

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

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

No annotations are present, so the description bears full responsibility for disclosing behavior. It states 'triggers inspection' which implies an async operation, but does not explain side effects, return behavior, or whether it is a mutation. This is insufficient for an understanding tool.

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

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

The description is extremely concise with only two short sentences. Every word adds value, and there is no fluff or repetition.

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

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

The description does not mention return values or expected output, and there is no output schema. For a tool that triggers an asynchronous inspection, the agent needs to know what to expect as a response, which is missing here.

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

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

Schema coverage is 100% with both parameters described. The description adds no additional meaning beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action (request a check/refresh) and resource (specific check item). It distinguishes from sibling tools like ncloud_advisor_refresh_category by targeting a single item, but does not explicitly call out that difference.

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

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

No guidance on when to use this tool versus alternatives, such as ncloud_advisor_refresh_category or other advisor tools. The description does not provide context for when a single item refresh is appropriate.

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

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

Annotations already declare destructiveHint=false. The description adds the dryRun feature for preview, which adds value beyond annotations. It clarifies the non-destructive creation behavior. However, it does not disclose other potential behaviors like authentication requirements or return format.

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

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

Two sentences with no fluff. The first sentence states the purpose, and the second adds a specific usage hint. Every sentence is valuable and front-loaded.

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

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

For a creation tool with 1 required and 2 optional parameters, the description covers the core functionality and adds the dryRun preview feature. However, it does not mention the return value or what the created API key contains, which could be useful given no output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mentions dryRun for preview, which aligns with its schema description. No additional meaning is added beyond what the schema already provides for the other 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 API key' and the resource 'in API Gateway'. It specifies the verb and resource, and among sibling tools like ncloud_apigw_list_api_keys and ncloud_apigw_delete_api_key, this tool is uniquely identified as the creation operation.

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

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

The description provides a usage hint for the dryRun parameter but does not explicitly guide when to use this tool versus alternatives. No mention of when not to use or comparison to list/delete operations. Usage is implied but not explicit.

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

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

Annotations indicate destructiveHint=false, which aligns with creation (non-destructive). The description adds the 'dryRun' preview behavior, but does not disclose other traits like idempotency, error behavior for duplicate stage names, or return value structure. With limited annotations, the description carries burden but only partially fulfills it.

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

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

Two sentences, no fluff. The purpose is front-loaded, and the dryRun hint is placed appropriately. Every word earns its place.

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

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

No output schema is provided, and the description does not hint at what the tool returns (e.g., stage details). It also omits prerequisites like the product must exist. For a simple create tool, this is adequate but not fully complete.

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

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

The input schema covers all 4 parameters with descriptions (100% coverage), so the schema already explains each parameter. The description adds minimal extra value beyond reiterating the dryRun behavior, which is already in the schema. Baseline 3 is appropriate.

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

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

Description clearly states the verb 'Create' and resource 'stage for an API Gateway product', distinguishing it from sibling tools like list_stages or delete_stages. It also mentions the dryRun feature, adding specificity.

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

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

Provides a specific usage hint for the dryRun parameter, which helps the agent preview without committing. However, it lacks guidance on when to use this tool versus alternatives (e.g., when to create vs. list/delete), and no prerequisites are mentioned.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds value by explicitly stating 'Destructive' and 'Permanently delete', and explains the confirm parameter's role as a safety mechanism. It does not discuss idempotency or error cases, but the key behavioral trait (destructive) is well communicated.

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

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

A single sentence with a warning emoji conveys all essential information. No superfluous text, and the most critical info (destructive nature and confirm flag) is front-loaded.

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

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

For a simple delete operation with full schema coverage and annotations, the description is sufficient. It explains the destructive action and the confirmation requirement. Missing details like return value are not critical given the tool's simplicity.

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

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

Schema coverage is 100% with both parameters described. The description reinforces the confirm parameter's purpose but does not add significant meaning beyond the schema. The apiKeyId parameter's meaning is clear from its name and schema description.

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

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

The description clearly states the tool's verb ('delete') and resource ('API key from API Gateway'), and the 'Permanently delete' indicates it's a permanent action. It distinguishes from sibling tools focused on other services or operations.

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

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

The description explicitly states the requirement to set confirm=true to execute, which acts as a usage guideline. However, it does not discuss when to use this tool versus alternatives like create_api_key or list_api_keys, but for a delete operation the context is clear.

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

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

Annotations already provide destructiveHint=true and idempotentHint=true. The description reinforces the destructive nature and adds the confirm parameter requirement, but does not disclose post-deletion behavior, idempotency implications, or permission requirements.

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

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

Extremely concise: a single sentence with a warning emoji. Every word is meaningful and front-loaded with the 'Destructive' warning.

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 delete operation, the description is minimally adequate. However, with no output schema, it lacks information on return values or post-conditions. The description does not explain what happens after deletion (e.g., confirmation message, error handling).

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

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

Schema coverage is 100% with all parameters having descriptions. The description's mention of 'Set confirm=true to execute' is redundant with the schema's confirm parameter description. No additional semantic value is added beyond what the schema provides.

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

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

The description clearly states 'Permanently delete an API Gateway stage' with a specific verb and resource. It distinguishes from sibling tools like ncloud_apigw_create_stage and ncloud_apigw_list_stages.

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 warning 'Destructive' and the instruction 'Set confirm=true to execute' provide clear usage guidelines. It implicitly tells the agent to use this only when intending to delete and to set the confirm flag, but does not elaborate on when not to use it or mention alternatives.

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

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

Annotations already declare 'readOnlyHint: true', indicating a safe read operation. The description adds no additional behavioral context beyond the surface-level 'get detailed information'. It does not mention any potential side effects, authentication needs, or data freshness, nor does it contradict the annotations.

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

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

The description is a single, front-loaded sentence that directly states the purpose. Every word earns its place, and there is no wasted text or redundancy.

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

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

The tool has a single parameter and no output schema. The description is minimal and does not hint at what kind of 'detailed information' is returned (e.g., pricing, specs, region). While sufficient for a basic get operation, it could be more informative given the complexity of API Gateway products.

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

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

Schema coverage is 100% with the parameter 'productId' described as 'Product ID to query'. The description does not add any additional meaning, format, or constraints beyond the schema. Baseline of 3 applies because the schema already covers the parameter.

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

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

The description clearly states the action ('Get detailed information') and the resource ('a specific API Gateway product'). The verb 'Get' and noun 'product' are specific, and the sibling tool 'ncloud_apigw_list_products' contrasts with this single-item retrieval, providing clear differentiation.

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

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

There is no explicit guidance on when to use this tool versus alternatives like 'ncloud_apigw_list_products'. The usage is implied by the name and description (use when you have a productId), but no exclusions or conditions are stated.

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

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

The annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds no additional behavioral context such as authentication needs, rate limits, or side effects. For a tool with annotations, the description should complement them, but here it merely restates the action.

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

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

The description is a single, front-loaded sentence of 11 words. Every word contributes meaning, and there is no wasted text. It is appropriately concise.

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

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

The description mentions 'details and API usage statistics' but does not specify what the response contains. With no output schema, the description should provide more completeness about the return value. For a simple read tool, this is adequate but not thorough.

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

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

The input schema has 100% coverage, with a description for the sole parameter 'usagePlanId'. The description adds no further meaning beyond the schema's 'Usage plan ID to query'. Baseline 3 is appropriate since the schema already documents the parameter adequately.

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

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

The description clearly states the action ('get') and the resource ('usage plan details and API usage statistics'), making the purpose evident. However, it does not explicitly differentiate from sibling tools like 'ncloud_apigw_get_product', though the resource type is different.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it does not mention that this retrieves a specific usage plan by ID, while a hypothetical list tool would be needed for browsing. Sibling tools include other API Gateway operations, but no comparative context is given.

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

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

Annotations already indicate readOnlyHint=true, so the read-only nature is clear. The description adds that it lists 'all' API keys, but does not disclose pagination behavior or potential limits beyond what the schema provides for limit and offset parameters.

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

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

The description is a single sentence of 7 words, making it very concise. It front-loads the key action and resource. However, it sacrifices some helpful detail that could be included without significant 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?

For a simple listing tool with no required parameters and a read-only annotation, the description is adequate. It covers the core purpose and, combined with the schema, provides a complete picture. The lack of output schema is typical for list tools.

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

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

Schema description coverage is 100% for both parameters (limit and offset), so the schema already provides necessary parameter meaning. The description adds no additional semantic information beyond the schema.

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

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

The description clearly states 'List all API keys in API Gateway', specifying the verb 'list' and the resource 'API keys in API Gateway'. It distinguishes from sibling tools like ncloud_apigw_list_apis and ncloud_apigw_create_api_key by focusing on keys specifically.

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 ncloud_apigw_create_api_key or ncloud_apigw_delete_api_key. It does not mention any prerequisites, filters, or conditions for use.

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

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

Annotations already indicate readOnlyHint=true, so the read-only nature is clear. The description adds no additional behavioral context such as pagination behavior or rate limits, providing no extra value over the annotations.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It is efficient but could benefit from additional optional context.

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

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

No output schema is provided, and the description does not describe the return format or fields. For a list operation with 4 parameters and no output schema, this is adequate but incomplete for an agent to fully understand what the tool returns.

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

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

Schema coverage is 100%, and the description does not add meaning beyond what the parameter descriptions already provide. The description's mention of 'specific API Gateway product' is redundant with the productId parameter description.

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

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

The description clearly states the action (list), resource (APIs), and scope (in a specific API Gateway product), distinguishing it from siblings like ncloud_apigw_list_products and ncloud_apigw_list_stages.

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

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

No explicit when-to-use or when-not-to-use is provided. Usage is implied by the description and sibling context, but no guidance on alternatives or prerequisites is given.

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

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

The annotations already declare readOnlyHint=true, so the description adds no further behavioral context. It does not disclose pagination behavior, sorting, default limits, or the structure of the response (no output schema). For a simple list tool, some behavioral details are missing.

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

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

The description is a single, concise sentence with no extraneous information. It is front-loaded and serves its purpose efficiently.

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

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

The tool is simple with no output schema, but the description lacks details on what information the list returns (e.g., product names, IDs, pricing). An agent may need more context to effectively use the output. While sufficient for a basic list, completeness could be improved.

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

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

Schema coverage is 100% with both parameters (limit, offset) described in the schema. The description does not add any additional meaning beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'List' and resource 'all API Gateway products'. It is specific enough to distinguish from other list tools that list different entities (e.g., servers, VPCS). However, it does not specify what constitutes an API Gateway product (e.g., SKU, plan), which could be clarified.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, use cases (e.g., fetching available products for creating an API Gateway), or when not to use it. The agent must infer its purpose from the name alone.

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

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

The annotations provide 'readOnlyHint: true', so the read-only nature is already indicated. The description does not add further behavioral traits such as pagination support or response size limitations. With annotations, a score of 3 is appropriate.

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

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

The description is a single sentence of 10 words, fully front-loaded with the action. Every word adds value with no redundancy.

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

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

For a simple list tool with 3 parameters and no output schema, the description adequately states the purpose. However, it lacks details about output structure, pagination behavior, or any error scenarios. Given the context of many sibling tools, more completeness could help an agent.

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

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

Schema description coverage is 100%, so the baseline is 3. The description only mentions 'productId' implicitly ('for a specific API Gateway product') but does not clarify 'limit' or 'offset' beyond what the schema already provides.

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

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

The description clearly states 'List all stages for a specific API Gateway product', using a specific verb and resource. It differentiates from sibling tools like 'ncloud_apigw_list_apis' and 'ncloud_apigw_list_products' which list different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a product ID obtained from another tool) or any exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the action and parameter choice, but does not mention any side effects, prerequisites (e.g., network interface must exist), limitations, or whether the assignment is immediate or asynchronous. This is a significant gap for a mutation operation.

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

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

The description is two sentences, front-loaded with the core purpose, and every piece of information is useful. There is no redundancy or fluff.

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

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

For a simple tool with complete schema coverage, the description is adequate but lacks contextual details such as expected output, whether the operation is reversible, or any constraints on the number of secondary IPs. The lack of annotations and output schema makes the description the only source for such behavior, but it remains minimal.

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

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

The schema covers 100% of parameter descriptions, but the description adds crucial semantic context by indicating that secondaryIpList and secondaryIpCount are mutually exclusive alternatives. This is not present in the schema, which merely lists the parameters without this relationship.

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

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

The description uses a specific verb ('Assign') and resource ('secondary IPs to a network interface'), clearly stating the tool's function. It also distinguishes from the sibling tool ncloud_unassign_secondary_ips by the action of assigning versus unassigning.

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 usage context by explaining the two modes: provide either secondaryIpList or secondaryIpCount. This helps the agent choose the right parameters. However, it does not explicitly mention alternatives or when not to use this tool, but the name and clear action make the use case evident.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds no behavioral details beyond the action itself, but it does not contradict the annotations. No extra context like side effects or preconditions is provided.

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

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

A single, direct 9-word sentence that starts with the action verb and states the object. No wasted words, perfectly concise.

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

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

For a simple two-parameter action with full schema coverage and helpful annotations, the description is mostly adequate. It lacks usage guidance and behavioral context, but the tool's complexity is low, so the overall information is sufficient for basic invocation.

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

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

Schema description coverage is 100%; both 'publicIpInstanceNo' and 'serverInstanceNo' have clear descriptions in the schema. The tool description adds no additional parameter semantics beyond what the schema already states.

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

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

The description uses the specific verb 'Associate' with clear resources: 'a public IP with a server instance.' It unambiguously distinguishes this tool from siblings like 'ncloud_disassociate_public_ip', 'ncloud_create_public_ip', and 'ncloud_delete_public_ip'.

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

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

No guidance is provided about when to use this tool versus alternatives. It does not mention prerequisites, such as requiring an unassociated public IP or the server being in a valid state, nor does it suggest when to prefer the disassociate or create 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?

The description discloses the non-obvious polling behavior ('Automatically waits... polls until status is CREAT'), adding value beyond the annotations. It aligns with the idempotentHint and destructiveHint annotations, and no contradictions are present.

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

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

The description is two concise sentences, front-loaded with the main action followed by a key behavioral note. No wasted words, making it highly efficient.

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

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

For a simple two-parameter tool with annotations, the description covers purpose and the main behavioral nuance. It lacks details like timeout behavior or prerequisites, but these are not essential for the basic use case, so it is nearly 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?

Since schema description coverage is 100% and both parameters have clear descriptions in the schema, the tool description adds no additional parameter semantics. Baseline of 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Attach a block storage instance to a server.' It also adds the unique behavior of waiting for creation, distinguishing it from related tools like detach, create, or delete block storage.

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

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

The description provides clear context for when to use the tool (attaching a block storage to a server) and even specifies the automatic waiting behavior, which guides the user on expected execution. However, it does not explicitly mention alternatives or exclusions, hence not a 5.

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

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

The annotations already declare idempotentHint=true and destructiveHint=false, so the agent knows the operation is safe and repeatable. However, the description adds no extra behavioral context such as prerequisites, side effects, or state changes beyond the literal action, and does not mention anything about server/interface states.

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

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

One concise sentence with no redundancy or filler; clearly front-loaded with the action. Every word earns its place.

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

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

Given the simple two-parameter operation, the schema provides complete parameter descriptions, and annotations cover safety traits. However, the description omits usage context and behavioral nuances such as whether the network interface must be detached first or if the server must be in a specific state, leaving the overall context slightly incomplete.

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

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

The schema fully covers both parameters with clear descriptions, and the description aligns with them. No additional parameter details are needed beyond what the schema already provides.

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

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

The description uses a specific action verb 'Attach' with a clear resource 'network interface' and target 'server instance', making it distinct from sibling operations like detach_network_interface, create_network_interface, and add_nic_acg. It fully identifies what the 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?

No guidance is provided on when to use this tool versus alternatives such as ncloud_detach_network_interface or ncloud_create_network_interface. The description simply states the operation without context on prerequisites, state requirements, or alternative actions.

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

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

The description adds no behavioral information beyond the annotations. Annotations already declare idempotentHint=true and destructiveHint=false, and the description only restates the operation without disclosing whether it replaces existing policies, requires specific permissions, or affects group members. No contradiction exists, but no extra context is provided.

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

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

The description is a single, concise sentence that directly states the tool's purpose without redundant words. It front-loads the action and is easily 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 simplicity (two required string parameters, no output schema, and annotations covering idempotency and non-destructiveness), the description is mostly complete. It clearly conveys the core function. However, it does not clarify whether the operation is additive or replaces existing policy attachments, which could be relevant for users. This minor gap prevents a perfect score.

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 fully describes both parameters (groupId and policyIdList) with clear descriptions, achieving 100% schema coverage. The tool description does not add additional parameter semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description 'Assign IAM policies to a group' clearly specifies the action (assign), the object (IAM policies), and the target (group). It distinguishes this tool from sibling tools like ncloud_attach_policy_to_sub_account and ncloud_detach_policy_from_group by naming both the resource and the recipient.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention scenarios where attaching policies to a group is preferred over attaching to a sub-account, nor does it reference detach operations or any prerequisites. The tool name suggests usage, but the description itself lacks explicit usage context.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the agent knows the operation is safe to retry and non-destructive. The description adds no extra behavioral context, such as whether existing policy assignments are replaced or appended, or what response is returned. 'Assign' is vague about the effect on existing policies.

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

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

The description is a single, front-loaded sentence that states the action and target without any wasted words. Every word earns its place.

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

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

The tool is simple with only two well-documented parameters and informative annotations, so the description is mostly adequate. However, it lacks guidance on usage alternatives and does not disclose the effect on existing policy assignments, making it slightly incomplete for an agent deciding between attach/detach operations or handling retries.

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

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

Schema description coverage is 100%, with clear descriptions for both subAccountId and policyIdList. The tool description adds nothing about parameter semantics beyond what the schema already provides, so the baseline 3 applies.

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 ('assign'), the resource ('IAM policies'), and the target ('sub account'), which distinguishes it from sibling tools like attach_policy_to_group. It is a specific, unambiguous statement, though it closely paraphrases the tool name without additional nuance.

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

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

The description implies the use case: you use this tool when you want to assign IAM policies to a sub account. However, it does not explicitly state when not to use it or mention alternatives such as the sibling tool ncloud_attach_policy_to_group for group attachments.

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

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

Annotations already indicate idempotentHint=true and destructiveHint=false. The description adds the 'running' qualifier, which is useful context, but does not describe side effects, error conditions, or what happens if the execution already completed. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to understanding the tool's function.

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

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

For a simple cancellation tool with two well-documented parameters and supportive annotations, the description is nearly sufficient. It lacks details about response format or behavior on non-running executions, but the 'running' qualifier and idempotency hint cover the main edge cases.

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

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

Schema coverage is 100% and both parameters include descriptions (projectId as 'Pipeline ID' and historyId with source hints). The tool description adds no additional parameter meaning beyond what the schema already provides, so baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Cancel') and the exact resource ('running SourcePipeline pipeline execution'). It is distinct from sibling tools like ncloud_sourcebuild_cancel_build or ncloud_sourcedeploy_cancel_deploy because it names SourcePipeline explicitly.

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

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

The description implies when to use it (when canceling a running SourcePipeline execution) but does not explicitly mention alternatives or exclusion cases. No reference to sibling tools such as ncloud_sourcebuild_cancel_build, leaving some ambiguity for an agent choosing among cancel 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?

Annotations only include destructiveHint: false, so the description must disclose behavioral traits. It does not mention whether the operation is asynchronous, has side effects, requires permissions, or is reversible. The description only states the action without any context about how it 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 one short sentence with no fluff, making it efficient and front-loaded. However, it is under-specified, but that is more a completeness issue than a conciseness issue.

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 mutating operation on a cluster and there is no output schema, the description is incomplete. It does not explain what a CDSS cluster is, any prerequisites, potential impacts, or operation semantics. The agent lacks enough context to use it confidently.

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

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

Schema description coverage is 100%, with both parameters (newBrokerNodeCount, serviceGroupInstanceNo) already documented in the input schema. The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description states a specific verb ('Add') and resource ('broker nodes to a CDSS cluster'), clearly distinguishing it from sibling tools like ncloud_cdss_change_node_spec (which modifies existing nodes) and ncloud_ses_add_node (for a different service). It is unambiguous about the action being performed.

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, no prerequisites (e.g., cluster must exist), and no exclusions or caveats. It is a bare statement of the action, leaving the agent to infer context.

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