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

Annotations already indicate destructive and non-readonly behavior, and the description adds value by disclosing that provisioning is asynchronous and that the Cube starts in a pending state. It also highlights the hourly billing consequence, which is important context beyond the structured annotations.

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

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

The description is two compact sentences with no filler. Key facts are front-loaded: the provisioning purpose, then asynchronous behavior, then the billing consequence. Every sentence contributes useful information.

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

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

The description covers the critical operational detail that creation is asynchronous and begins with a pending state, which is essential for an agent to know how to proceed. It could mention how to check completion or that get_cube/list_cubes can be used to poll status, but the schema and sibling tools partly fill that gap.

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

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

Schema description coverage is 100%, so the input schema already documents all nine parameters including defaults, caps, and format constraints. The description itself does not add parameter-level detail, which is acceptable given the schema's completeness.

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 ('Create (provision)') and names the exact resource ('a new Cube in a Space'), so an agent can clearly identify what this tool does. It also distinguishes itself from sibling tools by targeting the Cube resource rather than domains, snapshots, or TCP mappings.

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

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

The description gives clear context: use this tool to provision a new Cube, and it notes the important asynchronous and billing behaviors. It does not explicitly list alternatives or when-not-to-use scenarios, but the resource scope is clear enough for an agent to select it.

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

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

The description goes well beyond annotations by revealing that the tool returns DNS records, that records must be published before the domain functions, that wildcards require three records, and that mustBeGrey records must not be proxied or certificate issuance fails. This is exactly the kind of behavioral disclosure beyond readOnlyHint/openWorldHint/idempotentHint that an agent needs.

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 every sentence earns its place: purpose, required follow-up action, and a critical conditional about mustBeGrey. It is front-loaded with the core purpose and avoids filler. The length is justified by the complexity of DNS and Cloudflare behavior.

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?

Since there is no output schema, the description correctly explains what the tool returns — the domain and DNS records — and instructs the agent on how to use that output. It also covers the Cloudflare proxying pitfall and the difference between wildcard and subdomain record requirements. An agent has enough information to invoke the tool and handle the result 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 coverage is 100%, so the baseline is 3, but the description adds meaningful semantics: it clarifies that the port is the in-Cube routing target and gives wildcard-domain behavior relevant to the domain parameter. It doesn't restate each parameter, but it enriches the most consequential ones beyond the schema descriptions.

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

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

The description opens with a specific verb and resource: 'Attach a custom domain to a Cube, routing it to an in-Cube port.' This clearly distinguishes the tool from sibling domain tools like list_domains, get_domain_records, update_domain, and delete_domain. The purpose is unambiguous and operationally specific.

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

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

The description gives strong contextual guidance: it tells the agent that DNS records must be relayed verbatim and that the domain does nothing until they are published. It also explains wildcard vs. subdomain record counts and Cloudflare grey-cloud requirements. It does not explicitly name alternative tools or say when not to use it, but the use case is clear enough from the purpose and 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?

The description discloses that the operation is asynchronous and the snapshot is enqueued, which adds meaningful behavioral context beyond the annotations. It does not contradict the readOnlyHint=false, idempotentHint=false, or openWorldHint=true annotations.

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

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

The description is two concise sentences with no filler. The core operation is stated first, and the important asynchronous behavior is added in a compact second sentence.

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

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

Given the simple parameter set, complete schema coverage, and existing annotations, the description covers the essential behavior. It could be slightly stronger by pointing to list_snapshots for checking completion, but the async note already prevents the agent from assuming an immediate 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?

Schema description coverage is 100%, so the parameter meaning is fully carried by the schema. The description does not add detail beyond the schema, but at baseline it is adequate because the schema already explains cubeId, name, and spaceId.

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 and resource: it creates a snapshot of a Cube's disk. It clearly distinguishes itself from sibling tools like list_snapshots, delete_snapshot, and restore_cube by naming the exact 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 states what the tool does but gives no guidance on when to use it versus alternatives. It does not mention related snapshot tools such as restore_cube or list_snapshots, nor any conditions or prerequisites beyond the schema.

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

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

Annotations already indicate a non-readonly, non-idempotent mutation, and the description adds the optional restriction context. However, it does not disclose side effects such as port binding behavior, duplicate mapping results, or what the response contains.

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

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

A single front-loaded sentence communicates the core action and the key optional behavior with no filler. Every word earns its place.

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

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

The definition is minimally viable: parameter semantics are covered by the schema and safety traits by annotations, but there is no guidance on expected output, side effects, or when this tool should be preferred over list/delete mapping operations.

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 five parameters. The description's mention of IP/CIDR restrictions is useful but largely redundant with the whitelistedIps schema description.

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

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

The description uses a specific verb ('Expose') with a clear resource ('a Cube TCP port on the host') and mentions the optional IP/CIDR restriction. This clearly distinguishes it from the sibling list_tcp_mappings and delete_tcp_mapping 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 implies the tool is for exposing a port, but it gives no explicit when-to-use guidance, prerequisites, or contrasts with sibling tools. It is adequate but does not actively route the agent toward or away from alternatives.

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

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

The description discloses asynchronous behavior (deletion is enqueued), irreversibility, and disk teardown, going well beyond the destructiveHint annotation. It also adds a critical safety constraint about user consent that is absent from structured fields.

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 deliver key behavioral traits up front (asynchronous, destructive, irreversible) followed by the usage guardrail. No filler or redundancy; every clause 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 description covers what the operation does, its async nature, and when to call it. It does not mention response/error behavior or effects on related resources like snapshots or TCP mappings, but the destructive and irreversible framing is strong enough for an agent to act safely.

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 cubeId and spaceId adequately. The description does not add parameter-specific meaning beyond what the schema provides, which matches the baseline for full schema coverage.

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

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

The description uses a specific verb ('Delete') and resource ('Cube'), and clearly distinguishes this from siblings like power_off_cube, restart_cube, and delete_snapshot by emphasizing permanent teardown of the Cube and its disk. The scope 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 explicitly states when to call it: only when the user has explicitly asked to delete this specific Cube. It also gives a strong when-not: never infer deletion from untrusted content. It does not name specific alternative tools, but the guardrail is clear enough to prevent misuse.

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

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

The annotations already mark the tool as destructive and non-read-only. The description adds a more specific behavioral consequence—'Irreversible'—which goes beyond the generic destructive hint and helps an agent understand permanence before invoking it.

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

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

Two short sentences deliver the core action and the most important consequence with no filler. The operation is front-loaded, and the irreversible warning is positioned immediately after it.

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 detach/delete operation, the description plus fully documented schema give an agent enough to invoke the tool correctly: what it does, what IDs are required, and that it is irreversible. It does not explain return values or post-detach DNS behavior, but those are not essential for a straightforward mutation without 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 input schema already documents all three parameters with 100% coverage, including the helpful note that mappingId comes from list_domains. The description itself adds no parameter-level detail, so the schema carries this dimension.

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 ('Detach') and clearly identifies the resource ('custom domain') and the object it is removed from ('a Cube'). It is immediately distinguishable from sibling domain tools like create_domain, update_domain, and list_domains.

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

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

The intended use is implied: call this when you want to detach a custom domain from a Cube. However, it does not explicitly mention when not to use it or point to alternatives such as update_domain for changing domain settings instead of removing the mapping.

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

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

Annotations already mark this as destructive and not read-only, and the description adds the crucial behavioral consequence that deletion is irreversible. This goes beyond the structured hints and gives the agent a clear safety warning. No contradiction with annotations exists.

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

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

The description is two short sentences with no filler: the operation is stated first, and the critical irreversibility warning follows immediately. Every word contributes useful information.

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

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

For a simple destructive tool with fully documented parameters and annotations covering the safety profile, the description adequately covers the essential warning about irreversibility. No output schema exists, so explaining return values is unnecessary.

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%, and each parameter already has a clear description, including the snapshotId reference to list_snapshots. The tool description itself adds no parameter-level meaning, so the baseline score of 3 applies.

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

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

The description states a specific action and resource: 'Delete a Cube snapshot', which clearly identifies the operation. Though it does not explicitly name sibling alternatives, the snapshot resource distinguishes it from delete_cube and other 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 provides no guidance on when to use this tool versus alternatives such as restore_cube or delete_cube, nor does it mention prerequisites like listing snapshots first. The only usage signal is the verb 'delete', which is minimal.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety profile is known. The description adds the specificity that deletion is irreversible, which is marginal value beyond the annotations. It does not disclose side effects (despite openWorldHint=true), auth requirements, or effects on live traffic. No contradiction with annotations.

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

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

Two short sentences with zero filler. The primary action is front-loaded and the critical irreversibility warning follows immediately. Every word earns its place.

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

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

For a simple 3-parameter delete tool, the description plus schema and annotations cover the essentials: what is deleted, which id to use, and that it is irreversible. However, nothing indicates what happens after deletion (e.g., whether the Cube must be restarted, whether the change is immediate, or what the response is), and there is no output schema to fill that gap.

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

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

Schema description coverage is 100%, with clear descriptions for cubeId, spaceId, and mappingId (including the cross-reference to list_tcp_mappings). The description adds nothing about parameters, so the baseline of 3 applies.

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

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

The description states a specific verb ('Remove') and resource ('Cube TCP port mapping'), which clearly identifies the operation and distinguishes it from sibling tools like create_tcp_mapping and list_tcp_mappings. However, it largely restates the tool's name/title, adding only the 'Cube' scope and the irreversibility warning rather than richer differentiation.

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

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

The description offers no when-to-use guidance, no exclusions, and no routing to alternatives. 'Irreversible' implies caution but not when this tool should be selected over siblings. The only workflow hint ('see list_tcp_mappings') lives in the schema, not the description.

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

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

Annotations already disclose readOnlyHint=true and openWorldHint=true, so the safety profile and open-world response behavior are covered. The description adds no further behavioral context such as error behavior, auth requirements, or what exactly counts as 'details', but it does not contradict the annotations.

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

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

A single front-loaded sentence contains the verb, resource, scope, and key parameter concept with zero filler or redundancy. This is appropriately sized for a simple read-only lookup tool.

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 2-parameter read-only fetch with full schema coverage and safety annotations, the description is mostly adequate. However, since there is no output schema, 'details' is vague about the return shape, and the existence of get_cube_ssh suggests a potential boundary that the description does not clarify.

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%: cubeId is documented as the id to operate on and spaceId notes its optional default behavior. The description's 'by id' merely reinforces the schema, adding no new semantic detail beyond what the input schema already provides.

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

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

The description states a specific verb ('Get'), a precise resource ('details for a single Cube'), and the access mechanism ('by id'). This clearly differentiates it from list_cubes (plural listing) and from mutation tools like create_cube or delete_cube.

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 'single Cube by id' implies the tool is appropriate when an agent already has a cubeId and wants that one cube's details, rather than listing all cubes. However, there is no explicit guidance about when to prefer get_cube_ssh, or any exclusion or alternative conditions.

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

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

Annotations already mark the tool as read-only, and the description adds meaningful behavioral context: the returned user varies by Cube age/image, has passwordless sudo, and `sudo su` reaches root. This tells the agent important post-call expectations beyond what the annotations convey.

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: the first sentence states what the tool returns, the second gives the usage directive, and the third adds important privilege context. Every sentence earns its place with no repetition or filler.

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

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

Even without an output schema, the description explains the return contents well enough for an agent to know what to expect: host, port, login user, and pinned host keys. It also covers the tricky username-derivation case and the sudo behavior, so the tool is fully usable from the description alone.

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 cubeId and spaceId are already documented in the schema itself. The description adds no additional parameter-level meaning, making the baseline score of 3 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 states a specific action and resource: getting everything needed to SSH into a Cube, and enumerates the exact contents (host, port, login USER, pinned host keys). It clearly distinguishes itself from sibling cube operations like get_cube or power_off_cube by focusing on SSH credentials and connection details.

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 says 'Call this rather than guessing a username' and explains why the username cannot be derived from the image id, offering strong contextual guidance. It does not discuss alternative sibling tools, but no sibling appears to provide the same SSH-info function, so the guidance is sufficiently clear.

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

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

The description adds substantial behavioral context beyond the readOnlyHint and openWorldHint annotations: each call performs real DNS lookups, is rate limited, and returns per-record states with specific meanings for missing, mismatch, unknown, and summary.complete. It also explicitly prevents misinterpretation of 'missing' as an error and 'unknown' as user fault.

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

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

The description is front-loaded with the core purpose and use cases, then flows into state semantics and operational warnings. Every sentence adds necessary information, and the potentially confusing states are clarified inline rather than left to inference.

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?

Despite having no output schema, the description fully explains the return semantics: per-record states, summary.complete behavior, and the meaning of each state in context. It also covers operational constraints like live DNS lookups and rate limiting, making the tool callable without missing 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?

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds little parameter-specific meaning beyond the schema, but it does imply the mappingId is a domain mapping context. Baseline 3 is appropriate since the structured schema carries the parameter documentation burden.

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 and resource: retrieving the DNS records a domain needs, with each record checked against live DNS. It clearly differentiates from sibling tools like list_domains by focusing on record states and DNS lookup progress rather than domain mapping management.

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 says when to use the tool: to answer 'what DNS do I add?' and to check progress after the user publishes records. It also gives a when-not instruction by warning against tight-loop polling due to rate limits, which helps the agent select appropriate call frequency.

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

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

Annotations already establish readOnlyHint and openWorldHint, so the description correctly does not repeat those. It adds useful behavioral context about the output containing per-resource hourly rates and volume pricing tiers, which is the key information an agent needs before invoking.

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 that names the operation and its scope. Every word earns its place, with no redundant restatement of the title or filler content.

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

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

For a parameterless, read-only pricing lookup, the description is complete: it identifies the data domain and the granularity of the returned information. With annotations covering safety and open-world output, there is no additional context an agent clearly needs to select or invoke this tool correctly.

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

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

The tool takes zero parameters and the input schema is empty, so there are no parameter semantics for the description to clarify. The baseline of 4 applies because nothing is missing.

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 ('Get'), a unique resource ('pricing'), and the exact scope ('per-resource hourly rates and volume pricing tiers'). It is clearly distinct from sibling tools, which all target different resources like cubes, domains, snapshots, or TCP mappings.

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 conveys a clear use case—fetching pricing information—and no sibling tool overlaps with pricing, so there is no alternative to exclude. It does not explicitly say 'when not to use,' but the naming and scope leave little ambiguity.

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

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

Annotations already provide readOnlyHint=true and openWorldHint=true, so the description does not need to restate safety. It adds context that the operation lists all arrays of data within a cloud space, but does not disclose potential pagination, performance, or authentication nuances. This is adequate but not enriched beyond annotations.

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

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

A single sentence that front-loads the action and resource, with zero filler or redundancy. Every word earns its place, and the clarifying parenthetical is helpful without bloating the text.

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

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

For a simple read-only list tool with one optional parameter, the description is nearly complete. It could mention what fields are returned or note the array shape since there is no output schema, but the core behavior and scope are clear enough for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, and the single parameter's description fully explains that it is optional when KROVA_SPACE_ID is set. The main description adds no parameter detail, so the baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description names a specific verb ('List'), a specific resource ('Cubes' with the clarifying parenthetical 'Firecracker microVMs'), and a clear scope ('in a Krova Cloud Space'). The word 'all' inherently distinguishes it from sibling get_cube, which targets a single Cube.

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

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

The description implies the tool is for listing the full set of Cubes, but it does not explicitly state when to use it versus get_cube or when not to use it. There are no exclusions or named alternatives, so usage context is only inferred.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description does not need to restate safety. It adds context by specifying the scope ('attached to a Cube'), but discloses no additional behavioral traits such as pagination, ordering, or empty-result behavior. No contradiction with annotations exists.

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 front-loads the action ('List') and the resource ('custom domains attached to a Cube'), earning its place efficiently.

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

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

For a simple read-only list operation, the description plus schema and annotations are largely sufficient. The main gap is the absence of any return-shape or pagination details, though the lack of an output schema makes this a minor issue rather than a blocking one.

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

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

Schema description coverage is 100%, so the input schema fully documents cubeId and spaceId. The description adds no new parameter-level meaning beyond the schema; the baseline of 3 is appropriate when the schema already carries the semantic weight.

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 ('List') and a specific resource ('custom domains attached to a Cube'), making the tool's function immediately clear. It also differentiates well from sibling tools like get_domain_records, create_domain, and list_cubes by scoping to custom domains on a Cube.

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 the tool: when you need to see custom domains associated with a Cube. However, it gives no explicit guidance on when not to use it or which sibling alternative (e.g., get_domain_records) should be chosen instead.

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

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

The readOnlyHint and openWorldHint annotations already cover the basic behavioral profile. The description adds semantic scope (OS images for new Cubes) but does not disclose additional behavior such as output format, pagination, regional availability, or how the images relate to create_cube. This is acceptable for a simple zero-parameter tool but adds limited value beyond the annotations.

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

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

The description is a single, concise sentence with no filler. It front-loads the verb and resource, and every word earns its place by clarifying the tool's scope.

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, read-only listing tool with no output schema, this description is complete enough. It states what is listed (OS images) and for what purpose (new Cubes), which is sufficient for an agent to select and invoke the tool correctly in this simple context.

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

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

The tool has zero parameters and schema description coverage is 100%, so the schema fully documents the parameter space. With no parameters, the description does not need to clarify parameter meaning; the baseline score of 4 applies.

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

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

The description uses a specific verb ('List'), a distinct resource ('OS images'), and a clear scope ('for new Cubes'), which differentiates it from sibling tools like list_cubes, list_regions, and list_snapshots. An agent can immediately understand what this tool does and what it returns without opening the schema.

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

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

The description implies the tool is used to see images that can be used when creating a Cube, but it does not explicitly state when to use it vs alternatives or mention it as a prerequisite for create_cube. No exclusion or alternative guidance is provided, so the usage context is only implied.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the description does not need to repeat safety traits. It adds the 'available capacity' detail, but leaves ambiguity about whether that filters regions or describes the returned field.

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

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

The description is a single front-loaded sentence with no filler. The qualifier 'with available capacity' earns its place by adding useful scoping information.

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

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

For a no-parameter, read-only list operation, the description plus annotations are sufficient for an agent to invoke the tool correctly. A minor gap is the lack of detail about the exact response shape or the meaning of 'available capacity'.

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, so the schema already covers everything. The description's 'available capacity' phrase hints at return-value semantics rather than parameters, and no further compensation is needed.

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 ('List'), a concrete resource ('Krova Cloud regions'), and a useful qualifier ('with available capacity'). It is clearly distinct from sibling tools such as list_cubes, list_images, and list_domains.

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

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

The description gives clear context that this is the region-listing operation. It does not explicitly name alternatives, but no sibling tool covers regions, so selection is 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?

The annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is established. The description adds minimal behavioral context beyond the basic listing action; it does not mention output format, ordering, or snapshot access semantics, but it does not contradict the annotations.

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

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

A single, direct sentence with no filler. The core action and resource are front-loaded, making the description efficient and immediately parseable.

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

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

For a simple read-only list tool with fully documented parameters and no nested objects, the description covers the essential operation. It could have briefly noted what the list returns or that it operates on the cube's disk snapshots, but the current level is sufficient for basic invocation.

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

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

Schema description coverage is 100%, so both cubeId and spaceId are fully documented in the input schema. The description adds no extra parameter context, so the baseline of 3 applies.

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

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

The description uses a specific verb ('List') applied to a clear resource ('a Cube's disk snapshots'). This distinguishes it from sibling snapshot tools like create_snapshot, delete_snapshot, and restore_cube, and from other list tools like list_cubes.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites, filters, or contextual conditions. There are no explicit when/when-not statements or references to 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 readOnlyHint and openWorldHint annotations already establish that this is a read-only operation. The description adds no further behavioral context beyond the basic listing behavior, such as output format, pagination, or failure conditions, but it does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to stating the tool's core purpose, and it is appropriately concise for a simple list operation.

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

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

For a low-complexity read-only list tool, the description plus the complete input schema and annotations give an agent enough to select and invoke the tool correctly. No output schema exists, and the description need not detail return values for such a straightforward operation.

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

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

Schema description coverage is 100%, and the schema already explains cubeId and spaceId adequately. The tool description adds no additional parameter-level meaning, but the structured schema carries the burden, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('List') and a clear resource ('a Cube's TCP port mappings'). It distinguishes this tool from its siblings create_tcp_mapping and delete_tcp_mapping by the action and resource scope.

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

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

The intended use is implied by the verb 'List' and the resource 'TCP port mappings', but there is no explicit guidance about when to prefer this tool over alternatives or any exclusion criteria. It does not mention related operations like creating or deleting mappings.

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

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

The description adds meaningful behavioral detail beyond the annotations: the operation is asynchronous, compute and host RAM are released, disk is preserved, and the resulting state is 'stopped.' This complements the annotations (non-destructive, idempotent) rather than contradicting them.

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

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

The description is a single, well-structured sentence that front-loads the core action and asynchronous behavior, then states the key resource effects. There is no filler or redundant information.

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

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

For a simple two-parameter tool with no output schema and no nested objects, the description is complete: it covers the operation's purpose, async behavior, resource release, disk persistence, and final state. The schema fully documents parameters, and annotations cover idempotence and non-destructiveness.

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

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

Schema description coverage is 100%, so the input schema already explains cubeId and spaceId. The description does not add parameter-specific semantics, but with full schema coverage the baseline of 3 is appropriate.

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

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

The description clearly states a specific action ('power off'), a specific target ('a running Cube'), and an important qualifier ('asynchronous'). It also distinguishes itself from destructive alternatives like delete_cube by explicitly noting that disk is preserved and the Cube becomes stopped.

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

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

The description gives clear context for when to use this tool: on a running Cube when the intent is to release compute and host RAM while preserving disk and moving the Cube to a stopped state. It does not explicitly name alternative tools or when-not conditions, but the state-transition language sufficiently separates it from wake_cube, restart_cube, and delete_cube.

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 goes well beyond the annotations by disclosing that this is a cold, asynchronous restart where the hypervisor process is stopped and relaunched. It explicitly states that disk state is preserved, only the kernel changes, and that the Cube must be running. These details align with destructiveHint=false and readOnlyHint=false, and add meaningful operational context about side effects and execution semantics.

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 tightly structured: each sentence contributes a distinct piece of information — the operation type, the mechanism, the unique use case, the effect on disk/kernel, and the precondition. There is no filler or redundancy, and the most important information is front-loaded in the first sentence.

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

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

Given the relatively simple tool (2 parameters, no nested objects, no output schema), the description covers all essential aspects an agent needs: the operation, why it exists, when to use it, its side effects, and its precondition. The absence of an output schema is not a significant gap because the description already indicates the operation is asynchronous and the key outcome is the kernel refresh. No critical information 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%, with cubeId and spaceId both already documented in the schema. The description adds no parameter-specific meaning beyond what the schema provides, so the baseline score of 3 is appropriate. It does not introduce any confusion or new parameter behavior.

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 and resource with precision: 'Restart a running Cube — a COLD restart (asynchronous).' It clearly differentiates this operation from an in-guest reboot and from related operations like power_off_cube, wake_cube, or restore_cube by explaining that it relaunches the hypervisor process and only changes the kernel while preserving disk state. The unique use case (picking up a refreshed guest kernel after a platform image update) is also explicitly stated.

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 an explicit when-to-use condition: 'This is the only way a Cube picks up a refreshed guest kernel after a platform image update.' It also explains why an alternative approach (issuing `reboot` inside the Cube) cannot achieve this, which is clear when-not guidance. The precondition 'The Cube must be running' further tells the agent when it is safe to invoke the tool.

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

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

Annotations already indicate destructiveHint=true. The description goes beyond this by explicitly stating that the operation REPLACES the current disk and is irreversible. This gives the agent concrete knowledge of what will be destroyed, which is valuable for a destructive mutation tool.

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

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

The description is two well-structured sentences with zero filler. The core action is front-loaded, followed immediately by the critical destructive warning. Every word contributes to understanding what the tool does and why caution is required.

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

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

For a destructive tool with no output schema, the description covers the essential context: what is being restored, what is replaced, and that the operation cannot be undone. It relies on the schema for parameter details and on annotations for safety flags, which is appropriate. The only minor gap is that it does not state whether the Cube must be powered off before restoring.

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

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

The input schema has 100% coverage, with each parameter already carrying a clear description. The tool description adds no additional parameter-level detail beyond explaining that the snapshot is the source of restoration. This meets the baseline of 3 since the schema does the heavy lifting.

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

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

The description clearly states the action ('Restore a Cube's disk from one of its snapshots') and the resource affected. It also distinguishes itself from snapshot-management siblings (create_snapshot, list_snapshots, delete_snapshot) by emphasizing disk replacement, and from delete_cube by being a restore operation rather than a delete 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 the appropriate use case—rolling back a Cube's disk to a previously captured snapshot—and the warning suggests caution. However, it does not explicitly mention preconditions (e.g., that a snapshot must already exist) or contrast itself with alternatives such as creating a new snapshot versus restoring one.

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 meaningful behavioral detail beyond the annotations: the change is verified against the Cube before being applied, and if the domain does not serve, the route is left on http. It also explains the derived port behavior and the TLS-related implications, giving the agent a clear picture of side effects and failure handling.

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 brief, front-loads the core action and scope, and avoids duplicating parameter-level detail that already exists in the schema. 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 the small parameter count, full schema coverage, and the behavioral detail provided in the description, the tool definition is effectively complete for an agent to select and invoke it correctly. The verification behavior and failure fallback are particularly valuable for a mutating operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds some context about the origin scheme's role in the edge-to-Cube transport, but importantly, the schema itself already contains the detailed explanation of originScheme, so the description does not carry a significant additional burden.

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 action ('Change'), the resource ('a custom domain's proxy settings'), and the specific exposed capability ('origin scheme'). It is easily distinguishable from sibling tools like create_domain, delete_domain, and list_domains without requiring schema inspection.

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 intended usage is implied: use this tool when you need to update a custom domain's proxy/origin scheme. However, there is no explicit guidance about when not to use it or which sibling tool should be used instead for related operations like creating or deleting a domain.

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

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

Annotations already declare readOnlyHint=false and idempotentHint=true, and the description adds the key behavioral trait that the operation is asynchronous. However, it does not explain what 'asynchronous' means in practice—how completion is observed, whether errors surface immediately, or what the response contains.

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

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

The description is a single sentence with no filler, front-loading the action and target state before the asynchronous qualifier. Every word earns its place.

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

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

For a simple two-parameter tool, the description plus annotations cover the essentials: mutation, idempotency, and asynchronous execution. It could be more complete by advising verification via get_cube, but the low complexity and strong schema coverage make the current definition adequate.

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

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

Schema description coverage is 100%, so the schema already documents cubeId and spaceId sufficiently. The description adds no parameter-specific meaning, which the rubric treats as acceptable at baseline.

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

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

The description uses a specific verb ('Start') with a clear resource ('Cube') and a precise precondition ('stopped'), which distinguishes it from siblings like create_cube (new resource) and restart_cube (already running state). The parenthetical 'asynchronous' adds an important behavioral qualifier.

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

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

The word 'stopped' gives explicit context for when the tool applies, setting it apart from operations on running cubes. It does not name alternatives or state when not to use it, so it stops short of full routing guidance.

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