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 already declare readOnlyHint=true, so the safety profile is covered. The description adds that the output is an Excel (.xlsx) report and that it either saves to disk or returns base64, but the dual-output behavior and the 256 KB inline cutoff are already spelled out in the schema, so incremental value is modest.

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

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

Two short, front-loaded sentences with no filler: the action and scope come first, the output behavior second. Nothing is wasted, though it is minimal rather than richly 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?

For a read-only download with one fully documented parameter and a readOnlyHint annotation, the definition covers what the tool returns (an Excel report of all categories) and how the output is delivered. No output schema exists, but the file nature of the result is stated, so little is missing.

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

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

Schema coverage is 100% for the single savePath parameter, and the description merely restates its save-vs-inline behavior without the size threshold the schema provides. Baseline 3 is appropriate when the schema does the documentation work.

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

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

States a specific verb and resource ('Download the complete Excel report of check results') plus the scope qualifier 'for all categories', which implicitly separates it from ncloud_advisor_download_category_results and ncloud_advisor_download_item_results. It stops short of naming those siblings, so the differentiation is left to inference.

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

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

The phrase 'for all categories' implies when this tool is appropriate versus the category- or item-scoped download siblings, but no explicit when-to-use or alternative routing is given. Adequate but leaves the agent to infer the boundary.

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

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

With readOnlyHint already covering the safety profile, the description adds real behavioral detail: the output is an Excel file and it either writes to savePath or is returned inline as base64. This reveals the dual output mode beyond what annotations state.

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

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

Two compact sentences with the primary purpose front-loaded and the output behavior second; no wasted words.

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

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

For a read-only download tool with no output schema, the description tells the agent what is produced (Excel report) and how it is delivered (savePath or base64), which is enough to call it correctly. Only the relationship to sibling download/summary tools is left implicit.

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 both parameters (including the SECURITY/COST enum and the 256 KB inline constraint) are already fully documented in the schema. The description's mention of savePath and base64 merely restates this, adding no syntax or format detail 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?

States a specific verb ('Download'), the artifact ('Excel report of check results'), and the scope ('all items in a category'). The category scope implicitly distinguishes it from the sibling item-level and all-level download tools, though it does not name them 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?

Usage is only implied by the scope phrase 'for all items in a category'; there is no explicit when-to-use guidance or reference to the sibling tools (download_item_results, download_all_results, get_category_result_summary) that an agent would need to choose between.

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 profile is covered. The description adds the dual output mode (file save vs inline base64), which is useful behavioral context, though it largely restates what the savePath schema description already says. No pagination, size-limit, or auth details beyond that.

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

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

Two short sentences, with the core purpose front-loaded and the output behavior second. No filler or redundancy.

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

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

No output schema exists, but the description explains the two return modes (savePath file or base64 inline). Combined with a 100%-covered schema and readOnly annotation, an agent has enough to call it correctly; only the item/category relationship to sibling tools is left implicit.

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

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

Schema description coverage is 100%, so all three parameters (itemCode, savePath, categoryCode) are already documented in the schema. The description only echoes the savePath behavior and adds nothing about itemCode or the categoryCode enum, 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?

States a specific verb (Download) and resource (Excel report of check results) with an explicit scope qualifier ('for a specific check item'). That scope cleanly distinguishes it from the sibling item/category/all download variants without needing to name them.

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

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

The phrase 'for a specific check item' implies when to use this over the category/all downloads, but there is no explicit when-to-use guidance, prerequisite (e.g., must item be refreshed first), or named alternative. Usage is inferred rather than stated.

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

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

Annotations 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?

Only destructiveHint=false is annotated, so the description carries most of the behavioral burden. It usefully discloses the dryRun preview behavior, adding real context beyond the annotation. It does not, however, describe side effects of creation, deployment implications, or required permissions for a 13-parameter mutation.

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

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

Two short sentences, front-loaded with the core action and followed by the single most useful operational hint. No filler, 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 create tool with 13 parameters and only a destructiveHint annotation, the description is thin: it does not mention creation side effects, whether a deployment step is implied, or auth requirements. The rich schema and destructiveHint=false cover part of the gap, but the behavioral picture is not fully rounded out.

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

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

Schema description coverage is 100%, so all 13 parameters are already documented in the schema. The description only calls out dryRun, which the schema already explains in full, so it adds no semantic detail beyond the structured data. 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?

States a specific verb+resource: creating a stage for an API within an API Gateway product. The 'create' verb cleanly separates it from the sibling read/delete tools (ncloud_apigw_get_stage, ncloud_apigw_list_stages, ncloud_apigw_delete_stage). It does not explicitly name a sibling for comparison, so it stops 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?

Provides one actionable usage tip ('Use dryRun=true to preview without creating'), which is genuinely helpful. However it gives no guidance on when to prefer this over alternatives or on prerequisites (e.g. that a product and API must already exist), leaving usage largely implied.

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 declare destructiveHint=true and idempotentHint=true, so the 'Destructive' label mostly restates structured data. The description does add that deletion is permanent and gates execution behind confirm=true, but the confirm requirement is also already spelled out in the schema, so genuine new behavioral context is thin (no cascade effects, async behavior, or permission notes).

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

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

Two short sentences, warning and consequence front-loaded, with the required action at the end. Nothing is wasted and no explanation must be read past to act.

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

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

For a low-complexity single-object delete with fully documented parameters, no output schema requirement, and annotations that already carry the safety profile, the definition covers what an agent needs. It is only slightly short on what happens to dependent resources (routes, keys, usage plans) after the stage is removed.

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%: apiId, stageId, productId and confirm each carry their own descriptions. The description only echoes confirm=true, adding no syntax, format, or hierarchy meaning beyond what the schema already provides. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource (delete an API Gateway stage) plus the consequence (permanent). An agent can distinguish it from ncloud_apigw_get_stage / list_stages / create_stage by name alone. It does not explicitly name any sibling, so it stops short of full differentiation.

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

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

The only guidance is the operational directive 'Set confirm=true to execute', which is really an invocation requirement rather than when-to-use advice. No conditions for choosing this over alternatives (e.g. removing a stage vs. recreating it) or prerequisites such as stage state are given; usage is implied by 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?

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?

With readOnlyHint=true already declaring the safe-read profile, the description contributes no additional behavioral context such as whether the stage is returned with any truncation, permission requirements, or freshness. It restates the read nature without adding 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?

A single efficient sentence with the resource and scope front-loaded. No waste, though it is arguably too terse to be maximally useful.

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 tool with full parameter descriptions and a readOnlyHint annotation, the definition is minimally adequate. No output schema exists, so it need not describe returns, but nothing about identity semantics of the three IDs is added.

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 all three required parameters (productId, apiId, stageId) are documented in the schema. The description adds no format or hierarchy detail beyond what the schema already provides; 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?

States a specific verb (get) and resource (details of a single stage of an API in an API Gateway product), which distinguishes it implicitly from list_stages, create_stage, and delete_stage siblings. It is clear but never names the sibling it complements.

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 when-to-use guidance. The word 'single' hints that list_stages is the bulk alternative and create/delete are the mutations, but the agent must infer this from the verb alone; no prerequisites 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?

readOnlyHint=true already establishes safety; the description adds the domain-scoping fact that it lists within an API Gateway product and that apiId must be obtained elsewhere. No output schema, so return shape is left implicit, which is the main gap for a list operation.

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

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

Two short sentences, purpose front-loaded, prerequisite second. No filler.

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

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

For a simple two-param read-only list tool with a complete schema and annotations covering the safety profile, the description supplies the essential prerequisite (how to get apiId) and the scope. Return/pagination behavior is not described, but with no output schema that is a minor omission.

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 apiId and productId, so the schema carries the parameter semantics. The description only hints that apiId comes from ncloud_apigw_list_apis, which is a routing aid rather than additional parameter detail. Baseline 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?

States a specific verb (List) and resource (all stages of an API in an API Gateway product) and scopes it to a product/api. Clearly distinguishes from sibling ncloud_apigw_get_stage (singular) and ncloud_apigw_create_stage/delete_stage.

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 concrete pointer for obtaining a required input: 'Find apiId with ncloud_apigw_list_apis.' That is clear context. It does not, however, discuss when to use this vs. the get_stage sibling 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.