HuaweiCloud DevKit (Remote Demo)

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

The description discloses the behavioral effects of each decision: 's1' keeps the existing account as source of truth and propagates it, while 'newImported' propagates the newly imported account and mirrors it. This gives a clear picture of what will happen after confirmation. It does not mention potential side effects or irreversible actions, but the decision outcomes are sufficiently described for a confirmation 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 concise, consisting of two sentences that front-load the main action and then explain decision options. It uses clear formatting with semicolons to separate the two decision outcomes, making it easy to parse. Every sentence contributes essential information without extraneous detail.

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

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

Given the tool's role in a larger auth workflow, the description provides sufficient context by referencing auth_switch persist and explaining the scenario. It covers the decision semantics, which is critical for the agent. The use of 'S1' and 'R2' without expansion is a minor gap, but the surrounding sibling tool names and the description itself give enough context to infer meaning.

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

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

The description fully explains the 'decision' parameter by listing both enum values and their meanings, which the schema does not cover. The 'token' parameter is already described in the schema as 'confirmation token from the needs_confirmation response', and the description does not add further detail, but together the schema and description provide complete coverage of both parameters.

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

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

The description clearly states the tool's purpose—confirming a pending credential reconciliation choice—and provides specific context about the scenario (returned by auth_switch persist). The two decision options are explicitly named, which helps distinguish it from sibling auth tools. However, it relies on abbreviations like 'S1' and 'R2' without explanation, which slightly reduces clarity for an agent unfamiliar with the internal system.

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

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

The description gives a clear condition for use: when auth_switch persist returns a pending choice and S1 already holds a different account. It also explains the two possible decisions and their outcomes, effectively guiding the agent on what to do in this scenario. It does not explicitly contrast with alternatives, but the condition makes it clear when this tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of explaining behavior. It clearly states that runtime credentials take highest priority and that clear=true reverts to env/file credentials. However, it does not mention error handling or side effects (e.g., whether credentials are persisted across sessions or if invalid AK/SK are rejected), leaving minor gaps.

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

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

The description is concise and well-structured: two sentences front-load the primary action and usage scenario, with no redundant or extraneous information. It is immediately scannable and actionable.

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

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

For a tool with four parameters and two operational modes, the description covers the core purpose, usage, and behavioral scope. It does not mention output or error cases, but given the absence of an output schema and the simplicity of the operation, the provided context is sufficient for an agent to call it correctly in most scenarios.

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 descriptions already cover each parameter thoroughly (ak, sk, clear, region). The main description adds value by explaining the conditional relationship (ak/sk vs. clear) and the precedence rule, but does not introduce new parameter-specific details beyond what the schema provides, so it is strong but not exceptional.

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

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

The description clearly states the tool's purpose: setting or clearing runtime Huawei Cloud credentials for the current MCP session. It explicitly distinguishes it from related auth tools (e.g., auth_switch, auth_status) by focusing on session-scoped credential management and precedence over environment variables.

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

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

The description provides explicit guidance on when to use the tool: 'Use when switching accounts within the same Agent session.' It also clarifies the two modes of operation (AK/SK or clear=true) and the effect on subsequent calls, making the appropriate usage unambiguous.

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, but the description itself discloses key behavioral facts: it returns only redacted/status information and never credentials. This is transparent and prevents misuse, though it does not detail all side effects (e.g., no changes are made).

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

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

The description is one sentence, directly states the purpose and the safety guarantee, and includes no filler. It is well-structured 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 status-check tool with no output schema, the description provides enough context about scope and security. It could mention what statuses are returned (e.g., active/inactive) but that is not critical for selecting the tool.

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

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

The single parameter 'target' has a description listing valid values (opencode, codex, etc.). Schema coverage is 100%, so the description adds value but does not go beyond enumerating options; it is clear and sufficient.

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 'Check' and clearly identifies the resource: unified Huawei Cloud authentication status across credential vault, OBS, KooCLI, and agent MCP registrations. It is distinct from sibling auth tools (init, confirm, switch, sync) by focusing on status retrieval.

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 checking authentication state and explicitly states it returns only redacted/status information, never credentials. However, it does not explicitly state when to use this tool versus auth_confirm or auth_sync, leaving some inference to the agent.

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

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

With no annotations present, the description carries the full transparency burden and does so admirably. It discloses side effects: temporary credentials are lost on restart, persist writes and propagates, clear resets, import reads then wipes the file, and memory exposes the SK to the model.

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 dense but not bloated; every clause adds operational detail. It front-loads the core purpose and then systematically explains action and mode variants, though the single-paragraph format is a bit long and could benefit from structured bullets.

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?

Core behavior and side effects are well covered, but there is no mention of output/return values, error cases, prerequisites, or whether parameters like region and securityToken are required or optional. This leaves moderate gaps for an agent deciding how to invoke the tool.

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

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

Only two parameters (mode and action) have schema descriptions, so the description must compensate for the other four. It clarifies ak/sk in the context of import vs memory, but region and securityToken receive no explanation at all, leaving their role and optionality unclear.

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

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

The description states a specific action—switching Huawei Cloud credentials within the current session—and enumerates the action/mode variants. It is clear enough to distinguish from sibling auth tools, though it does not explicitly name those alternatives.

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

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

The description gives practical guidance on mode choices, such as preferring import because the SK never enters the conversation, and explains persistence/clear semantics. However, it does not explicitly say when to use this tool versus sibling tools like auth_init, auth_confirm, or auth_status.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose a key safety property—'Does not write secrets into any agent config'—which is valuable. However, it does not mention that syncing to OBS likely mutates external state, nor does it describe any permissions needed, reversibility, or side effects on existing OBS content. For a sync operation, more transparency about what changes are made and whether it is safe to run is expected.

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 primary action and followed by a precise safety clarification. There is no redundant phrasing or filler. Every word earns its place, and the structure is efficient for an agent scanning for the core purpose.

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

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

The tool has a simple signature (one optional parameter, no output schema), so the baseline complexity is low. The description covers the main purpose and one key safety aspect, but it lacks guidance on the expected return value (the 'agent registration status' is vague) and does not clarify the relationship with other auth tools. Given no annotations or output schema, a slightly richer description of what the report contains and when to invoke this tool would be helpful. It is adequate but not 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 single parameter 'target' is fully documented in the input schema, listing all allowed values and the default. The description adds no additional information about the parameter, so it does not go beyond the schema. Given 100% schema coverage, a baseline score of 3 is appropriate; the description does not need to repeat the schema, but it also adds no extra semantic nuance.

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 (synchronize credentials), the resource (global Huawei Cloud credential vault to OBS), and the additional outcome (report agent registration status). It also includes a specific safety constraint (does not write secrets into any agent config). This is specific enough to distinguish from sibling auth tools like huaweicloud_auth_init or huaweicloud_auth_switch, which focus on initialization or switching rather than syncing to OBS and status reporting.

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 any guidance on when to use this tool versus its many siblings. It doesn't mention prerequisites (e.g., whether huaweicloud_auth_init must run first), nor does it contrast with alternatives like huaweicloud_auth_status or huaweicloud_auth_switch. There is no explicit 'use this when' or 'instead of' information, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose that output is redacted, which signals careful secret-handling. However, it does not state whether the check is read-only (implied but unconfirmed), what error behavior occurs when hcloud is absent, whether network access is involved, or whether any state is modified.

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 and approximately 14 words, with the verb and subject front-loaded. Every word contributes meaning; there is no padding, redundancy, or tangential 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?

For a zero-parameter check tool, the description is nearly complete. It conveys the action, the target resource, and the redaction behavior. The only gap is the exact shape of the return value, but 'returns redacted output' provides sufficient agent guidance for a simple preflight check, and the absence of an output schema makes some ambiguity unavoidable.

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 is empty with zero parameters, so schema coverage is vacuously 100%. There are no parameters for the description to elaborate on, yielding the baseline score of 3. Nothing is missing because nothing exists to describe.

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

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

The description states a specific verb ('check') and a specific resource ('Huawei Cloud KooCLI hcloud is installed'), which clearly distinguishes it from sibling command-execution tools like huaweicloud_run_approved_command or huaweicloud_plan_cli_command. However, the output format (boolean, status message, version string?) is not specified, which leaves slight ambiguity about what 'check' produces.

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 is given for when to use this tool versus alternatives. While one can infer it is likely a preflight prerequisite to huaweicloud_plan_cli_command or huaweicloud_run_approved_command, that inference is not stated. The description lacks any 'use this when...' or contrast with sibling tools.

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

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

The word 'scan' implies a read-only operation, and the description mentions it returns information (framework type, build commands, output directory, port). However, with no annotations provided, the description carries the full burden for side effects, permissions, or error behaviors. It does not explicitly state that the tool does not modify the project or what access is required, leaving some behavioral aspects undisclosed.

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 well-structured sentences: the first states the core function and the second lists the outputs and usage context. It is front-loaded with the primary purpose and avoids any unnecessary verbosity, making it easy for an agent to quickly grasp the tool's role.

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 (single parameter, no output schema), the description is largely complete: it names the inputs, the outputs (framework type, build commands, output directory, port), and the user scenario. The only missing element is the exact format or structure of the returned data, but since there is no output schema, this gap is minor and unlikely to impede correct usage.

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 fully describes the only parameter, 'projectPath', including its type (string) and meaning ('Absolute path to the local project directory to scan'). The tool description adds no additional input-specific details beyond what the schema provides, so the parameter semantics are adequately covered but not enhanced.

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 scans a local project directory and identifies the web framework, package manager, and monorepo tool, listing specific framework examples. This makes its purpose explicit and distinguishes it from sibling tools focused on authentication, sandbox management, or CLI command execution.

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 when-to-use guidance ('Use before deploying a web application to determine the correct build pipeline'), which gives context for the tool's role. However, it does not explicitly mention alternative tools or situations where this tool should not be used, so it stops short of a full usage guideline.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states the tool explains errors and suggests diagnostic steps, but does not disclose how it processes input, whether it requires authentication, what happens with partial information, or the nature of the response. This leaves significant behavioral ambiguity for a tool that might call external services.

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

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

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

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

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

Given the lack of annotations and output schema, and the 0% parameter coverage, the description is insufficient for an agent to understand what inputs to provide and what output to expect. The tool is not complex, but the description leaves out critical details such as the format of the explanation, whether a requestId is required, or how to interpret the response, making it incomplete for reliable invocation.

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

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

Schema description coverage is 0%, and the description does not mention any of the four parameters (message, service, errorCode, requestId) or their roles. It fails to clarify which parameters are needed for a meaningful explanation or how they affect the output, providing no value beyond the bare schema 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 states a clear verb (Explain) and resource (a Huawei Cloud CLI, API, SDK, or agent workflow error) and adds the purpose of suggesting next diagnostic steps. It is specific enough to distinguish from sibling tools like search_docs or list_operations, though it does not explicitly name any sibling to differentiate from.

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

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

The description implies usage when an error is encountered, but provides no explicit when-to-use guidance or exclusions. It does not mention alternatives or when not to use this tool, leaving the agent to infer applicability from the general phrasing.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It implies a read-only check ('Check if') but does not explicitly state that it is non-destructive, does not describe authentication requirements, rate limits, or what the response format is (e.g., boolean, error, etc.). The lack of an output schema makes this gap more significant.

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: the first states the core purpose, the second provides the usage context. There is no redundancy, and the most critical information is front-loaded. Every sentence earns its place.

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

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

The tool is simple (2 params, no nested objects, no output schema), and the description covers purpose and usage. However, it omits details about the return value and error behavior, which are not covered by the schema or annotations. Without an output schema, the agent cannot know what the tool returns, so the description is 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 both 'region' and 'service' are already well-documented with examples in the input schema. The description adds no additional semantic value beyond restating that the service is specific and the region is a target. Per the rubric, baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description uses a specific verb ('Check if') and resource ('specific Huawei Cloud service... in a target region'), making the purpose unambiguous. It also adds a use case ('before creating resources') that helps distinguish it from sibling tools like listing regions or service catalogs, which serve different purposes.

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

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

The description explicitly states when to use the tool ('Use before creating resources to prevent failures from regional unavailability'), giving clear context. However, it does not mention any alternatives or when not to use it, so it stops short of the 5-level guidance.

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

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

With no annotations provided, the description bears full responsibility for transparency. It indicates read-only behavior through verbs like 'Find' and 'Returns', and specifies the output (URLs, paths, category, aliases, links). It does not explicitly state that no modifications occur or mention authentication/rate limits, but the nature of a logo lookup inherently implies a safe read operation. This is a reasonable level of transparency for the tool's simplicity.

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: the first states the core purpose and output; the second provides usage context and parameter examples. Every sentence contributes meaning without redundancy. It is well-structured, with the primary purpose front-loaded, followed by actionable details. No filler or unnecessary elaboration.

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

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

For a simple lookup tool with no output schema, the description sufficiently covers what the agent needs: what the tool does, what it returns (top 5 matches, URL/path/category/links), and how to supply inputs. It also gives real-world use cases, making it self-contained for correct invocation. No critical information for a basic lookup seems 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% (both parameters are described in the schema), so the baseline is 3. The description adds valuable context by providing concrete examples (ecs, obs, modelarts, 对象存储) for the 'service' parameter and example categories (计算, 存储, etc.) for 'category'. This goes beyond the raw schema definitions, helping the agent understand acceptable input formats and values.

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 ('Find') and the resource ('official Huawei Cloud service logo from the Huawei Cloud Icons library'). It is distinct from sibling tools, which focus on auth, CLI execution, sandboxing, or region listings. The purpose is immediately evident 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 explicitly instructs when to use the tool ('Use when generating PPT, architecture diagrams (draw.io), or frontend pages that need official Huawei Cloud service logos') and how to invoke it ('Provide service ... or category ... to browse'). It also states the output format ('Returns top 5 matches'), giving clear operational guidance. While it doesn't mention when-not-to-use, the use cases are specific enough to guide selection.

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

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

With no annotations, the description carries the burden of disclosing side effects. 'Check' suggests a non-mutating operation, but the description does not explicitly state that it is read-only, nor does it describe what output or side effects may occur.

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 a clear verb and object. It contains no fluff or redundant information, and the structure is 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 covers the basic purpose but omits details about expected output, return format, or any prerequisites. Given the simple input schema and no output schema, it is adequate but not rich in context for an agent deciding between this and similar hook-check 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?

The schema has no descriptions for the 'artifacts' array or its 'path' and 'content' fields, and the description only lists artifact types without explaining how path/content are used. It adds some context but does not fully compensate for the lack of schema-level parameter details.

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

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

The description clearly states a specific action ('Check') and a specific resource ('generated code, IaC, policy, or config artifacts') against 'Huawei Cloud hook risk rules'. This distinguishes it from sibling tools like huaweicloud_hook_check_command and huaweicloud_hook_check_deploy_plan based on artifact type.

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

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

The description implies usage for artifact checking but does not explicitly state when to prefer this tool over the sibling hook check tools. No direct alternatives or exclusions are mentioned, leaving some inference to the agent.

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

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

No annotations are provided, so the description carries the full burden. It discloses the key behavioral trait of not executing the command, which is critical for safety. It does not mention output format or potential side effects, but for a simple check tool this is reasonably transparent.

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 with no extraneous words. It clearly states the action, resource, and a key constraint, 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 tool with one parameter and no output schema, the description covers the essential aspects: what it does, what it does not do, and the type of input. It lacks explicit usage guidance relative to sibling tools, but this is minor for a simple check tool.

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

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

The schema describes the parameter as 'The exact command text to inspect', and the description adds that it is a 'planned shell or hcloud command', providing context about the command type and its planned status. This goes slightly beyond the schema's generic phrasing.

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

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

The description clearly states the verb 'Check' and the resource 'a planned shell or hcloud command', and specifies the scope as 'against Huawei Cloud hook risk rules'. It also explicitly notes 'without executing it', which differentiates it from execution tools like run_approved_command and plan_cli_command.

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 this tool is for pre-execution validation by saying 'without executing it', and the sibling set includes planning and execution tools. However, it does not explicitly state when to use it instead of alternatives like plan_cli_command or run_approved_command, nor does it mention 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?

The description indicates a read-only 'check' action but does not explicitly state whether any resources are modified or if external services are accessed. No annotations provide additional safety information, so the description bears the full burden.

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

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

The description is a single, direct sentence without redundant phrases. It immediately states the action and the subject.

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 covers the core purpose but lacks specification of expected deployment plan format (e.g., Terraform state) and any return value or error conditions. Given the single parameter and no output schema, these omissions are notable.

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 parameter 'plan' is described as an object, array, or string, which gives a basic type hint but no field-level details. Since this is the only parameter, the coverage is complete, but the description adds limited structural information.

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

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

Clearly states that the tool checks a deployment plan for specific risk categories (sandbox, exposure, IAM, cost). This distinguishes it from other check tools that target artifacts or commands.

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?

Does not provide guidance on when to use this tool compared to alternatives like huaweicloud_hook_check_artifacts or huaweicloud_sandbox_deploy_check. No explicit conditions or examples are 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?

With no annotations provided, the description carries the burden of disclosing side effects. It explicitly notes the operation is 'local/read-only', which signals safety and non-mutation, though it does not elaborate on failure modes or prerequisites.

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, focused sentence with no redundant wording. It fronts the primary action and includes the key qualifier 'local/read-only' early.

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 one required parameter and no output schema, the description is sufficient: it covers what, target, and safety. It could be improved by adding explicit guidance on when to use it versus related command-execution 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?

Both parameters already have clear descriptions in the schema (service name and timeout), and the tool description does not add extra meaning beyond that. Schema coverage is effectively 100%, so baseline 3 applies.

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

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

The description clearly states the action ('List'), the object ('KooCLI operations'), and the target ('a Huawei Cloud service'), which distinguishes it from sibling tools like listing regions or running commands.

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?

It explains the mechanism ('by running local/read-only hcloud <Service> --help') but does not explicitly say when to prefer this tool over alternatives such as planning or running commands. The intended use is implied 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?

The description discloses the output shape (region IDs, display names, endpoints). It does not mention side effects or failure modes, but as a read-only list operation, these are unlikely. With no annotations, the description carries the full burden, but it is sufficient for a safe 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, directly stating the purpose, output, and usage. No unnecessary words or redundant information. It is well-structured 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 list operation, the description provides sufficient context: what it does, what it returns, and when to use it. It does not mention prerequisites like authentication, but that is likely handled by sibling auth tools. Overall, it is complete enough for an agent to decide when to call it.

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?

There are no parameters, so schema_description_coverage is 100%, and the baseline is 3. The description adds no parameter-specific meaning because there are no parameters to describe.

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 available Huawei Cloud regions') and specifies the output ('Returns region IDs, display names, and endpoints'). It distinguishes itself from sibling tools by being focused on region discovery, as opposed to auth, sandbox, or other 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?

It explicitly states when to use the tool: 'Use when the agent needs to discover available regions before creating resources.' This provides a clear trigger condition and places it in the context of resource creation.

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

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

With no annotations provided, the description carries the full burden. It clearly states the tool does not execute the command, which is a key behavioral guarantee, but it does not describe potential side effects, whether it is fully read-only, or what kind of plan output is returned.

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, focused sentence with no filler. It efficiently communicates the tool's purpose and a critical constraint (no execution), making it easy to parse.

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

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

Given the simplicity of the tool and full schema coverage, the description is adequate but sparse. It does not mention what the plan output looks like, whether results are returned, or how this relates to approval workflows, which could matter for an agent deciding whether to call it.

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 both parameters with descriptions, so the description adds little beyond what is in the schema. The 'args' parameter is clear as command arguments, and 'allowWrites' is explained in the schema; the description does not need to repeat them.

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 'classify and plan' and the specific resource 'Huawei Cloud hcloud command', and explicitly notes it does not execute the command. This distinguishes it from execution-focused sibling tools, though 'classify' is somewhat vague.

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 'without executing it' implies use for planning or classification before actual execution, but it does not explicitly say when to prefer this tool over siblings like run_readonly_command or run_approved_command. More direct guidance on when to choose this tool would improve clarity.

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 burden of disclosing behavior. It states that the tool returns skill content and a reference file list, but it does not mention error behavior, whether the skill must exist, or any other side effects beyond retrieval.

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, front-loaded with the action and resource, and contains no unnecessary words. Two short sentences communicate purpose, output, and usage context effectively.

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 one-parameter retrieval tool, the description adequately explains what is returned and when to use it. It does not document failure modes or edge cases, but these are not critical given the tool's simplicity and the lack of an 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 single parameter is fully described in the schema, and the description adds concrete examples of valid skill names, which helps the agent understand the expected format. Schema coverage is high, so this exceeds 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?

Clearly states the verb 'Retrieve' and the specific resource 'full SKILL.md by skill name', and distinguishes itself from sibling search/list tools by emphasizing that it returns the complete skill content when the agent has already identified which skill to load.

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 explicit guidance on when to use it ('when the agent has identified which skill to load and needs the full procedure'), though it does not explicitly name alternative tools or provide a detailed when-not-to-use list.

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 that this tool executes write-capable commands and requires both an approval token and explicit user approval, which are critical safety behaviors. It does not enumerate all possible side effects, but the approval gate is prominently and appropriately highlighted.

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, focused sentence states the purpose and the critical safety condition. It is concise, well-structured, and contains no redundant or tangential 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?

Given the schema fully documents all parameters and there is no output schema, the description plus schema provides enough context to invoke the tool correctly. The relationship to the plan step is captured via the approvalToken description, and the approval requirement is stated clearly.

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 descriptions fully explain each parameter, including that args excludes the executable, the defaults for timeout/maxRetries, the origin of approvalToken, and the condition for approvedByUser. The tool description itself adds no extra parameter meaning, so the baseline 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 identifies the tool as running a write-capable hcloud command subject to explicit user approval, and the 'write-capable' qualifier distinguishes it from the sibling run_readonly_command. It also implies the connection to the planning step through the approval token.

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?

It explicitly states that the command should only be run after the exact command has been shown and approved, and the write-capable qualifier advises against using it for read-only operations. It does not explicitly contrast with run_readonly_command, but the guidance is strong and practical.

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?

Discloses that output is redacted and that the command passes through a safety policy, which is useful behavioral context. With no annotations, more detail about failure modes or side-effect guarantees could strengthen 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?

One concise sentence conveys the main purpose and key behavioral constraints without redundancy or extraneous 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?

Provides enough context for basic use: read-only scope, safety policy, and output redaction. Missing examples or edge-case guidance, but the tool is not highly complex and has no output schema to document.

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 essential 'args' parameter has no schema description and the tool description does not clarify its format or expected contents. Other parameters have basic descriptions, but the core required argument is underspecified.

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 tool runs a read-only hcloud command, identifying both the action and resource. The explicit 'read-only' qualifier distinguishes it from sibling tools like huaweicloud_run_approved_command.

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 clear context by limiting usage to read-only commands and mentioning the toolkit safety policy. Does not explicitly name alternative tools or state when not to use it, so it falls short of full explicit guidance.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly. It discloses the read-only nature (never signs), the exact success response structure, and the specific error codes and their meanings (HDKIT_NOT_REALNAME, HDKIT_NOT_AGREEMENT, HDKIT_NOT_REALNAME_AND_AGREEMENT). This exceeds typical transparency for a simple check 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?

Two sentences with zero wasted words. The purpose is front-loaded, and the behavioral details (returns, errors, no side effects) are packed efficiently. Every sentence 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 no-parameter, no-output-schema tool, the description is complete: it states what is checked, what a successful result looks like, what failure modes exist, and that it has no mutating side effects. An agent has everything it needs to decide whether and how to call it.

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

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

The tool has zero parameters, and schema coverage is trivially 100%. The baseline for 0-param tools is 4, and the description adds nothing beyond what the empty schema already implies. No parameter documentation is needed, so the score is appropriately high.

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

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

The description clearly states a specific verb ('Check') and resource (user's real-name verification and agreement status). It precisely distinguishes itself from siblings like huaweicloud_sandbox_sign_agreement by explicitly noting it never signs anything, and from huaweicloud_auth_status by focusing on verification and agreements rather than general auth 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?

The description implies when to use it (to check prerequisites) but does not explicitly name alternatives or state when not to use it. The 'Never signs anything itself' hint suggests that signing tools exist, but it doesn't reference huaweicloud_sandbox_sign_agreement or other auth-related tools. This is clear context but lacks explicit exclusions.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It only states the action without explaining side effects (e.g., terminating running processes), reversibility, idempotency, or error behavior. For a mutation tool, this is a significant gap. The description also does not indicate whether authentication is required or what happens if the session does not 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?

The description is a single, concise sentence with no wasted words. The core action and target are front-loaded, making it immediately clear what the tool does.

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

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

For a tool with no annotations and no output schema, the description is too minimal. It lacks critical context such as return values, potential side effects, error scenarios, and whether the operation is destructive or reversible. An agent would not know what to expect or how to handle edge cases, making the description incomplete for safe invocation.

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

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

Schema description coverage is 100%, so both parameters (username and workspace_id) are fully documented in the input schema. The description adds no extra meaning beyond the schema; it does not explain why workspace_id is required when HW_WORKSPACE_ID is unset (already in schema). According to the rubric, with high coverage, a 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 ('Close') and the target ('persistent terminal session for a workspace'). This is specific and distinct from sibling tools like huaweicloud_sandbox_connect (which opens sessions) and huaweicloud_sandbox_exec_with_session (which executes commands). The purpose is 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 no guidance on when to use this tool, when not to, or any alternatives. It does not mention that this is the counterpart to huaweicloud_sandbox_connect or that it should be called after the session is no longer needed. There is no context about prerequisites or conditions for safe usage.

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

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

No annotations are provided, so the description must carry the behavioral disclosure. It does disclose the reuse/create behavior and lists returned values (session_id, dev_stage_id, connection_id, connection_address). However, it omits critical prerequisites such as signing the sandbox agreement (huaweicloud_sandbox_sign_agreement) or authentication requirements, which are important for a tool that creates resources.

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-loads the core action and key behavior, and wastes no words. It efficiently conveys the primary purpose and return values without redundancy.

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

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

Given the tool's complexity (5 parameters, nested git object, no output schema) and the presence of related sibling tools, the description lacks critical context. It does not explain prerequisites like signing the agreement or how the returned session_id should be used with other sandbox tools. While the schema covers parameter semantics, the description fails to connect this tool to the broader sandbox workflow.

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

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

Schema description coverage is 100%, so each parameter already has a description, including notes like 'only for new sandbox' for env, git, flavor_id, and template_id. The tool description adds no parameter-level information 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 ('Connect to a sandbox via hdkitservice') and specifies the key behavior: it reuses an existing sandbox or creates a new one. This distinguishes it from sibling tools like huaweicloud_sandbox_exec_one_shot or huaweicloud_sandbox_check_user, making its 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 context about reuse/create behavior but does not explicitly state when to use this tool versus alternatives. It does not mention checking for an existing sandbox first (e.g., via huaweicloud_sandbox_check_user) or that it is a prerequisite for session-based execution (huaweicloud_sandbox_exec_with_session). Guidance is implied rather than 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?

With no annotations, the description carries the full transparency burden. It discloses the main action and the running-state requirement, but it omits side effects such as whether existing credentials are overwritten, whether prior authentication is required, or what happens on failure.

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 with no redundant wording. It efficiently communicates the core action and a key precondition.

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?

There is no output schema and no mention of expected success/failure behavior. The description gives purpose and a precondition, but it does not specify what the agent should expect after invocation, how to choose between session_id and dev_stage_id, or what errors might occur.

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 descriptions for all three parameters, so the baseline is moderate. The description adds AK/SK context but does not clarify the relationship or precedence between session_id and dev_stage_id, nor how enable_sts interacts with the injection process.

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 ('Configure temporary AK/SK'), the target ('for a sandbox'), and the mechanism ('via hdkitservice'). It also distinguishes this tool from related sandbox operations like connect, exec, and upload by focusing on credential injection.

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 precondition ('sandbox must be in RUNNING state') but gives no explicit when-to-use guidance or comparison with alternative tools such as auth_init or auth_switch. It does not explain when an agent should choose this over other auth-related operations.

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

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

With no annotations provided, the description carries the full burden. It describes what the tool verifies and that it returns score and nextStep, but it does not disclose whether the tool has any side effects (e.g., modifying files, requiring special permissions, or executing non-read-only commands). Since it is primarily a check, this is a minor gap, but more transparency about potential side effects would be beneficial.

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, consisting of two sentences that pack essential information: what the tool does, specific checks it performs, what it returns, and when to call it. No redundant or vague wording is present.

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 appropriately mentions the return values (score and nextStep). It covers the tool's purpose, key parameters, and usage context, making it sufficiently complete for an agent to invoke it correctly without additional information.

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 covers all 7 parameters with descriptions (100% coverage), but the tool description adds valuable context beyond the schema. For example, workspace_id is noted as 'Required - must be passed explicitly when HW_WORKSPACE_ID is not set', and framework_type is tied to 'cross-platform' for QR code checks. This enhances understanding and correct usage.

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

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

The description clearly states the tool's purpose: running a deployment completeness check on the sandbox, listing specific verification items (nginx, output directory, tunnel, QR code), and indicating it should be called at the end of a deployment workflow. This distinguishes it from sibling tools like deploy_nginx or check_user.

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 provides a usage scenario ('Call this at the end of a deployment workflow to confirm everything is working before reporting success.'). It does not explicitly state when not to use it, but the context is clear enough for an agent to make the correct choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that it writes a template (SPA, SSR, or static), fixes directory traverse permissions, and reloads nginx. It does not mention potential side effects like overwriting existing configs or require explicit prerequisites (e.g., active sandbox session), but the disclosed behaviors are core and sufficient for an agent to understand the tool's effect.

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

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

The description is two sentences, concise and to the point. It front-loads the primary action and then adds the key differentiators (handles permissions, template selection, reload). The alternative advice is appended efficiently without redundancy. It could be trimmed slightly, but it is well-structured and informative.

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 10 parameters and no output schema, the description covers the core behavior (deploy, template selection, permissions, reload) but does not explicitly mention the return value or success/failure semantics. The schema itself provides required workspace_id and other details, so the agent can infer prerequisites. The description is sufficiently complete for an agent to call the tool correctly, though a note on expected response would improve it.

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 all parameters already have descriptions. The description adds minimal value by noting the parameters come from framework detection and are used to select the template, but this is largely redundant with the schema's own descriptions. It does not clarify parameter syntax or edge cases beyond what the schema provides, so a 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 tool's action: deploy an nginx configuration on the sandbox and reload. It specifies the resource (nginx config), the verb (deploy), and the specific behaviors (writes the correct template based on type, fixes permissions, reloads). It also differentiates from manual construction, which helps distinguish it from other sandbox 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?

The description explicitly advises using this tool instead of manually constructing nginx config, and notes it handles permissions, template selection, and reload in one call. It implies usage after framework detection by referencing parameters from detection. It does not name specific sibling alternatives or give explicit exclusion criteria, but the guidance is clear and actionable.

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. It honestly discloses the WebSocket lifecycle, one-shot execution, and lack of state persistence. It does not discuss potential side effects or safety/approval requirements, but the core runtime behavior is transparent.

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?

Three focused sentences with no fluff. The most important differentiators—fresh connection, no state carryover, and intended use case—are 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?

Provides enough context for selecting and invoking the tool: one-shot execution, no session persistence, suitable for long-running commands. Minor gap: it does not explicitly name the session-based sibling tool, but 'session-based execution' is a clear reference.

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 parameters, so baseline is 3. The description adds context about workspace_id needing explicit passing when HW_WORKSPACE_ID is unset, but otherwise does not significantly enrich parameter meaning 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?

Clearly states the verb (execute), resource (workspace terminal), and key behavior (fresh connection per call). Distinguishes itself from session-based execution by noting no session state carries over.

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?

Explicitly recommends use for long-running build/deploy/install commands (>30s) that do not need shell state persistence, and contrasts with session-based execution. Provides a clear decision rule for when this tool is preferred.

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 reveals that shell state (cd, env vars, aliases) persists across calls and that commands are limited to 30s, both non-obvious traits. However, it does not mention whether a session must be established first via huaweicloud_sandbox_connect, nor what the response format is—minor gaps given the richness of what is stated.

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?

Three sentences with zero fluff. The primary purpose and key distinguishing trait (session reuse) are front-loaded, followed by usage guidance and a clear exclusion with the preferred alternative. Every sentence 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 no output schema and no annotations, the description covers the essential decision factors (session reuse, 30s limit, alternative tool). It does not explicitly mention prerequisites like establishing a session via huaweicloud_sandbox_connect or the return value format, but these are implied by the sibling set and the tool's nature. A small but acceptable gap for an experienced agent.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no syntax or format details beyond the schema, staying at the baseline for parameter semantics. It does not clarify the relationship between workspace_id and the HW_WORKSPACE_ID environment variable beyond the schema's note.

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

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

The description states a clear verb ('Execute a command') and resource ('workspace terminal') with an explicit qualifier ('with session reuse'), immediately distinguishing it from the sibling exec_one_shot by highlighting state persistence. It also names the alternative in the exclusion clause, leaving no ambiguity about what this tool does.

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

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

Explicit guidance is provided: 'Use for interactive work and command sequences that need shared state' and 'NOT for long-running commands (>30s) — prefer exec_one_shot for those.' This gives clear when-to-use and when-not-to-use criteria, directly referencing the relevant sibling.

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. It discloses that the tool performs a state-changing signing action and emphasizes the consent requirement. However, it does not explicitly state the permanence of the action or any additional side effects beyond signing, so a perfect score is not warranted.

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, direct, and front-loaded with the action. It includes a critical warning without unnecessary elaboration, making it efficient and well-structured.

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

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

Given no parameters and no output schema, the description provides all necessary context: what it does, when to call it based on check-user, and the consent prerequisite. It also references related tools to place it in the larger workflow, making it complete for its scope.

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 zero parameters, so the baseline is 4. The description adds no parameter-specific meaning because there are none, but it correctly omits any irrelevant detail.

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: sign all unsigned or outdated agreements for the current user. It also distinguishes itself from siblings by referencing the specific precondition (check-user returning agreementSigned=false) and its role before connect.

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?

Explicitly specifies when to use this tool: required before huaweicloud_sandbox_connect if check-user returns agreementSigned=false. Additionally, it provides a critical usage rule about obtaining explicit user consent before calling, which is clear guidance for the agent.

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

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

The description discloses the internal mechanism: base64-encoding, chunked writes through terminal session, and md5 checksum verification. This is valuable because it explains why this tool is more reliable for large files (exec channel fragility). Since no annotations exist, this carries the full burden, and it does well in explaining behavior beyond the basic action.

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

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

Two sentences, no waste. The core purpose is stated first, then the mechanism and usage guidance. Efficient and well-structured.

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

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

For a tool with 5 parameters and no output schema, the description covers the key behavioral aspects (chunked upload, verification) and gives a clear use case. It could mention the requirement of an active session (implied by 'terminal session') and the return value, but these are minor given the schema already specifies workspace_id and the tool's nature.

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 parameters are already documented. The description adds no additional parameter-specific details. It provides context about the upload process but not about the parameters themselves. Thus, it meets the baseline but doesn't exceed it.

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: 'Upload a local file into the sandbox workspace.' It also hints at differentiation by saying 'Use this instead of embedding large file content directly in a command,' which helps distinguish from command execution tools. However, it doesn't explicitly differentiate from huaweicloud_sandbox_upload_project, but the singular 'file' vs project is implicit.

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?

It provides a specific usage condition: for large file content, don't embed in command, use this upload. This is a clear when-to-use. It doesn't explicitly mention alternatives like upload_project, but it gives a context for when this tool is preferred over direct command execution. It lacks explicit exclusions or a comparison with other sandbox tools.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavior. It mentions packaging, uploading, fallback, and default extraction, which are useful, but it does not mention potential side effects like overwriting existing files, permission requirements, or failure modes beyond the tunnel fallback.

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 compact and front-loaded, stating the main action in the first sentence and supplementary details (fallback and default extraction) in the second. 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?

The description provides enough context for a correct invocation, including the default extraction behavior and the fallback mechanism. It does not describe return values or error scenarios, but no output schema exists, so that is not required. It briefly mentions defaults but not all parameter defaults, though the schema covers those.

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 does not add extra meaning to individual parameters beyond what the schema already provides; it only summarizes the overall workflow.

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: packaging and uploading a local project directory to a sandbox workspace. It also distinguishes itself by mentioning the creation of a tar.gz archive and extraction, which differentiates it from file-level upload tools like huaweicloud_sandbox_upload_file.

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 explains the mechanism (HTTP tunnel with base64 fallback) but does not explicitly state when to use this tool versus alternatives such as huaweicloud_sandbox_upload_file or huaweicloud_sandbox_exec_one_shot. The context is clear enough for a project-directory upload scenario, but there is no explicit when/when-not 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?

No annotations are provided, so the description carries the full burden. It discloses the output structure (top 10 results with source, name, snippet, relevance score) and the scope of search (SKILL.md files and local docs). However, it does not mention any potential side effects (e.g., read-only nature, authentication requirements, or error behavior), which is a notable gap for a tool with zero annotation coverage.

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

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

The description is two concise sentences with no wasted words. The primary action and resource are front-loaded, followed by the use case. It is well-structured and 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?

With no output schema, the description explains the return format clearly. It covers the search scope, the use cases, and the output details. It does not mention error handling or edge cases (e.g., no results), but for a simple two-parameter search tool, this is fairly complete. The default for topic is implied in the schema, so that is covered.

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 (query and topic) are already documented. The tool description does not add any extra meaning beyond what the schema provides, such as query formatting or topic usage specifics. It only mentions the search context generally, so it stays at the baseline of 3.

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

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

The description clearly states the tool searches Huawei Cloud SKILL.md files and local documentation, with a specific verb and resource. It also specifies the return format (top 10 results with source, name, snippet, relevance score), and the use case helps distinguish it from sibling tools like search_marketplace.

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?

Explicitly states when to use the tool: 'when the agent needs to discover which skill covers a topic, or when uncertain about API parameters, quotas, or limitations.' It gives clear context but does not mention when not to use it or name alternative tools, which would make it more complete.

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

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

With no annotations provided, the description carries the burden of indicating behavior. 'Search' and 'Returns scored results' clearly imply a read-only, non-destructive operation, though it does not explicitly state the absence of 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?

The description is two concise sentences with the primary action front-loaded. It avoids unnecessary detail and is 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 covers what the tool does, what it returns, and when to use it. Since there is no output schema, it sufficiently communicates the expected result without over-specifying.

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 tool description itself does not add parameter-level meaning beyond the schema, though the schema fields are adequately described.

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 searches the Huawei Cloud agent skill marketplace and returns available skills, using a specific verb and resource. It is easily distinguished from sibling tools like retrieve_skill and search_docs.

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?

Explicitly states when to use it: when built-in skills are insufficient or the user asks what skills exist. This gives clear contextual guidance for an agent.

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

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

No annotations are provided (no readOnlyHint, destructiveHint, or authHints), so the description carries the full burden. It implies a read-only operation via 'Return', but it does not disclose whether any side effects, authentication requirements, or rate limits apply. The lack of explicit behavioral disclosure is a significant gap.

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

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

The description is a single concise sentence with no redundant words or filler. It states the action and the resource directly, achieving maximum efficiency for its length.

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 explain what 'capability sources' are, what format the returned data takes, or how the result should be interpreted. Combined with the absence of an output schema, an agent has insufficient context to know what to expect from the call and how to use the result.

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 single parameter 'intent' is already well-described in the schema with concrete examples ('deploy app, use API, debug error, or inspect resources'). The description adds no additional meaning beyond the schema, so it neither helps nor hinders beyond 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 verb 'Return' clearly indicates a read operation, but the resource 'recommended capability sources' is vague—it is unclear what constitutes a 'capability source' or how this differs from search_marketplace or search_docs. The tool name 'service_catalog' hints at a catalog lookup, but the description alone does not make that explicit.

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

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

No guidance is given on when to use this tool versus the many sibling tools such as search_marketplace, search_docs, or get_regional_availability. An agent has no way to decide between this and similar lookup tools based on the description alone.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses that the tool writes to a local config file, that it is a one-time setup expected to be re-run, and that it addresses a cross-store credential mismatch. It does not state whether existing OBS config values are overwritten or what happens on an invalid profile, but the core mutation behavior is transparent.

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?

Three sentences with zero waste: the first states the core action and target, the second explains why the tool exists, the third gives run-time guidance. The core action is front-loaded and each sentence 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 low-complexity tool (one optional param, no output schema, no annotations), the description covers what, why, and when. Minor gaps remain around success confirmation and overwrite semantics, but nothing an agent needs to call it correctly 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 description coverage is 100%: the single optional 'profile' parameter is already fully documented with its default behavior. The tool description adds no parameter-specific meaning, but per the rubric the baseline 3 applies when the schema carries the 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 opens with a specific verb-resource pair: 'Synchronize KooCLI credentials to OBS config (~/.obsutilconfig)'. It names the exact artifact touched and the failure mode it fixes, which distinguishes it from sibling auth tools like huaweicloud_auth_init or huaweicloud_auth_sync that manage credentials in other stores.

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 explicit trigger conditions: run once to enable OBS operations and re-run after changing hcloud credentials, with the concrete symptom (OBS commands fail with 'Please set ak, sk') that signals when the tool is needed. It stops short of explicitly naming alternatives or exclusions among the huaweicloud_auth_* siblings.

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

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

With no annotations, the description carries the burden. It does disclose that the tool invokes 'hcloud configure show' and returns redacted output, implying a read-only profile inspection. It does not state whether credentials are required, what errors might occur, or whether output contains only specific profile fields, but what is disclosed is not misleading.

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 filler, front-loading the action, resource, and redaction behavior. It could briefly mention when to omit the profile parameter, but as a description it is compact and efficient.

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

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

Given a simple optional parameter and no output schema, the description gives enough to identify and invoke the tool. However, it lacks detail about the returned redacted content shape and defaults, leaving an agent without full clarity on what 'redacted output' will contain.

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 covers the single parameter, 'profile', with the description 'Optional KooCLI profile name.' The tool description adds no extra nuance such as default behavior when no profile is named, leaving the schema to carry the parameter understanding.

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

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

The description gives a clear verb and resource: 'Inspect a KooCLI profile' via 'hcloud configure show', and specifies the redacted nature of the output. It is clear enough to say what the tool does, though it does not explicitly contrast it with sibling 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?

There is no guidance about when to use this tool over siblings such as huaweicloud_auth_status or huaweicloud_check_cli. The intended situation is only implied by 'Inspect a KooCLI profile' and 'redacted output'.

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

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

No annotations are provided, so the description carries the full burden. It discloses that repeated claims return '已领取' (already claimed), which is a useful behavioral trait. However, it does not describe the success response, side effects, or any permission requirements. The disclosure is partial but not contradictory.

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

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

The description is one concise sentence, front-loaded with the action and the key constraint. It contains no filler and 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 tool with one optional parameter and no output schema, the description is adequate: it states the purpose, the repeat behavior, and the parameter is already documented. It might be slightly more complete with an explicit note on the success response, but it is sufficient for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the single parameter domain_id is fully documented in the schema (optional, auto-resolved from IAM). The tool description adds no additional parameter meaning, so it meets the baseline for high coverage without adding value.

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

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

The description clearly states the action: '领取代金券' (claim voucher), a specific verb+resource. It also adds the constraint '一人一次' (once per person), which clarifies scope. It is distinguishable from siblings like huaweicloud_voucher_status, which is a different 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 implies when to use it (claiming a voucher) and mentions the repeat behavior, but does not explicitly state when not to use it or point to alternatives like huaweicloud_voucher_status for checking status. The context is clear but exclusions are not mentioned.

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

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

No annotations are provided, so the description carries the full burden. The term '查询' (query) and '状态' (status) strongly imply a read-only operation with no side effects, and the '不打扰' (do not disturb) behavior clarifies that it will not take actions when already claimed. However, it does not explicitly state that it performs no writes or external effects, leaving a slight gap.

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

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

The description is concise yet comprehensive, covering purpose, invocation triggers, and conditional responses in two sentences. No unnecessary words 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?

Given that no output schema is provided, the description effectively fills the gap by indicating the output (claimed=true/false) and the corresponding actions. It also includes the triggering context, making the tool's behavior fully understandable without needing to inspect other documentation.

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 only parameter, domain_id, is fully described in the schema (optional, leave empty in production, resolved from IAM). Since schema coverage is 100%, the description does not need to add parameter details. It does not supplement the schema, but that is acceptable per the rubric.

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 queries the voucher claim status and explains the context for when it should be used (first use, session start, or plugin capability inquiry). The specific action (查询) and target (领取状态) are 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 gives explicit when-to-use guidance: proactive check for new users, session starts, or capability questions. It also specifies the conditional behavior based on the result (prompt to claim if unclaimed, do not disturb if claimed), making the usage pattern fully clear.

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