Contabo (VPS) MCP Server

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

The annotations already indicate destructive behavior (destructiveHint: true), and the description adds no extra context about side effects, idempotency, or what happens if the instance is already assigned. The description simply repeats the action without providing any behavioral details.

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

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

The description is redundant, repeating the same idea twice ('Add instance to a Private Network' and 'Add a specific instance to a Private Network'). This wastes space without adding meaningful information, making it less concise than a single well-worded sentence would be.

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 and minimal annotation, the description is severely incomplete. It does not mention return values, error conditions, prerequisites (e.g., existing network or instance), or any consequences of the operation. This is insufficient for an agent to safely and correctly use the tool.

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

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

The schema has no parameter descriptions (0% coverage), and the description does not explain any of the parameters. It only mentions 'instance' and 'private network', which are already obvious from the parameter names, and gives no clarity on x-request-id or x-trace-id. The description fails to compensate for the missing schema metadata.

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

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

The description clearly states the action ('Add') and the resources involved ('instance' and 'Private Network'), making it obvious what the tool does. It also distinguishes from the sibling tool 'unassignInstancePrivateNetwork' by describing the opposite operation.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. For example, it does not mention the sibling 'assignIp' or 'createAssignment' tools, making it unclear what unique scenario this tool is for.

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, so the agent knows it's a mutating operation. However, the description adds no further behavioral context about what changes occur (e.g., whether existing VIPs are replaced, if downtime is expected, or if the resource must be stopped).

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 very short, but the second sentence redundantly restates the first with only 'using the machine id' added. It could be more concise by merging into one sentence without loss of 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?

As a destructive mutation with no output schema, no parameter details, and no usage guidance, the description is insufficient for an agent to understand the full scope of the operation. It lacks information about preconditions, side effects, and postconditions.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'resourceId' is the 'machine id' and hints at the resourceType enum (VPS/VDS/Bare Metal), but leaves ip format, header requirements, and other parameters unexplained.

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

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

The description clearly states the action ('Assign a VIP') and the target resource type ('VPS/VDS/Bare Metal'), which distinguishes it from read-only tools. However, it doesn't differentiate from sibling tools like createAssignment or unassignIp, which could also involve assignments.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or conditions (e.g., IP availability, resource state). The description simply restates the action without 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 disclose destructiveHint=true and readOnlyHint=false, but the description adds no further behavioral context—no mention of irreversibility, impact on DNS resolution, required permissions, or side effects. It simply restates the delete operation without elaborating on consequences beyond what annotations already signal.

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

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

The description is extremely short and free of unnecessary words, which is concise. However, it largely repeats the title and offers no additional structure or information. It is not bloated, but it also doesn't earn its place by adding value beyond the 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?

Given the tool has 4 parameters, no output schema, and minimal annotations, the description is severely incomplete. It provides no context about return values, error cases, required headers, or the effects of bulk deletion. The description offers only a trivial statement of purpose, leaving the agent without essential operational 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?

Schema description coverage is 0% and the description provides no parameter details. It does not explain zoneName, x-request-id, or the structure of the request body beyond what is already in the schema. The description fails to compensate for the lack of schema descriptions, leaving parameter meaning largely unexplained.

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 (delete), the resource (DNS zone records), and the bulk nature, distinguishing it from sibling deleteDnsZoneRecord which targets a single record. The phrasing 'Delete multiple zone records from a DNS Zone' is specific and unambiguous.

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

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

The word 'bulk' implies use when deleting multiple records, but there is no explicit guidance on when to choose this tool over alternatives like deleteDnsZoneRecord, nor any exclusions or prerequisites. Usage context is only implied by the name and phrase 'multiple zone records'.

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 destructiveHint=true and readOnlyHint=false, so the safety profile is known. The description adds no additional behavioral details such as irreversibility, confirmation steps, or consequences beyond the action itself, so it provides no value beyond the structured annotations.

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

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

The description is two identical phrases ('Cancel a specific domain - Cancel a specific domain'), which is redundant and wastes the second sentence. It is concise in length but under-specified, and the repetition detracts from clarity.

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

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

This is a destructive cancellation operation with no output schema and a nested request body. The description provides no information about return values, side effects, prerequisites, or how to specify the domain. It is far too minimal to be contextually complete for an agent.

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

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

Schema description coverage is 0%, and the description does not mention any of the four parameters or the nested cancelDomainBody fields. The description adds no meaning to the input schema, leaving the agent without any semantic context for domain, x-request-id, x-trace-id, or cancelDomainBody.

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 action clearly ('Cancel a specific domain'), but it is essentially a repetition of the title and does not distinguish this tool from siblings like cancelInstance or revokeCancelDomain. It is not vague, but it adds no detail about the scope or process beyond the resource being acted upon.

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

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

No guidance is provided on when to use this tool vs alternatives, prerequisites, or what happens after cancellation. The description is purely a statement of the operation and gives no contextual cues for an agent to select it appropriately.

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 destructive nature is known. The description adds the claim 'at any time,' implying no restriction, but doesn't disclose post-cancellation effects, reversibility, or idempotency. Minimal extra value 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?

The description is very short and front-loaded with the purpose. However, the second clause 'Your are free to cancel...' is grammatically flawed ('Your' instead of 'You') and adds little substance, slightly reducing efficiency.

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 four parameters, no output schema, and a destructive operation, a one-line description is insufficient. It does not explain the body parameter, prerequisites (e.g., instance state), or expected result, leaving significant gaps for an agent to invoke 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 0%, and the description only references 'by id' (instanceId). It fails to explain the required cancelInstanceBody (containing cancelDate) or x-request-id. The description does not compensate for the low 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 the verb 'Cancel' with the resource 'specific instance by id', clearly distinguishing from other cancellation tools (cancelDomain, CancelObjectStorage). It unambiguously states the action and target.

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

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

'You are free to cancel a previously created instance at any time' provides clear context that cancellation is permitted without temporal restrictions. It doesn't explicitly exclude alternatives (e.g., stop/shutdown) or mention prerequisites, but the context is sufficient for most usage cases.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds meaningful context by specifying that cancellation happens at the next possible date and warns about contract periods, going beyond the basic destructive flag. It also correctly aligns with annotations.

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

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

The description opens with a clear sentence but then repeats the exact same phrase after a dash, creating unnecessary redundancy. While the warning about contract periods is useful, the duplication wastes space and undermines conciseness.

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

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

Given the tool has 4 parameters, no output schema, and only minimal annotation coverage, the description is inadequate. It lacks parameter explanations, details about cancellation behavior, and any consequences beyond the contract warning. This is a destructive operation that requires more thorough disclosure.

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

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

The schema has 0% description coverage, and the description does not compensate by explaining any of the four parameters. It fails to mention objectStorageId, x-request-id, or the cancelDate body field, leaving agents without essential guidance on how to construct a valid request.

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 ('Cancels'), the resource ('object storage'), and a specific condition ('at the next possible date'), effectively distinguishing it from sibling tools like cancelInstance or updateObjectStorage. The verb and resource 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?

There is no guidance on when to use this tool versus alternatives such as cancelInstance or updateObjectStorage. The warning about contract periods is a cautionary note, not a usage directive. No exclusions or alternative tool references are provided.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, but the description adds no behavioral context. For a destructive action, it does not disclose potential consequences, irreversibility, or any side effects of confirming a transfer out.

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 repetitive, saying the same phrase twice separated by a dash. This is not concise; it is padded and provides no structural benefit. It is under-specified rather than efficiently written.

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 minimal annotations, the description should explain the domain transfer flow, what confirming entails, and how it relates to siblings. It does none of this, leaving a significant gap in operational understanding.

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

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

Schema description coverage is 0% and the description provides zero detail about the parameters (domain, x-request-id, x-trace-id). The agent gets no help understanding what 'domain' should be or what the required UUID x-request-id represents.

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 restates the title exactly ('Confirm transfer out for a domain') without adding any new information. It does clearly state the action, but it fails to distinguish this tool from closely related siblings like revokeDomainTransferOut, making the purpose ambiguous in context.

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

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

There is no guidance on when to use this tool versus the many sibling tools (e.g., revokeDomainTransferOut, getAuthCode). It also lacks any context about the domain transfer workflow or prerequisites, leaving the agent with no decision support.

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 the operation is destructive and not read-only. The description adds useful context by explaining that the assignment may restrict access to the resource, which is not apparent from annotations alone. However, it does not disclose potential side effects like idempotency, duplicate handling, or whether existing assignments are overwritten.

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, but the first sentence is essentially a restatement of the title, and the second sentence is slightly wordy. It could be compressed into one concise sentence without losing key 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 creation tool with 5 parameters, no output schema, and minimal behavioral annotations, the description leaves significant gaps. It does not mention what the response contains, what happens if the resource already has the tag, or any prerequisites. The access-restriction note is helpful but insufficient for a full understanding.

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?

With 0% schema description coverage, the description must compensate for undocumented parameters. It only vaguely refers to 'the specified resource' and 'the specified tag' without mapping to actual parameters (tagId, resourceId, resourceType, etc.). No details are given about allowed values, formats, or the meaning of resourceType, leaving the agent to guess.

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 that the tool creates a new tag assignment, marking a resource with a tag for organizing or access restriction purposes. This distinguishes it from sibling tools like createTag (which creates the tag itself) and deleteAssignment. However, the opening phrase is a near-verbatim repeat of the title, adding minor redundancy.

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 attach a tag to a resource, but it provides no explicit guidance on when to use it versus other assignment tools (e.g., assignIp, assignInstancePrivateNetwork) or any prerequisites such as the tag and resource needing to exist. No alternatives or exclusions are mentioned.

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

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

Annotations indicate a non-read-only, destructive operation; the description adds valuable behavioral details: format restrictions, rejection of other formats, asynchronous download with status check via GET, and quota-based rejection. This goes beyond the annotations but does not address all potential side effects.

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

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

The description is three sentences long, front-loaded with the core action, and every sentence contributes (format constraint, timing, status check, limits). It is slightly verbose but not wasteful.

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

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

Given no output schema and a nested body parameter, the description covers the key user-facing concerns: required URL, supported formats, potential delays, monitoring via GET, and quota limits. It does not specify the response shape but implies the created resource can be retrieved.

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

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

The schema provides descriptions for all parameters, so the baseline is 3. The description adds crucial semantics for the 'url' parameter by specifying direct download URL and format constraints. It does not add meaning for name, osType, or version, but schema descriptions cover them sufficiently.

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

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

The description clearly states the tool's purpose: 'Provide a custom image' and explains the mechanism (URL download). It differentiates from siblings like createInstance or createSnapshot by focusing on custom image creation from an external URL. However, it does not explicitly contrast with sibling tools.

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

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

The description provides clear procedural context: specify URL, accept .iso/.qcow2, and be aware of download time and limits. It does not explicitly state when to use this tool versus alternatives, and there are no exclusions or alternative tool references.

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 destructiveHint=true, so the description adds no additional behavioral context. It does not disclose the effects of creating a zone, any validation rules, or what happens to existing resources. The phrase 'for a customer' is too vague to provide meaningful transparency 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 very short but contains redundancy: 'Create DNS zone' repeats the title, and 'for a customer' adds little value. It is not overly verbose, but it wastes the opportunity to add essential context in its limited space.

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

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

The description is too sparse for a tool with a nested request body and no output schema. It omits details like valid zone naming conventions, whether the zone is created empty or with default records, and what the response contains. Given the complexity of the schema and lack of output schema, the description is inadequate for reliable invocation.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining any parameters. It offers no insight into the required createDnsZoneBody or the zoneName format, forcing the agent to rely on the schema alone, which is minimal. The only hint is the word 'zone' in the description, which is already evident.

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

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

The description clearly states the action ('Create') and the resource ('a new DNS zone for a customer'), which directly aligns with the tool name and distinguishes it from siblings like createDnsZoneRecord. The verb and resource are specific and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, such as needing a customer or domain, nor any comparison to related tools like createDnsZoneRecord or deleteDnsZone. The agent must infer usage entirely from the name and title.

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

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

The description adds no behavioral context beyond the annotations. It does not disclose idempotency, whether duplicate records are allowed, validation rules, or potential side effects, despite having a destructiveHint annotation that only hints at state modification.

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 short sentence with no redundancy, but it is under-specified rather than efficiently concise. It restates the title without adding substantive detail, so it barely meets the conciseness bar.

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?

This is a complex tool with a nested request body, required fields, and type-dependent parameters, yet the description offers no explanation of record types, field requirements, or return behavior. With no output schema, the agent is left without essential context, making the description almost useless 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 0%, and the tool description itself explains none of the four parameters or the nested body structure. The meaning of fields like type, ttl, prio, and data, and their interdependencies, remains completely undocumented.

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

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

The description clearly states the tool creates a resource record in a DNS zone, using a specific verb and resource. It does not, however, explicitly differentiate itself from similar sibling tools like updateDnsZoneRecord or createPtrRecord, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., an existing zone), nor does it reference update/delete/retrieve counterparts or the separate createPtrRecord tool, leaving the agent without decision-making support.

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 write operation (readOnlyHint=false) with destructive intent (destructiveHint=true), and the description does not contradict them. However, the description adds no behavioral context beyond what the annotations provide, such as side effects, permissions, or idempotency.

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

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

The description is extremely short but this is under-specification, not conciseness. It repeats the title verbatim and contains no structured information, wasting the opportunity to add useful 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?

This tool has a nested body object, multiple required fields, and no output schema, so the description must provide substantial context. It provides none, leaving agents completely uninformed about the purpose or expected behavior.

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

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

The schema description coverage is 0%, so the tool description must compensate for the lack of parameter explanation. The description mentions no parameters at all, leaving the agent with no additional meaning beyond the raw schema field names and generic property descriptions.

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

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

The description 'Create specific handle - Create specific handle' is a direct repetition of the title and provides no additional specificity. It does not explain what a handle is, what 'specific' means, or how it differs from sibling create tools like createUser or createDnsZone.

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

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

No guidance is given on when to use this tool versus alternatives. The description lacks any mention of use cases, prerequisites, or exclusions, and does not reference any 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?

Annotations already provide readOnlyHint=false and destructiveHint=true, so the agent knows it is a state-changing operation. The description adds no additional behavioral details about side effects, asynchronous provisioning, or cost implications. The product table is useful for parameter selection but not for behavioral transparency.

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

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

The opening sentence repeats 'Create a new instance' from the title, creating redundancy. The large HTML table is information-dense but makes the description verbose. Structure could be improved by front-loading the key purpose and placing the table separately.

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 multi-parameter creation tool with no output schema, the description should explain return values, provisioning status, and cost implications. It only provides product selection details. The lack of usage guidelines and behavioral disclosure leaves significant gaps.

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

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

The schema covers many parameters with descriptions (e.g., period, region, sshKeys), but the description adds significant value by mapping productId values to product names and disk sizes via the table. This is critical because the schema's productId description only mentions the default value. However, the description does not cover other parameters that lack schema context.

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

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

The description clearly states 'Create a new instance for your account with the provided parameters,' which identifies the action and resource. It distinguishes from sibling create tools like createCustomImage or createSnapshot by specifically mentioning 'instance.' However, the title already says this, and the description could be more explicit about provisioning a compute instance.

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

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

No guidance is given about when to use this tool versus alternatives like upgradeInstance, reinstallInstance, or patchInstance. There is no mention of prerequisites such as account verification or billing setup.

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

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

Annotations already indicate a write/destructive operation (readOnlyHint=false, destructiveHint=true). The description adds useful behavioral context beyond annotations: the one-per-location purchase limit and the ability to resize via a POST endpoint. This clarifies constraints and follow-up actions, which is valuable behavioral disclosure.

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

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

The description is two sentences, front-loaded with the primary purpose, followed by a critical constraint and resizing alternative. Every sentence earns its place; there is no fluff or repetition.

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

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

The description covers the key limitation (one per location) and the resize path, but it omits other context such as required parameters, costing, permissions, or response format. Given the nested object schema and absence of output schema, more details could be expected, but the essential creation intent is clear.

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

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

The description provides zero information about parameters (region, totalPurchasedSpaceTB, autoScaling, displayName). Schema description coverage is 0% for top-level parameters, so the description must compensate but does not. Even though nested schema fields have descriptions, the tool description adds no semantics, leaving agents to inspect the schema for details.

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

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

The description states a specific action ('Create / purchase a new object storage in your account') with a clear resource (object storage). It distinguishes from sibling tools like updateObjectStorage or CancelObjectStorage by focusing on creation/purchase. The verb and resource are explicit.

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

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

The description provides context on when to use the tool (to create/purchase object storage) and implicitly when not to (not for resizing), explicitly pointing to the resize endpoint for increasing space. It also notes a per-location limit, which guides usage decisions. It doesn't explicitly exclude alternatives but offers a clear path for scaling.

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 indicate a non-read-only, potentially destructive operation. The description adds no behavioral context beyond 'in your account', omitting details about side effects, prerequisites, invocation patterns, or regional requirements that would be useful beyond the structured annotations.

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

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

The description is repetitive, saying essentially the same thing twice: 'Create a new Private Network - Create a new Private Network in your account.' It could be condensed to a single non-redundant sentence, so it is under-specified rather than genuinely concise.

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

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

Given the moderate complexity (nested body object, required headers) and the lack of output schema, the description is notably incomplete. It provides no information about request/response behavior, required fields, regional defaults, or potential side effects, making it insufficient for reliable invocation without additional investigation.

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 reported as 0%, and the tool description does not mention any parameter names, types, or requirements. The description fails to compensate for the low schema coverage, leaving parameters like x-request-id, name, region, and description entirely unexplained outside the schema.

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

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

The description states the verb 'Create' and the resource 'Private Network', making the primary purpose clear. However, it is largely a restatement of the tool name and title, and it does not distinguish from sibling tools like patchPrivateNetwork or deletePrivateNetwork.

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

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

There is no guidance on when to use this tool versus alternatives such as patchPrivateNetwork or assignInstancePrivateNetwork. The description provides no usage context, prerequisites, or exclusions, leaving the agent without direction for tool selection.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the mutating nature is disclosed. The description adds the specific constraint that only IPv6 is supported, which is useful behavioral context. However, it does not mention potential side effects, duplicate handling, or required permissions beyond what annotations imply.

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

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

The description is redundant, repeating the same sentence twice: 'Create a new PTR Record using ip address - Create a new PTR Record using ip address.' This wastes words without adding information. It is short but not concise in the sense of every sentence earning its place.

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

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

The tool has no output schema, and the description does not explain what the response looks like or any error handling. For a create operation, it should at least indicate what is returned or that the operation is irreversible. The IPv6 constraint is useful but incomplete for an agent to fully understand the tool's behavior.

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

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

The description adds no parameter meaning beyond the input schema, which already contains descriptions for ip, ptr, and ttl. Schema description coverage is reported as 0%, meaning the description does not compensate for any gaps. The description mentions 'ip address' but nothing about ptr or ttl 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?

The description clearly states the tool creates a PTR record using an IP address, and the resource (PTR record) is specific. It distinguishes itself from sibling tools like createDnsZoneRecord or updatePtrRecord. However, the description repeats the same phrase twice, which slightly detracts from clarity.

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

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

The only usage guidance is the constraint 'Only IPv6 can be created'. There is no explicit guidance on when to use this tool versus alternatives like createDnsZoneRecord or updatePtrRecord, nor any mention of prerequisites or limitations beyond IPv6.

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

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

The annotation destructiveHint=true directly contradicts the description which states this creates a new role, implying a non-destructive creation operation. No additional behavioral context is provided beyond the title and description, so this is an annotation 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 starts with a clear purpose but repeats 'Create a new role' unnecessarily. The additional sentences provide useful hints but are somewhat verbose and could be more concise. Overall, it is reasonably sized but not optimally structured.

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

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

The tool has nested objects and no output schema, so the description should cover behavior and return values, but it does not. It also fails to mention the effects of admin/accessAllResources flags or what happens after creation. The annotation contradiction further reduces completeness.

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

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

With schema description coverage at 0%, the description must compensate for parameter explanations. It does clarify that `resources` should be tag IDs and that apiName/actions come from the GET api-permissions endpoint, but it omits meaningful details about `admin`, `accessAllResources`, and the permissions array structure that are needed for correct invocation.

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 begins with 'Create a new role - Create a new role.' which is a specific verb-object pair that clearly distinguishes it from sibling tools like updateRole and deleteRole. The repetition is redundant but does not obscure the purpose.

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 contextual usage guidance for permissions and resources, such as referring to the GET api-permissions endpoint and assigning tags via the tag management API. However, it does not explicitly state when to use this tool versus alternatives like updateRole, nor does it mention any exclusions.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=true, meaning it is a write operation. The description adds no behavioral context beyond this, such as uniqueness constraints, overwrite behavior, or permission requirements.

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

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

The description is brief but redundant, repeating 'Create a new secret' after the dash, which duplicates the title. It contains unnecessary repetition and could be more streamlined.

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

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

There is no output schema, and the description does not mention response behavior, prerequisites, or value validation requirements. Given the tool's nested body and complex password pattern, the description is incomplete.

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

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

Schema description coverage is 0% per context signals, and the description only lists parameter names without explaining their semantics. The statement 'Attribute type can be password or ssh' merely repeats the schema enum and does not aid in constructing valid values.

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

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

The description clearly states the action (create) and resource (secret), listing the attributes name, type, and value. It distinguishes from updateSecret by using 'create' as the verb, though it does not explicitly reference alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives such as updateSecret, deleteSecret, or generateClientSecret. It simply describes the operation without context or exclusions.

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

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

Annotations already declare destructiveHint: true and readOnlyHint: false, but the description adds no behavioral context beyond what annotations provide. It does not explain any side effects, permissions required, or why the operation is considered destructive. With zero added context, the transparency is limited.

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 short and the first sentence largely repeats the title, making it slightly redundant. The second sentence adds minimal new information. It is concise but not maximally efficient; every sentence should earn its place, and the repetition does not.

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 nested objects and no output schema, the description is too sparse. It does not explain the request body structure, required fields (name is required per schema), or what the response might be. The schema provides some detail, but the overall context remains incomplete.

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

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

Schema description coverage is 0% for the top-level parameters, and the description only mentions 'name and description attributes' without explaining instanceId, request headers, or the body structure. The nested schema does provide descriptions for name and description, but the tool description does not compensate for the undocumented parameters.

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

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

The description clearly states the tool's purpose: creating a new snapshot for an instance. It uses specific verbs ('create') and identifies the resource (snapshot) and target (instance), distinguishing it from sibling tools like updateSnapshot, deleteSnapshot, or rollbackSnapshot.

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, nor does it mention any prerequisites (e.g., instance must exist) or conditions. It simply states the action without contextual usage clues.

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 minimal behavioral context beyond the annotations. It does not mention permissions, side effects, idempotency, or return behavior. The annotation destructiveHint:true is not addressed or explained, and the description's claim that color is 'optional' conflicts with the schema, creating potential behavioral confusion.

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 redundant, starting with 'Create a new tag - Create a new tag...' and uses awkward phrasing like 'with attribute name.' The sentence wastes words and does not efficiently convey information beyond the title.

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

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

For a creation tool with a nested body and required headers, the description omits critical context: the request ID requirement, the actual body structure, error expectations, and any effect on existing tags. The description is too sparse to support correct invocation without relying on the 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 description calls color 'optional,' but the input schema lists color as required. It also omits the 'description' parameter entirely. The schema's own parameter descriptions are useful, but the tool description actively misleads the agent about required fields, providing negative value.

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

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

The description explicitly states the action ('Create') and the resource ('a new tag'), and clarifies scope ('in your account'). Although it repeats the title, it leaves no ambiguity about the tool's purpose and distinguishes it from sibling tools like updateTag or deleteTag.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., updateTag, deleteTag) and no exclusions or prerequisites. The only contextual hint is 'in your account,' which does not help an agent decide between related tag operations.

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

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

Annotations already indicate this is a non-read-only, destructive operation. The description adds context by stating that no passwords or secrets can be set, which is useful behavioral information. Yet it contains misleading attributes (admin, accessAllResources) not in the schema, and does not mention what happens on success or any side effects beyond creation.

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 repeats 'Create a new user' at the start, and the attribute list is redundant and partially inaccurate. The security note is useful but phrased twice ('You can't specify...' and 'the user will have to specify secrets'). It is not concise and contains waste.

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 the return value or expected response, but it does not. It also omits the required 'locale' parameter from the body and ignores the required x-request-id header. The description is incomplete for a creation tool with these structured requirements.

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

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

The schema description coverage is 0%, and the description fails to mention any of the actual top-level parameters (x-request-id, x-trace-id, createUserBody). Worse, it introduces parameters like 'admin' and 'accessAllResources' that are not present in the schema, and lists 'name' while the schema uses 'firstName' and 'lastName'. This actively misleads rather than clarifies.

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

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

The description clearly states the tool creates a new user with a specific verb and resource, distinguishing it from sibling tools like updateUser and deleteUser. However, it inaccurately lists attributes such as 'name', 'admin', and 'accessAllResources' that do not exist in the schema, which slightly muddies the purpose.

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 tool name and title: use this to create a user. The description adds a constraint that no passwords/secrets can be specified, which helps decide when not to use it. However, it does not explicitly state alternatives or when to use this over other create tools (e.g., createRole, createInstance).

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 signal destructive behavior (destructiveHint=true). The description adds valuable context about the consequence on access restrictions for affected users, which goes beyond the annotation and helps the agent anticipate side effects. No contradiction with annotations.

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

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

The description is compact and front-loaded: the first sentence states the primary action, and the second adds a critical behavioral note. No unnecessary words or repetition.

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

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

For a simple destructive delete, the description is adequate, with the access-impact warning providing key context. However, it lacks details like supported resource types, behavior for non-existent assignments, or error conditions. No output schema exists, so more completeness would be beneficial.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'specified resource' but does not explain the roles of tagId, resourceType, or resourceId, nor any constrained values. The parameter names are somewhat self-explanatory, but the description does not provide the needed clarity for correct invocation.

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 (delete) and the resource (tag assignment). It also differentiates from sibling tools like deleteTag by specifying 'tag assignment' removal from a resource. The first sentence is precise and unambiguous.

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

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

The description implies when to use the tool (when removing a tag assignment from a resource) but does not explicitly state alternatives or when not to use it. Given many similar sibling tools (e.g., unassignIp, deleteTag), more explicit guidance would improve clarity, but the description is not misleading.

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 destructiveHint annotation already signals the destructive nature, but the description does not add any further behavioral context such as irreversibility, impact on associated records, or idempotency. It merely restates the use of zone name, which adds no transparency beyond the annotation.

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 short, but the second sentence ('Delete a DNS Zone using zone name') largely repeats the first, making it redundant. A single sentence would be equally informative without the repetition.

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

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

For a destructive tool with no output schema and minimal parameter documentation, the description is insufficient. It does not state that deleting a zone may cascade to all records, whether the operation is reversible, or what response status to expect. The lack of context on these aspects leaves the agent under-informed.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meaning. The only mention is 'using zone name,' which is merely a restatement of the parameter name and does not clarify its format (e.g., FQDN vs. simple name) or purpose. The required x-request-id and optional x-trace-id are not explained at all.

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 (Delete) and the resource (DNS zone) in the first clause. It also distinguishes from sibling tools like deleteDnsZoneRecord by specifying 'DNS Zone' rather than a record, making the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives such as deleteDnsZoneRecord or bulkDeleteDnsZoneRecords. It lacks any context about prerequisites or situations where deletion should be performed.

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, so the destructive nature is known. The description adds no extra behavioral context such as irreversibility or cascading effects, but it does not contradict the annotations. Minimal additional value is provided.

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

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

The description is short but redundant, repeating the same idea twice with the second phrase containing a typo. It is not efficiently structured and wastes the space with an unclear paraphrase.

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?

This is a destructive tool with no output schema, no parameter descriptions, and no usage context. The description fails to mention what identifiers are needed, what the consequences are, or how it differs from related delete operations. It is severely under-specified.

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 0%, and the description provides no explanation of the required parameters (recordId, zoneName, x-request-id). The agent is left without any semantic grounding for how to invoke the tool correctly.

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

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

The description states a clear action (Delete) and resource (DNS zone record), which is specific. It is essentially a restatement of the title, but it does distinguish from deleting a whole zone or a bulk operation. The typo 'DNZ' slightly detracts but does not obscure meaning.

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

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

No guidance is provided on when to use this tool versus alternatives such as bulkDeleteDnsZoneRecords or updateDnsZoneRecord. It simply repeats the function without indicating context, prerequisites, or exclusions.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds the nuance that only 'previously uploaded custom images' are eligible, implying a scoping constraint. However, it does not disclose permanence or side effects beyond what the destructive hint implies, so it adds moderate value.

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

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

The core purpose is in the first clause, and the second clause adds a short usage note. While there is a minor grammatical error ('Your are'), it remains concise and front-loaded with the essential meaning.

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

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

For a simple delete operation without output schema, the description plus annotations provide a reasonable understanding. However, the lack of parameter explanations for required headers and absence of any edge-case context (e.g., failure behavior, idempotency) leaves gaps for an agent fully invoking the tool.

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

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

The description mentions 'by its id' only, which maps to imageId. With schema description coverage at 0%, it fails to explain the required x-request-id header or the optional x-trace-id. These parameters are structurally present but their semantics are left entirely to the schema, making the description insufficient.

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 'Delete an uploaded custom image by its id' with a specific verb and resource, distinguishing it from sibling tools like createCustomImage, updateImage, and retrieveImage. The scope is unambiguous and matches the tool name and title.

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 adds 'You are free to delete a previously uploaded custom images at any time', explicitly indicating that this tool is for removing previously uploaded custom images without time restrictions. It does not explicitly name alternatives, but the purpose is clear enough to know when to use it unlike related 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 annotations already declare destructiveHint=true and readOnlyHint=false, which signals a destructive operation. The description adds a valuable behavioral detail beyond the annotations: that all instances are automatically unassigned upon deletion. This explains a key consequence that the annotations do not specify, enhancing transparency. It does not mention other potential effects like irreversibility or associated resource cleanup, but the annotation coverage lowers 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?

The description is two sentences but contains redundancy: 'Delete existing Private Network by id' is repeated as 'Delete existing Virtual Private Cloud by id' in the same description. This could be condensed into one clear sentence. While it is relatively short, the repetition wastes an opportunity for additional 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 delete operation with no output schema, the description mentions the critical side effect (auto-unassignment of instances), which is essential. However, it omits other potentially relevant context such as whether the operation is permanent, any permission requirements, or the shape of the response. Given the tool's simplicity and the presence of annotations, the description is adequate but not comprehensive.

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 0% description coverage for its three parameters, so the description must compensate. It only reinforces that deletion is 'by id', implicitly referring to privateNetworkId, but does not explain the purpose of x-request-id or x-trace-id, nor does it clarify formatting or requiredness beyond the schema. This is insufficient for filling the schema's descriptive gap.

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: 'Delete existing Private Network by id', with a specific verb (delete), resource (Private Network/Virtual Private Cloud), and scope (by id). It also distinguishes this tool from siblings like patchPrivateNetwork and unassignInstancePrivateNetwork by noting the automatic unassignment of instances, which is a unique consequence not present in 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 clear context for when to use this tool: when deleting a private network, and it implicitly communicates that prior unassignment of instances is unnecessary because the tool 'automatically unassign[s] all instances from it'. This informs the agent not to call unassignInstancePrivateNetwork separately. However, it does not explicitly name alternatives or exclusions, 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?

Annotations already indicate destructive behavior (destructiveHint=true), and the description adds the useful constraint 'Only IPv6 can be deleted.' No other behavioral details are disclosed, but the annotation coverage lowers the burden.

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

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

The description is repetitive, repeating 'Delete a PTR Record using ip address' verbatim before and after the dash. This redundancy wastes words, although the additional 'Only IPv6 can be deleted' is concise and valuable.

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

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

The tool has 3 parameters and no output schema, yet the description provides minimal context. It does not explain the purpose of the required request ID header, error scenarios, or the outcome of a successful deletion, making it incomplete for an agent to use correctly.

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

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

Schema coverage is 0%, and the description only references the ipAddress parameter ('using ip address'). The required x-request-id and optional x-trace-id parameters are not explained, and the description does not compensate for the lack of schema descriptions.

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

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

The description clearly states the action: delete a PTR Record using an IP address. It distinguishes from sibling tools like createPtrRecord and updatePtrRecord by using the specific verb 'delete' and adding the constraint 'Only IPv6 can be 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?

The description implies usage for deleting IPv6 PTR records, but does not explicitly mention when to use this tool versus alternatives (e.g., updatePtrRecord for modifications). The IPv6-only constraint is a clear limitation, but no alternative is suggested for IPv4 records.

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 (destructiveHint=true), and the description adds a meaningful behavioral limitation (role must not be assigned) beyond what annotations provide. It does not contradict annotations and covers an important precondition.

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

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

Two short sentences, front-loaded with the primary action, followed by a critical constraint. Every word earns its place; no waste.

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

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

For a simple delete operation, the description covers the essential action and the main failure mode. It lacks response/error details, but with no output schema and a destructive annotation, it is reasonably complete for the tool's simplicity.

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

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

With 0% schema description coverage, the description must explain parameters, but it only says 'by id.' The roleId parameter's purpose is inferable from the tool name, but the required x-request-id and optional x-trace-id are not explained at all, leaving the agent to guess their roles.

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

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

The description clearly states the tool's function: 'Delete existing role by id' – a specific verb and resource that immediately distinguishes it from sibling tools like createRole, updateRole, and retrieveRole. No ambiguity.

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

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

The description provides a key usage constraint: a role cannot be deleted while assigned to a user, and advises removing it from users first. This gives clear situational context, though it does not explicitly name alternative tools for unassignment.

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 agent knows this is a destructive operation. The description adds minimal extra context ('from your account') but does not disclose additional consequences such as irreversibility or impact on dependent resources. This aligns with the expected baseline given annotation coverage.

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

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

The description is a single, concise sentence that front-loads the core action and resource. It contains no redundant information and every word adds value.

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

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

Given the simple nature of the operation, the description plus annotations provide a basic understanding. However, it does not mention prerequisites, side effects, or any additional behavior beyond the destructive action, leaving gaps for the agent about what happens when the secret is deleted or whether other resources are affected.

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

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

The schema has 0% description coverage, so the description must compensate. It only mentions 'by id' which maps to secretId, but provides no further explanation of the secretId format or the purpose of the required x-request-id or optional x-trace-id parameters. This is insufficient to guide the agent on how to fill the parameters correctly.

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

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

The description clearly states the tool's purpose with a specific verb ('delete') and resource ('secret'), and explicitly identifies the key parameter ('by id'). It distinguishes itself from sibling tools like createSecret and updateSecret by focusing on removal of an existing secret.

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

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

The description provides clear context for when to use this tool: to remove a specific secret from the account. It does not explicitly mention alternative tools or exclusion criteria, but the purpose is unambiguous given the tool name and sibling context.

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

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

The annotations already indicate destructiveHint=true and readOnlyHint=false, aligning with the 'Delete' description. The description adds minimal behavioral context, merely specifying the resource type (instance snapshot) but not disclosing irreversibility, permission requirements, or side effects. Since annotations cover the destructive nature, a score of 3 is appropriate.

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

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

The description is redundant, repeating the same statement twice separated by a dash. It could be shortened to a single clause. The phrasing is not efficiently structured and does not earn its place, as the second half adds no new 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 destructive operation with multiple required parameters and no output schema, the description is severely incomplete. It does not explain the implications of deleting a snapshot, whether the instance must be stopped, or what happens to dependent resources. The sparse description fails to provide necessary operational context for a high-risk action.

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?

With 0% schema description coverage, the description must compensate by explaining the parameters, but it only mentions 'by id' without clarifying which parameter is which. The input schema lacks descriptions for instanceId, snapshotId, x-request-id, and x-trace-id, and the tool description does nothing to bridge this gap, leaving the agent guessing about required identifiers and headers.

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 specific verb 'Delete' and the resource 'existing snapshot by id', and further clarifies it is an 'instance snapshot by id'. This clearly distinguishes it from sibling tools like retrieveSnapshot, rollbackSnapshot, and updateSnapshot, which serve different operations.

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

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

The description provides no guidance on when to use this tool versus alternatives such as rollbackSnapshot or updateSnapshot. It does not mention prerequisites, conditions for deletion, or cases where deletion is inappropriate, leaving the agent without clear 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 indicate destructiveHint=true, so mutation is expected. The description adds valuable behavioral context: deletion is contingent on the tag not being assigned to any resource, and it warns to check assignments first. This goes beyond the annotation by explaining the condition for success, though it doesn't specify the exact outcome if the tag is assigned or the response format.

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

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

The description is extremely concise: two short sentences that front-load the primary action and then add the key precondition. Every word earns its place, with no fluff or repetition of schema details.

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

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

For a simple delete operation with no output schema, the description covers the essential precondition (must be unassigned) and a recommended pre-check. However, it does not explain what happens after a successful deletion (e.g., response format, permanent removal), nor does it describe error cases or the purpose of the required request ID headers. It is adequate but leaves some gaps.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meanings. It only clarifies that deletion is 'by id', which maps to tagId, but it does not explain the required x-request-id or optional x-trace-id parameters. These could be standard headers, but the description does not mention them, leaving them under-specified given the complete lack of schema descriptions.

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

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

The description states 'Delete existing tag by id' which clearly identifies the action (delete) and resource (tag) and distinguishes it from sibling tools like createTag, updateTag, and retrieveTag. The method of identification (by id) is also explicit, leaving no ambiguity about the tool's purpose.

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

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

The description provides a clear precondition: 'Your tag can be deleted if it is not assigned to any resource on your account.' It also advises checking tag assignments before deleting. This offers practical guidance on when deletion is allowed, though it does not explicitly mention alternatives or when to use other tag operations. The guidance is sufficient for safe usage.

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

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

Annotations already mark this as destructive (destructiveHint=true) and not read-only. The description adds meaningful context by stating the consequence: the user will no longer access endpoints or resources. It also provides the alternative update behavior, going beyond the annotation flags.

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

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

The description is two sentences, front-loaded with the primary purpose, and every sentence adds value. The second sentence provides essential usage guidance without wordiness.

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 action, the description covers the main consequence and the alternative, which is sufficient given the annotations and simple schema. It could mention permanence more explicitly, but 'any longer' implies irreversibility. Overall it's complete for an agent to decide.

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

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

The schema description coverage is 0% and the description does not explain the parameters. It only says 'by id' without naming the 'userId' parameter or clarifying the required 'x-request-id'. It fails to compensate for the lack of parameter information.

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

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

The description clearly states the action 'Delete existing user by id', which is specific and distinguishes it from sibling tools like updateUser, retrieveUser, or createUser. The verb 'delete' and resource 'user' 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 explicitly provides an alternative for temporary disablement: 'In order to temporarily disable a user please update its `enabled` attribute.' This gives clear guidance on when not to use the delete tool and directs to the appropriate action.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the agent knows it is a mutating operation. However, the description adds no extra context such as whether existing secrets are invalidated, required permissions, or what the response contains. The 'get' part implies a returned secret, but that is not elaborated.

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

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

The description is extremely short, but it is under-specified rather than concise. It repeats the title and adds only 'get', which does not earn its place. There is no useful information, so the brevity is a deficiency.

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 and 0% parameter documentation, the description is grossly incomplete. It does not explain the purpose, behavior, prerequisites, or return value. The tool's place among many secret-related siblings is not clarified, leaving the agent with insufficient 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 input schema has two parameters (x-trace-id, x-request-id) with 0% description coverage in the schema. The description does not mention these parameters at all, leaving the agent to guess their purpose or whether they are headers or payload fields. This is a complete failure to compensate for the schema gap.

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 action (generate) and resource (client secret), but it essentially rephrases the title without adding clarifying detail. It does not distinguish this from sibling tools like createSecret or regenerateObjectStorageCredentials, nor does it explain what a client secret is or its scope.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, typical scenarios, or why one would choose this over other secret-related tools. No exclusions or alternative references are given.

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

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

The annotations declare destructiveHint=true and readOnlyHint=false, but the description adds no context about side effects, such as whether obtaining the code invalidates existing codes or requires domain transfer eligibility. It does not contradict the annotations, but it also provides no additional behavioral information.

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 short but redundant, repeating the title twice. The two phrases convey nearly identical information, and the structure is not front-loaded with distinguishing details. It could be tighter and more informative in a single 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 destructive hint and absence of an output schema, the description is incomplete. It doesn't state what the auth code is used for, how to identify the domain (by name or ID), or any prerequisites. The tool is more complex than the description suggests.

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

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

Schema description coverage is 0%, and the description does not explain any parameters. The mention of 'by id' is insufficient; the 'domain' parameter could be an ID or name, and the required headers (x-request-id) are entirely unexplained.

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 tool retrieves an auth code for a domain, which is a specific verb+resource. However, the phrase 'by id' is ambiguous because the parameter is named 'domain' rather than 'domain_id', and the description is repetitive, restating the title without adding clarity.

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

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

No guidance is provided on when to use this tool versus alternatives. Among siblings there are other domain-related operations (e.g., retrieveDomain, cancelDomain) but no mention of when an auth code is needed, prerequisites, or exclusions.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, which covers the safety profile. The description adds minimal behavioral context (that credentials are for S3 tool access) but does not disclose potential response contents, sensitivity of data, or any other behavioral traits beyond what annotations state.

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

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

The description is repetitive: the first sentence nearly duplicates the title, and the second sentence adds only slight context. It is under-specified rather than concise, wasting the first sentence on redundancy without providing meaningful structure.

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 five parameters, no output schema, and zero parameter documentation, the description is inadequate. It provides no information about request structure, expected response format, or how credentials are scoped to the object storage, making the tool difficult to invoke 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 0% and the description does not explain any of the five parameters (userId, objectStorageId, credentialId, x-request-id, x-trace-id). The description fails to compensate for the schema gap, leaving the agent to infer parameter semantics solely from names.

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

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

The description clearly states the tool retrieves S3-compatible object storage credentials, with a specific verb and resource. However, it does not distinguish itself from sibling tools like listObjectStorageCredentials or regenerateObjectStorageCredentials, so it lacks sibling 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 phrase 'for accessing it via S3 compatible tools like aws cli' implies a use case, but there is no explicit guidance on when to choose this tool over alternatives like list or regenerate credentials. No exclusions or alternative suggestions are provided.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the notion of filtering but not specific behavioral details such as pagination, sorting, or return format. Consistent with annotations, no contradiction.

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

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

The description is only one sentence but redundantly states 'List all domains' and 'List and filter all your domains', covering the same idea twice. It could be condensed to a single non-repetitive sentence without losing meaning.

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 8 parameters, one enum, no output schema, and zero description coverage, the description is far from complete. It does not mention response structure, pagination behavior, filtering fields, or any requirements like the x-request-id header, leaving the agent under-informed for effective invocation.

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

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

Schema description coverage is 0%, and the description does not explain any of the 8 parameters (sld, tld, page, size, status, orderBy, x-trace-id, x-request-id). Agents have no guidance on how to construct filters or pagination parameters, making this a critical gap.

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

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

The description clearly states the tool lists and filters domains, using the verb 'List' and resource 'domains'. The scope 'all your domains' implies a collection-level operation, distinguishing it from single-domain tools like retrieveDomain, though not explicitly naming a sibling.

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 that this is the tool for listing/filtering domains, but provides no explicit guidance on when to use it versus alternatives like retrieveDomain or validateDomainAvailability. The usage context is implied by the tool's name and purpose but not elaborated.

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 destructiveHint=false, lowering the bar. The description adds that it lists the user's own handles and supports filtering, but omits details like pagination, required request ID, or default behavior.

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

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

The description is short but repetitive: 'List all handles' duplicates the title and the second clause reiterates the same idea. It is concise in length but not in wording, lacking structural clarity.

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

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

For a list endpoint with 12 parameters and no output schema, the description does not explain pagination, return format, required headers, or how filters combine. This is insufficient 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?

With 0% schema parameter coverage, the description must compensate but only says 'filter', implying some parameters are filters without explaining specific ones. It does not clarify orderBy, page, size, search, or showDefaults 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?

The description states the tool lists and filters handles, using a clear verb and resource. It distinguishes from retrieveHandle (singular) and mutation tools, but is somewhat redundant with the title.

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

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

No guidance is given on when to use this tool versus alternatives like retrieveHandle or setDefaultHandle. The description does not mention exclusions or provide context for selecting this over 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds minimal context beyond that, only mentioning the S3-compatible tool access, but does not disclose pagination, filtering, or return behavior.

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

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

The description is redundant, repeating 'Get list of S3 compatible object storage credentials for user' nearly verbatim in both sentences. It could be condensed into one concise sentence without losing meaning.

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

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

Given the tool has 9 parameters, no output schema, and zero parameter descriptions, the description is far from complete. It does not mention pagination, filter behavior, response format, or how to interpret the results, making it inadequate for an agent to invoke 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 0%, and the description does not explain any of the 9 parameters (e.g., page, size, orderBy, regionName). The phrase 'for user' adds no parameter insight, leaving the agent without guidance on required inputs like userId or optional filters.

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

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

The description clearly states the tool gets a list of S3-compatible object storage credentials for a user, with a specific use case of accessing via S3 tools like aws cli. However, it does not differentiate from the sibling tool getObjectStorageCredentials, which likely retrieves a single credential.

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 a use case (accessing storage via S3-compatible tools) but gives no explicit guidance on when to use this tool versus alternatives like getObjectStorageCredentials, nor any exclusions or prerequisites.

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

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

Annotations declare readOnlyHint=false and destructiveHint=true, but the description adds no additional behavioral context. It does not elaborate on consequences, required ownership, or the transfer process, so the description fails to provide 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 extremely short but under-specified, repeating the title without adding information. This is not effective conciseness; it's a placeholder.

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

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

The tool has a nested object schema with required properties, yet the description provides no context about domain creation vs. transfer, auth code requirements, or what the response contains. It is completely inadequate for an agent to 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 description does not mention any parameters. With schema description coverage reported at 0%, the description offers no compensation, leaving agents to infer parameter meaning solely from the schema (which does have some descriptions, but the tool description itself is mute).

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 is a verbatim repetition of the title ('Create or transfer a domain'), making it a tautology. It states the action but provides no differentiation from related tools like updateDomain or confirmDomainTransferOut.

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 usage guidance is provided. The description does not specify when to use this tool versus createInstance, transfer alternatives, or any prerequisites such as handles or auth codes.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, and the description merely repeats that it updates, adding no additional behavioral context such as side effects, scope of changes, or required permissions. It does not contradict annotations, but also provides no extra transparency.

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

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

The description is two sentences that are nearly identical; the first sentence is redundant with the title, and the second repeats it with 'by instanceId'. This wastes the reader's attention without adding substantive 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?

Given that there is no output schema and the tool has a nested body parameter, the description is far too sparse. It does not define the update semantics (partial vs full), the effect on the instance, or distinguish it from other update tools. An AI agent would have to guess at the body format and usage.

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

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

Schema description coverage is 0%, and the description only references instanceId ('by instanceId'), ignoring patchInstanceBody, x-request-id, and x-trace-id. It fails to explain what fields can be patched (e.g., displayName) or the purpose of the headers.

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 restates the title verbatim ('Update specific instance') and only adds 'by instanceId', which is already evident from the schema. It does not clarify which fields are updatable or differentiate it from sibling tools like upgradeInstance or updateImage. This is a tautology.

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 usage guidance is provided. The description does not mention when to use this tool versus other instance-related operations (e.g., upgradeInstance, reinstallInstance), nor any prerequisites or exclusions.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, which the description aligns with but adds almost nothing beyond 'in your account'. It does not disclose what fields will be updated, whether changes are reversible, or any side effects, so the behavioral coverage is minimal.

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

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

The description is short but redundant: 'Update a Private Network by id - Update a Private Network by id in your account' repeats the same content in two clauses. This is under-specification rather than concise writing; every sentence should add value, and the second part adds negligible value.

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

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

For a mutation tool with no output schema and two body parameters (name, description), the description is critically incomplete. It fails to state the update behavior, effect on existing fields, required header parameters, or any return value expectations. The tool's complexity is not addressed at all.

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

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

Schema description coverage is 0%, and the description provides zero parameter detail. It does not mention that privateNetworkId identifies the target, that patchPrivateNetworkBody contains updatable fields like name and description, or that x-request-id is required. The schema's inline descriptions for body properties are not enough to compensate for the complete lack of parameter explanation in the description.

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

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

The description clearly states the action ('Update') and the resource ('a Private Network by id'), making the tool's purpose unambiguous. However, it does not distinguish this from sibling tools like createPrivateNetwork or deletePrivateNetwork beyond the implied update semantics, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites (e.g., existing private network), and no exclusions. The description simply repeats the tool's name and title, offering no contextual decision-making support.

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 destructiveHint annotation signals that this operation is destructive, but the description adds no behavioral context such as invalidating the existing secret key, potential impact on integrations, or required permissions. It fails to disclose consequences beyond what the annotation already implies.

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 short but poorly structured, containing two sentences where the second is a typo-laden restatement of the first ('the a specific'). It is repetitive and lacks a helpful structure, failing to earn 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 destructive operation with five parameters, no output schema, and no parameter descriptions, the description is severely underspecified. It provides no context about expected inputs, return values, or side effects, making it inadequate for an agent to invoke 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 schema has 0% parameter description coverage, and the description does not compensate. It vaguely references a 'specified user' and 'specific S3 object storages' but provides no meaning or format for required parameters like x-request-id, credentialId, or objectStorageId. This is a significant gap.

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 (regenerate secret key) and resource (S3-compatible object storage for a user), but it is essentially a verbatim restatement of the title and does not distinguish this tool from siblings like generateClientSecret or getObjectStorageCredentials. The purpose is clear but no new information is added.

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

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

There is no guidance on when to use this tool, what prerequisites exist, or which alternative tools should be considered. The description only restates the action and does not mention scenarios, exclusions, or related commands.

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 the description doesn't contradict this. It adds some context about optional ssh keys, root password, and cloud-init, but doesn't disclose additional behavioral traits such as data loss, instance state requirements, or post-reinstall effects.

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

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

The description is a single concise sentence that front-loads the core purpose and then lists optional parameters. No extraneous information or repetition of schema details.

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 annotations indicating destructiveness and a nested body schema, the description covers the primary action and optional parameters. However, it lacks details about what happens to existing data, the instance state, or the response format, which would be helpful given the lack of an output schema.

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

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

The description mentions 'ssh keys, a root password or cloud-init', which aligns with sshKeys, rootPassword, and userData in the schema. However, it doesn't clarify that instanceId targets the specific instance or mention defaultUser/applicationId. The schema does include descriptions for nested properties, so the description adds marginal clarity but doesn't fully compensate for the 0% top-level schema coverage.

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

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

The description clearly states the tool's function: 'Reinstall specific instance' with a new image and optional customization. It uses a specific verb ('reinstall') and resource ('specific instance'), distinguishing it from siblings like createInstance or upgradeInstance.

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

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

The description provides clear context for when to use the tool: to reinstall an existing instance with a new image. It doesn't explicitly name alternatives or exclusions, but the purpose is unambiguous enough that an agent can infer the appropriate scenario.

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 (destructiveHint=true) already indicate the destructive nature, but the description adds no context about effects, reversibility, or side effects. It offers nothing beyond what annotations already disclose, missing opportunities to clarify what 'remove' implies.

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 unnecessarily redundant, repeating the same phrase twice. While it is short, the duplication wastes the limited space and violates the principle that every sentence should earn 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 destructive operation with no output schema, the description should clarify scope, permanence, and any related impacts. It does none of these. The tool appears straightforward, but the description is too minimal to be considered complete for agent decision-making.

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

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

Schema description coverage is 0% and the description does not mention any parameter. The agent gets no guidance on what handleId means or how to provide it, nor are the x-request-id/x-trace-id identifiers explained. This leaves parameter semantics entirely unspecified.

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 is a direct restatement of the title ('Remove specific handle - Remove specific handle'), adding no new information. It is a tautology rather than an explanatory clarification, even though the underlying operation is clear from the phrase.

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 like updateHandle or setDefaultHandle. There is no mention of prerequisites, exclusivity, or situations where another tool might be more appropriate.

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

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

The description adds meaningful behavioral context beyond the annotations: it explains that the rescue system is booted instead of the regular OS, the disk with user data is mounted for repair/modification, and a subsequent reboot restores the normal OS. This aligns with destructiveHint=true and readOnlyHint=false, providing valuable operational details.

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

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

The description is a single focused paragraph that front-loads the purpose and then explains the rescue mode behavior. It is efficient, though it contains minor redundancy and a typo ('sytstem'). Every sentence contributes to understanding, making it appropriately sized.

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

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

The description covers the core concept well but lacks operational specifics for a destructive, nested-object tool. It does not explain what parameters are needed (e.g., SSH keys or root password), prerequisites, or return behavior. Since there is no output schema, these details would help, but the description remains adequate at a high level.

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

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

The description adds almost no parameter-level information. It only says 'identified by its id', hinting at instanceId but not naming it or explaining rescueBody, sshKeys, userData, or rootPassword. With schema description coverage at 0%, the description fails to compensate, leaving agents without clear guidance on required inputs.

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

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

The description clearly states the tool's purpose: 'Rescue a compute instance / resource identified by its id' and explains the rescue mode reboots the instance into a Linux-based system to resolve system issues. This distinguishes it from sibling tools like restart or reinstallInstance by emphasizing the temporary boot into a rescue OS with the disk mounted.

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

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

The description provides clear context for when to use the tool: 'You can reboot your instance in rescue mode to resolve system issues' and mentions it is for advanced users. It does not explicitly name alternatives or state when not to use it, but the context is sufficient for basic usage 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 destructiveHint=true and readOnlyHint=false, but the description adds no behavioral context. It does not explain what happens when the email is resent (e.g., whether previous links are invalidated), any permissions required, or potential side effects.

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

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

The description is repetitive, essentially repeating the title ('Resend email verification - Resend email verification for a specific user'). While short, the redundancy makes it poorly structured and wastes space.

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

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

Given it is a simple tool with no output schema, the description still falls short. It lacks parameter semantics, usage guidance, and behavioral details, making it insufficient for reliable invocation even though the action is straightforward.

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 4 parameters with 0% description coverage, and the description itself mentions none of them. It does not clarify the meaning of userId, redirectUrl, x-request-id, or x-trace-id, leaving the agent to infer or guess.

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 (resend email verification) and specifies the target (a specific user), which is a specific verb+resource combination. However, it is largely redundant with the title and does not distinguish this tool from siblings beyond its unique name.

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 or when to prefer alternatives. There is no mention of prerequisites, conditions, or exclusions.

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

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

The annotations already declare destructiveHint=true, so the description does not need to restate that this is a non-read operation. However, the description adds no additional behavioral context, such as whether sending the email invalidates the current password, requires admin permissions, or is rate-limited. The description merely reiterates the action without enriching the agent's understanding of side effects or prerequisites.

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

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

The description is redundant: 'Send reset password email - Send reset password email for a specific user' repeats the same information twice. While short, the repetition wastes words and does not add value. A concise version would state the action and the target once, without the duplicated title-like phrasing.

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 four parameters, no output schema, and no enums, the description must provide more context about what happens when the tool is invoked. It does not mention the return value, expected side effects, or the purpose of required headers like x-request-id. The description is too sparse to fully inform an agent, especially given the lack of structured schema descriptions.

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

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

Schema description coverage is 0%, meaning all four parameters (userId, redirectUrl, x-trace-id, x-request-id) are undocumented in the schema. The description must compensate but only mentions 'specific user', which does not clarify which parameter holds the user ID or what the other parameters are for. This is a significant gap for a tool with four parameters and no schema descriptions.

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

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

The description clearly states the action 'Send reset password email' and the target 'for a specific user', making it evident what the tool does. However, it does not differentiate this from sibling tools like 'resetPasswordAction' or 'resendEmailVerification', which could be similar in purpose. The verb+resource is specific enough for a 4, but the lack of distinguishing context prevents a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, user roles, or scenarios where this tool is preferred over resetPasswordAction or resendEmailVerification. Without any contextual cues, users are left to infer the appropriate usage.

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

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

The annotations already declare destructiveHint=true and readOnlyHint=false, so the agent knows this is a mutating operation. The description adds one concrete detail: it resets the current password to the password provided in the request body. This adds some context beyond the annotations, but it doesn't disclose irreversible consequences, required permissions, or other behavioral nuances.

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 repetitive, repeating the title phrase twice ('Reset password for a compute instance / resource referenced by an id - Reset password for a compute instance / resource referenced by an id'). This wastes space and adds no new information. It could be significantly condensed into a single 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?

The tool is a destructive write operation with nested parameters and no output schema. The description is minimal, providing no information about return values, side effects, error conditions, or required authorization. For a potentially dangerous action, far more contextual detail is needed.

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

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

Schema description coverage is 0%, and the description provides no parameter details. The input schema does include descriptions for nested properties (e.g., rootPassword, sshKeys, userData), which partially helps, but the tool description itself offers no guidance on how the parameters relate to the action. The agent would need to rely entirely on the schema, which lacks top-level parameter descriptions.

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

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

The description clearly states the action (reset password) and the target (a compute instance/resource by id). It uses a specific verb and resource, making the purpose understandable. However, it does not differentiate from the sibling tool 'resetPassword', which likely performs a similar or identical function, so the differentiation is unclear.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or alternative tools. Given the existence of a closely named sibling 'resetPassword', the absence of any usage differentiation is a significant gap.

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 the operation is destructive and not read-only, but the description adds no additional context about side effects, required instance state, or consequences. No value beyond what annotations already provide.

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

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

The second sentence is a pure tautology of the first, adding no information and wasting space. A single clear sentence would be more concise and effective.

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 destructive nature and the presence of sibling tools like stop/start, the description should explain prerequisites (e.g., instance must be running) and expected side effects. The description lacks these details and does not fully support an agent in deciding when to use it.

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

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

Schema description coverage is 0%, and the description only vaguely references 'its id' without naming the instanceId parameter or explaining the other parameters (x-request-id, x-trace-id). This is insufficient compensation for the lack of schema documentation.

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 clearly states the action (restart) and resource (compute instance/resource by id). However, it does not differentiate from siblings like start, stop, or shutdown, so it lacks sibling distinction.

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

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

No guidance is provided on when to use restart compared to alternatives such as start, stop, or reinstallInstance. The description only implies the action without giving context or exclusions.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: permissions vary by endpoint. However, it does not disclose pagination behavior, response structure, or any other operational details that might be needed. With annotations covering safety, this is a middle score.

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 short sentences and is front-loaded with the core purpose. The opening phrase 'List of API permissions' is redundant with the title, but the rest is efficient and free of fluff.

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

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

For a read-only list tool with six parameters, no output schema, and no parameter descriptions, the description should explain pagination, filtering, ordering, and what the response contains. It only provides the purpose and a caveat, leaving significant gaps in understanding how to use the tool.

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

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

The input schema has six parameters with zero description coverage. The description does not explain page, size, apiName, orderBy, or the ID fields. The caveat about endpoint-specific possibilities hints at apiName but does not explicitly define it. This under-compensates for the schema's lack of parameter documentation.

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 explicitly states the action ('List') and resource ('all available API permissions'), and clarifies the list is a reference for specifying roles. This clearly distinguishes it from sibling list tools such as retrieveInstancesList or retrieveRoleList.

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: the list is a reference for roles, with a caveat that not all actions are available per endpoint. While it doesn't name alternatives or explicit exclusions, no direct sibling tool duplicates this functionality, so the guidance 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 already declare readOnlyHint=true and destructiveHint=false, so the safe read nature is clear. The description adds minimal context like 'in your account' and the requirement for resource type/id, but does not disclose other behavioral aspects such as authentication needs, rate limits, or response format. No contradiction with annotations.

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

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

The description is short but contains redundancy: the first phrase 'Get specific assignment for the tag' restates the title, followed by a dash and a near-identical restatement. It could be condensed to a single clear sentence without losing meaning.

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 is returned (e.g., the assignment attributes structure), but it only vaguely says 'Get attributes'. It also does not cover error cases, pagination, or the role of all parameters. The tool has 5 parameters and zero schema descriptions, so the description is insufficient for an agent to invoke it confidently.

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

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

Schema description coverage is 0%, and the description only states that resource type and resource id are required. It does not explain the meaning of tagId, x-request-id, or x-trace-id, nor does it clarify what values resourceType should take. The description provides minimal semantic value beyond the schema.

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

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

The description clearly states the tool retrieves attributes for a specific tag assignment, using the verb 'Get' and specifying the resource type and resource id. This distinguishes it from sibling list tools like retrieveAssignmentList and mutation tools like createAssignment/deleteAssignment.

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 use when needing a single assignment's attributes, but does not explicitly state when not to use it or mention alternatives such as retrieveAssignmentList for bulk retrieval. It only notes that resource type and resource id are required, which is more of a prerequisite than a usage guideline.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds only the 'for a tag' scope and 'in your account' context, but does not disclose pagination behavior or filter mechanics. No contradiction with annotations.

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

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

The description is a single front-loaded sentence with no fluff, though the title and description repeat 'List tag assignments' which is slightly 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?

This is a 7-parameter list tool with no output schema. The description is too minimal: it lacks pagination details, filter parameter semantics, return format expectations, and any differentiation from related assignment list/audit tools.

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

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

Schema has 7 parameters with 0% description coverage. The description only implies tagId via 'for a tag' and gives a generic 'filter' mention, leaving page, size, orderBy, resourceType, and trace/request IDs without meaningful explanation.

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: 'List and filter all existing assignments for a tag in your account.' It clearly distinguishes from create/deleteAssignment and the singular retrieveAssignment, though it does not explicitly name alternative list tools.

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

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

No guidance on when to use this tool instead of siblings like retrieveAssignment or retrieveAssignmentsAuditsList. It does not provide exclusions, prerequisites, or recommended scenarios.

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 destructiveHint=false, so the tool is known to be safe. The description adds that it can 'filter' history, but it does not disclose pagination behavior, required headers beyond the schema, or the format of returned data. With annotations covering the safety profile, a score of 3 is appropriate.

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

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

The description consists of two sentences that are nearly identical: 'List history about your assignments (audit)' and 'List and filters the history about your assignments.' This repetition wastes words without adding information. The second sentence only introduces 'filters' but otherwise repeats the first, so it does not earn 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 11 parameters, no output schema, and no explanation of the response structure or filtering semantics, the description is critically incomplete. An agent would have difficulty understanding what the history entries contain, how filters affect results, or what the return value looks like, making the tool much harder to use 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 0%, and the description mentions 'filters' generically but provides no explanation of any of the 11 parameters (e.g., page, size, tagId, startDate, endDate). The agent must rely solely on the raw schema, which lacks semantic meaning, so the description fails 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 tool lists audit history for assignments, using a specific verb and resource. It distinguishes itself from sibling tools like retrieveAssignmentList by specifying 'history (audit)'. However, it is repetitive, saying the same thing twice, which slightly detracts from clarity.

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

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

No guidance is provided on when to use this tool versus the many sibling audit list tools (e.g., retrieveInstancesAuditsList, retrieveDomainsAuditsList). There is no mention of exclusions, prerequisites, or alternative tools, leaving the agent to infer usage solely from the tool's name and 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 mark the operation as read-only and non-destructive. The description adds the types of statistics returned, providing some context about the response content. However, it does not disclose response structure, pagination, or any access requirements. With annotations covering safety, this is adequate but not rich.

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 redundant, repeating the title verbatim before adding examples. The first clause 'List statistics regarding the customer's custom images' is identical to the title, making the description bloated and less scannable.

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

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

For a simple read-only stats retrieval, the description provides a reasonable overview of the returned data (count, disk usage). However, it does not specify the response shape or whether the stats apply to all custom images. Given no output schema, some ambiguity remains.

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 two header-like parameters (x-request-id, x-trace-id) with no descriptions. The tool description does not explain these parameters or their formats, despite the schema coverage being 0%. The description fails to compensate for the lack of parameter documentation.

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

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

The description clearly states the tool's function: listing statistics about the customer's custom images, and enumerates specific stats (number of images, disk space used/free/total). This distinguishes it from sibling tools like retrieveImageList and retrieveObjectStoragesStats which target different resources.

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

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

The description offers no guidance on when to use this tool versus alternatives. It simply restates the tool's purpose without mentioning exclusions, prerequisites, or related 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds little. It mentions 'all data centers' and 'regions' but does not describe pagination, filtering defaults, or any other behavioral traits. No contradiction, but minimal value 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?

The description is short and front-loaded. However, the prefix 'List data centers -' repeats the tool name and adds no value, slightly detracting from conciseness.

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

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

With 9 parameters and no output schema, the description is under-specified. It does not mention required x-request-id, pagination, filtering, or ordering behavior. The tool is safe to call (per annotations), but the description alone is insufficient 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 0%, so the description must compensate. It only hints at region-related parameters via 'corresponding regions' but leaves page, size, orderBy, name, slug, and tracing parameters unexplained. This is insufficient for a 9-parameter tool.

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

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

The description clearly states the action ('List') and the resource ('data centers'), and adds that it returns corresponding regions. This distinguishes it from sibling tools, as it is the only one about data centers.

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 name and description, but there is no explicit guidance on when to use this tool over alternatives or any prerequisites. No alternatives are mentioned, but the purpose is clear enough that an agent can infer when to use it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds that it returns 'all attributes' and selects by zone name, but does not disclose error behavior, whether a non-existent zone returns 404, or any other operational details. This is adequate for a simple read but not rich.

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: 'Retrieve a DNS Zone by zone name - Get all attributes for a specific DNS Zone'. Every word contributes meaning, with no filler or repetition.

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

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

For a simple read tool with annotations, the description is adequate but incomplete. There is no output schema, and the description only promises 'all attributes' without specifying what those attributes are or how the response is structured. It also does not address edge cases like zone not found. Given the lack of output schema, more detail would be expected.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly states the zone is retrieved by zone name, clarifying the role of zoneName. However, it does not explain the required x-request-id or optional x-trace-id headers; their names and patterns (UUID for x-request-id) make them somewhat self-explanatory, but the description adds minimal value for these parameters.

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

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

The description uses the specific verb 'Retrieve' with the resource 'DNS Zone' and specifies 'by zone name' and 'for a specific DNS Zone', clearly distinguishing this from sibling tools like retrieveDnsZonesList (plural list) and retrieveDnsZoneRecordsList.

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: use this when you need a specific DNS zone's attributes by its name. However, there are no explicit exclusions or references to alternative tools (e.g., retrieveDnsZonesList for listing), so the guidance is only implied, not explicit.