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

Annotations cover the safety profile (destructive, non-idempotent, open-world) but the description adds substantial behavioral context beyond them: billing responsibility, backup-limit consumption, required permission level, and the specific 422 failure reasons. It also discloses the return payload.

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

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

Front-loads the action and its consequence, then permissions, then error cases. Every sentence carries information, though the 422 enumeration makes it slightly dense.

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?

Covers action, side effects, permissions, failure modes, and even the return value despite there being no output schema. For a 2-parameter mutation tool, 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% and both parameters are documented in the schema, including cross-referencing list_backup_shares for shareId and the KROVA_SPACE_ID default for spaceId. The description adds no parameter-level detail beyond that, so the baseline 3 applies.

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

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

States a specific verb+resource action ('accept a backup share') and immediately clarifies the side effect (the space gets its own copy). It is clearly distinguishable from the sibling decline_backup_share and cancel_backup_share.

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?

Gives explicit preconditions ('confirm with the user first'), authorization rules (owner or Manage Backups), and refusal conditions. It does not explicitly name the sibling alternatives (decline/cancel) as the when-not path, so it falls just short of a 5.

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

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

Annotations already declare it is a non-read-only, non-destructive, non-idempotent, open-world operation, so the safety profile is covered. The description adds real value beyond that by stating the authorization model (owner, Manage Backups member, or the originating member). It stops short of describing the effect on state or error behavior.

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

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

Two tight sentences with zero waste; the operational condition is front-loaded and the permissions follow. Nothing redundant.

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 and only one required parameter, the description covers the essential context: what it acts on, its timing constraint, and who may call it. Return values need not be explained. It is close to complete, missing only expected outcome/error semantics.

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% — shareId and spaceId are fully documented, including the KROVA_SPACE_ID default fallback. The description adds no parameter-level detail beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb (withdraw/cancel) and resource (a pending backup share this space offered), plus the temporal scope (before the destination answers). This clearly distinguishes it from the sibling accept/decline_backup_share, which operate on the recipient side.

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?

Gives the condition under which it applies (a pending share, before the destination responds) and lists who may invoke it. It does not explicitly name or contrast with sibling tools, but the 'this space offered' phrasing implicitly routes the agent away from decline/accept.

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 beyond the annotations by disclosing that provisioning is asynchronous and the Cube starts in a pending state, and that it begins hourly billing. These are valuable behavioral details not captured in the annotations, and they align with destructiveHint=true.

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 with zero fluff. It front-loads the core purpose, then packs essential behavioral and cost warnings into the second sentence. 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?

With no output schema, the description explains the asynchronous return state, addressing the outcome. It also flags billable side effects. It doesn't discuss permissions or how to monitor pending progress, but combined with schema and annotations it is sufficiently complete for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all 10 parameters thoroughly. The description adds no parameter-specific meaning, so the baseline of 3 is appropriate.

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

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

The description clearly states 'Create (provision) a new Cube in a Space' with a specific verb and resource, making the tool's purpose unambiguous. It is obviously distinct from sibling tools like delete_cube or create_snapshot, even without naming them.

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

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

The description implies usage by defining what the tool does and adds relevant context about asynchronous provisioning and billing, but it does not explicitly compare with alternatives or state when not to use it. This is adequate but not 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?

Annotations only declare this is a non-idempotent mutation (readOnlyHint=false, idempotentHint=false). The description adds substantial context beyond that: the tool returns DNS records the caller must relay verbatim, the domain is inert until those exist, and a proxied record breaks certificate issuance. It omits the idempotency implication (re-calling creates another attempt) and any auth/permission requirements.

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

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

Four sentences, all load-bearing: purpose first, then return payload, then the operational requirement, then the failure-mode caveat. No filler and the critical information is front-loaded.

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

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

With no output schema, the description correctly compensates by explaining the returned domain and DNS records. Combined with the safety annotations and 100% schema coverage, an agent has enough to invoke it correctly, though permission prerequisites and duplicate-call behavior remain unaddressed.

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 itself documents every parameter including the nuanced originScheme, proxyProtocol, and confirmMixedProxyProtocol notes. The description reinforces the port-routing concept but adds no syntax or format detail the schema lacks, so the baseline 3 applies.

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

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

States a precise verb and resource ('Attach a custom domain to a Cube, routing it to an in-Cube port') and immediately identifies its return payload. An agent can distinguish this from update_domain, delete_domain, and get_domain_records without opening a 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?

Gives strong conditional guidance: subdomain vs wildcard record counts, and the Cloudflare grey-cloud requirement that selects between DNS-only and proxied. However, it never names the sibling alternatives (e.g. update_domain to modify an existing domain) or states explicit when-not conditions, so routing between siblings is left to inference.

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 this is a mutating, non-idempotent operation. The description adds the concrete behavioral context that this exposes a port on the host, which is an externally visible side effect. However, it does not disclose other useful details such as how the host port is chosen 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, front-loaded sentence with no wasted words. It conveys the core action and a key optional behavior 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?

With no output schema, the description should explain what the caller gets back or how the host port is allocated, but it does not. It also does not mention prerequisites such as the cube needing to exist. The parameter schema covers inputs, but the operational outcome is underspecified.

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 parameters are already well documented. The description's mention of 'restricted to specific IPs/CIDRs' aligns with the whitelistedIps parameter but adds no meaning beyond what the schema already provides.

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

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

The description states a specific verb ('Expose'), a specific resource ('a Cube TCP port'), and the target context ('on the host'), while also mentioning optional IP/CIDR restrictions. This clearly distinguishes it from related operations like list_tcp_mappings or delete_tcp_mapping.

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 makes the use case clear: use this tool when you want to expose a Cube TCP port on the host, optionally with access restrictions. It does not explicitly name alternatives or exclusion criteria, but the intended context is unambiguous and the optional-restriction note adds practical guidance.

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

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

Annotations already indicate this is a non-read, non-idempotent operation, and the description adds crucial behavioral context: the signing secret is returned only in this response and must be persisted immediately. This is a one-time side-effect an agent cannot infer from the schema.

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

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

The description is two sentences with no wasted words. The purpose is front-loaded, and the critical secret-persistence warning immediately follows.

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 4-parameter creation tool with no output schema, the combination of complete parameter docs, annotations, and the one-time secret warning gives an agent everything needed to invoke it correctly. The only non-obvious response information, the signing secret, is explicitly 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 url, events, spaceId, and description are already fully documented. The description's phrase 'one or more events' reflects the events parameter but adds no new meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description names a specific verb and resource ('Create a webhook endpoint') and adds the key action 'subscribe it to one or more events.' This clearly distinguishes it from sibling tools like list_webhooks, get_webhook, and delete_webhook.

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 makes the intended use clear: creating a new webhook endpoint and subscribing it to events. It does not explicitly list exclusions or alternatives, but no alternative creation tool exists among the siblings, so the context is sufficient.

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 cover the safety profile (mutating, non-destructive, non-idempotent, open-world). The description adds valuable behavioral facts beyond that: nothing is copied or billed, and it requires the same permission as accept_backup_share. It doesn't state the resulting state of the share, but the added context is meaningful.

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 short sentences, front-loaded with the action, then the key side effect (no copy/billing), then permission. No waste; 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 simple two-parameter mutation with full schema coverage and annotations, the description covers what the tool does, what it does not do (copy/bill), and permission requirements. The only minor gap is what happens to the share record after declining, but this is not essential for correct invocation.

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

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

Schema description coverage is 100%, so shareId and spaceId are fully documented in the schema. The description adds no parameter-level information, which is acceptable given the complete schema (baseline 3).

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

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

Clear verb + resource ('Decline a backup') and scope clarification ('another space shared with this one') specify this is the recipient declining an incoming share. It names sibling accept_backup_share for permission context, though it doesn't explicitly distinguish from cancel_backup_share.

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

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

Usage is implied by the action itself (declining a share you don't want), but there is no explicit when-to-use versus accept_backup_share or cancel_backup_share. The mention of accept_backup_share is for permission equivalence, not usage routing.

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 declare destructiveHint=true and readOnlyHint=false. The description goes beyond annotations by disclosing that delivery history is also cascaded/deleted, which is useful behavioral context. It doesn't mention irreversibility or permissions, but the annotations cover the core destructive nature.

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

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

One concise sentence with no filler. The key action 'Deletes' is front-loaded, and the cascade detail is included efficiently 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?

For a simple destructive action with two well-documented parameters and annotations indicating destructiveness, the description is largely complete. It covers the main object and the cascade effect. It doesn't mention return value (no output schema) or prerequisites, but those are not critical here; a minor gap around reversibility/permissions keeps it from a 5.

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

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

Schema description coverage is 100%, with both spaceId and endpointId properly documented in the input schema. The description itself adds no parameter-specific meaning beyond the schema, so the baseline 3 is appropriate.

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

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

The description 'Deletes the endpoint and cascades its delivery history' names a specific verb, resource, and an additional cascade behavior. It is clearly distinct from sibling tools like delete_cube or delete_domain, leaving no ambiguity about what is being deleted.

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 when-to-use, when-not-to-use, or alternatives are mentioned. The description only states the action; an agent must infer from the name that this is the tool for removing a webhook endpoint, with no guidance on prerequisites or cases where it should be avoided.

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 safety profile is covered. The description adds the required 'View Backups' permission, which is useful authorization context beyond the annotations, but says nothing about failure modes or what the returned backup 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?

Two short sentences, zero waste, with the core action and the permission requirement front-loaded. Nothing redundant with the title or name.

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 single-resource read with full schema coverage and annotations carrying the safety profile, the description covers the essentials plus the permission prerequisite. A brief note on typical errors (missing/invalid id) would make it 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 parameters (spaceId with its server-default fallback, backupId cross-referenced to list_backups) are fully documented in the schema. The description's 'by id' adds no meaning beyond that, making the baseline 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?

States a specific verb and resource ('Get one backup by id'), and the phrase 'one backup' implicitly contrasts with the sibling list_backups. It does not name an alternative explicitly, but the singular retrieval 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 supplies a prerequisite ('Needs the View Backups permission'), which is genuine usage context, and the backupId schema note points to list_backups for discovery. However, there is no explicit when-to-use vs when-not guidance or routing among the backup siblings (share_backup, list_backup_shares).

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 include readOnlyHint=true, which covers the read-only nature. The description adds valuable behavioral context beyond annotations by explicitly stating that the signing secret is never returned and is only available at create time, plus enumerates what fields are included in the response.

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 exactly two sentences with no filler. The primary purpose and key behavioral note are front-loaded, and 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 read-only tool with two parameters and no output schema, the description covers the purpose, the return contents, and an important exclusion (signing secret). Combined with the annotations and schema, it provides everything an agent needs to call 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?

Schema description coverage is 100%, so both parameters (spaceId and endpointId) are already documented in the schema. The tool description does not add extra parameter-level meaning beyond the schema, 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 clearly states the action ('Get'), the resource ('a single webhook endpoint by id'), and the specific fields returned (URL, subscribed events, enabled flag). It distinguishes itself from siblings like list_webhooks (which lists all) by focusing on a single endpoint by id.

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 makes it clear this tool is for retrieving a specific webhook by id, implying it is used when you have an endpoint id and need its details. It does not explicitly mention alternatives or when not to use it, but the context 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?

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. The description adds valuable context: newest-first ordering, that backups persist after the Cube is gone and are redeployable, and that sharedFromBackupId signals a copy shared from another space. It also states the required permission.

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 compact sentences with zero waste. The purpose and ordering are front-loaded, followed by clarifying semantics and the permission requirement.

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 does a good job explaining what each backup represents and the ordering. It does not mention pagination or response shape, which is a minor gap for a list 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?

Schema coverage is 100% and the single optional parameter (spaceId) is fully documented in the schema. The description adds no extra meaning about the parameter itself, so baseline 3 is appropriate.

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

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

States a specific verb (List) and resource (backups) scoped to the space, plus ordering. Defines what a backup is, making the tool's output semantics clear. Does not explicitly differentiate from siblings like get_backup or list_backup_shares, so only 4.

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 permission prerequisite is stated, which helps usage. However, there is no explicit when-to-use vs alternatives guidance—no mention of when to use get_backup, share_backup, or list_backup_shares instead. Usage is only implied by the listing scope.

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 safety is covered. The description adds genuine context beyond them: the result set is filtered to pending/unexpired shares in both directions, and the call requires the View Backups permission, an auth prerequisite not present in the 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 compact sentences, front-loaded with the scope and state definitions, with no filler. The trailing `counterpartySpaceName` clause refers to output rather than input in a parameter-focused sentence, which costs a little clarity but not much 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?

For a simple one-optional-parameter read tool with no output schema, the description covers what is returned (incoming/outgoing pending shares, the counterparty space) and the permission gate. An agent has enough to invoke it correctly; only pagination/expiry specifics are absent, which is acceptable here.

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

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

Schema description coverage is 100% for the single optional `spaceId` parameter, so the schema already carries the semantics and the baseline of 3 applies. The description adds no syntax or defaulting detail beyond the schema; its mention of `counterpartySpaceName` describes a response field, not an input parameter, which slightly muddles rather than clarifies parameter 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 names the resource precisely (backup shares) and narrows the scope to pending, unexpired ones, then defines the `incoming`/`outgoing` distinction. It implicitly separates this read-only listing from the action siblings (share_backup, accept_backup_share, decline_backup_share, cancel_backup_share), but never names them or explicitly contrasts with list_backups/get_backup.

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

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

Usage is implied by the state definitions ('waiting for this space to accept or decline' suggests when an agent would look here), and the View Backups permission requirement is a stated prerequisite. There is no explicit when-to-use, when-not-to-use, or pointer to an alternative sibling 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 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?

Annotations already mark this read-only and open-world, so the safety burden is covered. The description adds meaningful behavioral context beyond annotations: the 30-day retention window, newest-first ordering, and the supplied limit with a max of 100.

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 tightly written sentences with no filler. The scope, ordering, limit, and diagnostic purpose are all front-loaded, and the use case 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 read-only, single-required-parameter list tool with fully documented schema parameters, the description covers the important operational constraints: time window, ordering, and limit. Nothing needed to select and call this tool 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%, so the schema already documents all three parameters. The description reinforces the limit cap but does not add substantive parameter meaning beyond what the schema provides, matching 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 uses a specific verb and resource: it lists webhook delivery attempts, not webhook endpoints or webhooks themselves. It also adds distinguishing scope details (last 30 days, newest first, limit cap) that separate it clearly from sibling list_webhooks.

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 use context: diagnosing why an endpoint never received or acknowledged an event. It does not explicitly name alternatives or when-not-to-use, but the diagnostic framing plus sibling names provides enough directional guidance.

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

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

The readOnlyHint=true annotation already covers the safety profile, so the description adds value by describing what each listed webhook contains: an HTTPS URL, subscribed events, and enabled state. There is no contradiction and no undisclosed mutation or side 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 a single, well-structured sentence with the action and scope front-loaded. Every clause adds useful information about the resource or its returned fields, with no filler.

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

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

For a simple read-only list tool with no output schema, the description covers the result contents and the Space scoping. It does not mention pagination or ordering, but the low complexity and readOnlyHint annotation make that a minor gap 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 coverage is 100% for the single optional spaceId parameter, and the description adds no new parameter-level detail beyond restating the Space scope. The schema already explains that spaceId can default from KROVA_SPACE_ID, so the description does not need to compensate.

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

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

The description clearly states the verb 'List', the resource 'webhook endpoints registered against a Space', and the key attributes returned (HTTPS URL, subscribed events, enabled status). It does not explicitly contrast sibling tools like get_webhook or list_webhook_deliveries, but the list semantics 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 provides clear context: this tool lists webhook endpoints scoped to a Space. It implies read-only enumeration, but it does not explicitly name when to prefer get_webhook or list_webhook_deliveries instead, so it stops short of a 5.

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

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

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

Annotations provide readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds significant behavioral detail: delete_cube rejection with 409, Krova's exception with audit row, allowed operations, and idempotent no-op behavior. This exceeds annotation coverage and provides valuable context without contradiction.

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

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

The description is three sentences, front-loaded with the primary action, then covers key effects, exceptions, and undo path. Every sentence adds distinct value with no redundancy.

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

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

The description covers the tool's purpose, behavior under protection, exceptions, allowed operations, idempotency, and how to disable it. For a simple mutation with clear annotations, nothing essential 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% (both cubeId and spaceId have descriptions). The description does not add parameter-specific semantics beyond what the schema provides, 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 the precise action ('Turn on termination protection for a Cube') with a clear verb and resource, and distinguishes itself from siblings like delete_cube and unprotect_cube by explaining the effect on delete_cube. It leaves no ambiguity about the tool's function.

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 implicitly guides usage by explaining the protected state and explicitly names the alternative for toggling off (unprotect_cube). It does not explicitly say when not to use it, but the context is clear enough for an agent to decide.

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?

Discloses far more than the annotations: nothing is copied until the recipient accepts within 48 hours, the accepted copy is billed to the destination, the source backup/bill are unchanged, the request is always pending even when the same user owns both spaces, and Manage Backups is required. This is unusually rich behavioral context for a destructive-hinted mutation.

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

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

Front-loads the action ('Offer a copy...') before the conditions, and each sentence carries distinct information (timing, billing, pending semantics, permission). Slightly dense but no filler.

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

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

For a mutation tool with no output schema, the description covers timing, acceptance, billing ownership, permission requirements, and the always-pending behavior — everything an agent needs to invoke and warn the user 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 each parameter is documented in the schema (spaceId default behavior, backupId via list_backups, destinationSpaceId). The description only implies the destination parameter via 'the destination space'; baseline 3 applies since the schema carries the semantics.

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

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

States a precise verb+resource: 'Offer a copy of a backup to another space.' This is clearly the initiation step, distinguishable from accept_backup_share, decline_backup_share, and cancel_backup_share among the siblings.

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

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

Gives clear context: confirm the destination with the user first, needs Manage Backups permission, and the offer stays pending. It does not explicitly name accept/decline/cancel siblings as the follow-up alternatives, but the framing makes the corresponding workflow evident.

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

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

Even though idempotentHint is already in annotations, the description adds concrete detail: 'unprotecting an already-unprotected Cube is a no-op server-side' and clarifies the exact consequence for delete_cube. This enriches the annotation-provided safety profile without contradicting 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?

Three sentences, all information-dense: purpose, effect, idempotency, and inverse tool. No filler or repetition; the main action 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?

For a tool with only 2 parameters, no output schema, and no nested objects, the description covers purpose, side effects, idempotency, and the inverse operation. An agent has everything needed to decide and invoke it correctly.

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

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

Input schema coverage is 100%: both cubeId and spaceId have descriptions in the schema. The description itself adds no parameter-specific detail, so it provides no value beyond the schema. Baseline 3 is appropriate.

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

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

The first sentence uses a specific verb and resource ('Turn off termination protection for a Cube'), immediately stating the tool's function. It also names the inverse operation (protect_cube) and ties the purpose to the delete_cube workflow, clearly distinguishing it from sibling tools like protect_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 description explicitly states the effect on delete_cube, which tells the agent when this tool is needed (before deleting a protected Cube). It also names the alternative for the reverse action ('To turn protection back on, call protect_cube'), leaving no ambiguity about usage context.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true and openWorldHint=true, so the mutation/safety profile is covered. The description adds one trait not present in the annotations: that this is a patch-style operation where omitted settings retain their current values, and that at least one setting must be supplied. It does not restate the risk context (TLS mismatch, 409 on mixed PROXY protocol) that lives in the schema, but the annotations lower the bar.

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 tight sentences with the resource named first, then the accepted settings, then the constraint. Zero filler and nothing buried.

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

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

For a mutation tool with no output schema but full schema description coverage and annotations, the description supplies the patch-semantics contract an agent needs. The conflict/refusal behaviors are documented in the schema parameters rather than the description, which is acceptable but leaves the top-level entry slightly thin.

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 both enum parameters carry rich, self-contained descriptions (defaults, failure modes, the 409 confirm flow). The description only restates the two settings at a conceptual level, so the schema does the heavy lifting and a baseline 3 is appropriate.

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

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

The description names a specific verb ("Change") and resource ("a custom domain's proxy settings") and enumerates exactly the two settings it touches: origin scheme and PROXY protocol header. Against siblings like create_domain and delete_domain, the update semantics 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?

It gives invocation-level guidance ("Pass at least one; a setting you leave out keeps its current value"), which clarifies partial-update behavior, but there is no when-to-use/when-not guidance or reference to alternative tools for domain configuration. Usage is implied rather than framed.

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.