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

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false and openWorldHint=true, so safety is largely covered. The description adds one genuinely useful behavioral fact beyond the annotations: deletion cascades to the deployment's files. It does not address auth requirements, confirmation, or what happens to a repeated call despite the idempotent hint.

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

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

A single front-loaded sentence with no filler; every word ('Permanently', 'and its files') carries weight. Nothing could be trimmed without losing 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?

With a fully documented schema, an output schema, and annotations covering the safety profile, the description supplies the one extra fact that matters (cascade to files). It is close to complete, though it omits any note on irreversibility/confirmation context an agent might want before a destructive call.

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

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

Schema description coverage is 100% and the single parameter ('deployment' hostname) is fully documented with an example in the schema. The description adds no parameter-level detail, so the baseline of 3 applies.

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

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

The description states a specific verb ('deletes') and resource ('a deployment'), so an agent can distinguish it from deployments_get/list/set/upload at a glance. It does not, however, explicitly name the sibling tools or the condition that selects deletion over them, which a 5 would require.

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 when-to-use or when-not-to-use guidance and no mention of alternatives such as deployments_set or deployments_list. Usage is only implied by the verb 'delete'.

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 that this is read-only and non-destructive, lowering the behavioral burden. The description adds value by specifying exactly what details are returned, which helps the agent understand the tool's output scope without needing to inspect the output schema.

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

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

The description is a single sentence that front-loads the action and immediately lists the valuable result fields. There is no filler, repetition, or unnecessary context.

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

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

For a one-parameter, read-only lookup with full input schema coverage, explicit read-only annotations, and an output schema, the description plus structured metadata gives an agent everything needed to select and invoke the tool correctly.

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

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

The only parameter, deployment, is fully documented in the schema with a type, example hostname, and a note that it comes from deployments_upload or deployments_list. With 100% schema description coverage, the description adds little extra meaning beyond what the schema already provides.

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

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

The description uses a strong, specific verb and resource ('Get deployment details') and enumerates the concrete data fields returned: URL, status, file count, size, labels, and password protection state. This clearly distinguishes it from sibling operations like deployments_delete, deployments_list, or deployments_upload.

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

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

The description makes it clear this is a single-deployment lookup, and the parameter schema adds helpful provenance guidance: deployment hostnames are returned by deployments_upload or deployments_list. It does not explicitly state when not to use it, but the get-versus-list distinction is strongly implied by the tool 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the pagination contract (cursor null on last page, pass it back to fetch next), which is behavioral detail beyond the annotations. It does not contradict any annotation, and the read-only nature is consistent with the described operation.

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

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

Two sentences with no filler. The first sentence states exactly what the tool returns, and the second covers the essential pagination detail. Every word earns its place, and the most important information is front-loaded.

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

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

Given that an output schema exists (signaling the response structure is documented separately), the description is complete for a list tool. It covers the action, the returned fields, and the pagination mechanics. Annotations cover safety, and the parameter schema is fully documented, so nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (limit and cursor). The description adds no additional meaning to the parameters beyond what the schema already provides; it only ties the cursor to the pagination flow, which is implicit in the schema's description. The baseline of 3 applies because the schema carries the heavy lifting.

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

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

The description states a specific verb ('List') and resource ('all deployments') and enumerates the fields returned (URLs, status, labels, password protection state). It clearly distinguishes itself from sibling tools like deployments_get (which retrieves a single item) and deployments_delete (which removes one). The name and title reinforce 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 explains how to handle pagination (passing cursor back), which is clear usage guidance for iterating pages. However, it does not explicitly contrast with alternatives (e.g., when to use deployments_get vs this list), though the sibling names are self-explanatory. It provides context but no exclusions or explicit when-not-to-use 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?

The description explicitly discloses the destructive behavior: 'Replaces all existing labels.' This goes beyond the generic destructiveHint annotation by telling the agent exactly what is affected and that labels not included in the request will be removed.

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

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

The description is two short sentences with no filler. The primary action is front-loaded and the essential replacement behavior is stated immediately after, making it easy for an agent to parse quickly.

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

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

For a two-parameter tool with a fully documented input schema and an existing output schema, the description provides the key operational context, particularly the label replacement semantics. It lacks explicit usage guidance and alternative routing, but the core information needed to call the tool correctly is present.

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

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

Schema description coverage is 100%, and the schema already documents each parameter thoroughly, including the empty-array-to-clear behavior for labels. The description adds no parameter-specific meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Update') and the resource ('deployment labels'), and the second sentence clarifies the full replacement semantics. It does not explicitly differentiate from sibling tools like deployments_get or deployments_list, but the resource and verb are specific enough to avoid major 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 gives no guidance on when to prefer this tool over alternatives, nor does it state prerequisites or exclusions. The schema mentions 'Use deployments_list to find deployments,' but the tool description itself does not provide 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 only declare readOnlyHint=false and openWorldHint=true; the description adds real behavioral context beyond them — no auth needed, anonymous sites expire in 3 days unless claimed via a one-time URL, and the password gate applies to custom domains too. It omits operational traits such as rate limits, payload/size limits, and what happens to existing deployments, so it stops short of a 5.

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

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

Three tight sentences, front-loaded with the core action and followed by the two facts an agent most needs (returns and expiry/claim behavior). 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?

With a full output schema, complete parameter documentation, and annotation-covered safety, the description covers the essentials: what it does, what it returns, and the anonymous-expiry caveat. Minor gaps remain around auth token sourcing (SHIP_TOKEN is referenced but never explained) and deployment limits.

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

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

Schema description coverage is 100%, so all five parameters (including the rich ttl and idempotencyKey semantics) are already fully documented in the schema. The description restates only the password behavior ("make the site private"), adding little beyond what the schema says; baseline 3 applies.

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

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

"Deploy a static site instantly" is a specific verb+resource, and it is unambiguously distinct from the sibling read/manage tools (deployments_list, deployments_get, deployments_set, deployments_delete). The added notes about return values and anonymous vs. token-based deploys further pin down what this tool is.

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 useful context for choosing the anonymous path (free, no account/API key, 3-day expiry unless claimed) but never explicitly states when to use this over siblings or when to prefer an authenticated deploy. Usage is implied rather than spelled out, and no alternatives are named.

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 already signals the destructive nature, so the description adds little beyond repeating 'Permanently deletes'. It does not clarify whether the action is reversible, requires authentication, affects DNS records, or has rate limits. With annotations providing basic safety hints, the description fails to add meaningful behavioral context for a destructive operation.

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

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

Extremely concise single sentence that front-loads the key verb. No waste, no redundancy.

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

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

For a destructive tool with an output schema and full parameter description, the minimal description is adequate but misses important context such as whether deletion cascades to related domains or DNS records, whether it can be undone, and any required permissions. The annotations cover some safety aspects, but the overall guidance for a high-risk operation is thin.

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

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

Only one parameter, and the schema fully describes it with an example. The description correctly implies a domain name is needed but adds no extra meaning since the schema already covers it well. Since there is a single parameter, baseline 4 applies when the schema is rich.

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

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

States a specific verb (deletes) and resource (domain) precisely matching the tool name and title. It is clearly distinguishable from siblings like domains_get or domains_set, making the agent's selection easy.

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

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

Provides no guidance on when to use this tool versus alternatives such as domains_set or domains_verify, nor any prerequisites or warnings beyond the word 'Permanently'. The agent must infer appropriate contexts.

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, destructiveHint=false, openWorldHint=false, so safety is covered. The description earns credit by adding non-obvious behavior beyond them: the result is best-effort ('if known'), and the tool is only meaningful while the domain is unverified — a real applicability constraint an agent cannot get from 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?

One compact passage with the resource stated first and the scoping constraint immediately after. The closing clause ('once its DNS is right there is nothing left to locate') is slightly colloquial but does real work by explaining the unverified-only rule.

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 an output schema present, return-shape detail is not required, and the description covers purpose, scope, and the unverified-only precondition adequately. The only meaningful omission is routing to sibling tools when the precondition fails.

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

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

Schema description coverage is 100% and there is a single required 'domain' parameter fully documented in the schema, including its prerequisite ('previously created with domains_set'). The description adds no syntax or format detail, so the baseline 3 for schema-covered params applies.

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

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

The description gives a specific verb and resource — 'Returns the DNS provider recorded for the domain' — with concrete examples (Cloudflare, Namecheap). It does not name the nearest siblings (domains_records, domains_get, domains_verify), so differentiation is implied by scope rather than stated.

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

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

It states a clear when-condition and two when-not conditions: 'Custom domains only, and only while the domain is unverified; once its DNS is right there is nothing left to locate.' That is strong applicability guidance, though it never points to the alternative tool an agent should use instead (e.g. domains_records for record inspection).

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, openWorldHint=false, and destructiveHint=false, so safety is covered. The description adds genuinely non-structured context by decoding the `status` values (unverified, unlinked, live, paused) and what they mean to the owner, which an agent cannot infer from the schema.

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

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

A single sentence that leads with the core action and then lists the payload. The trailing status parenthetical is somewhat long but it carries real information, so it earns its place.

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

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

With an output schema present, the description needn't document return values, and it still sketches them usefully. Combined with annotations covering the read-only profile and a fully documented single parameter, an agent has what it needs to call this 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?

There is only one parameter and schema description coverage is 100%, including an example format and a pointer to domains_list. The description adds nothing about the `domain` argument, so the baseline 3 applies.

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

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

The description gives a specific verb ('Get') and resource ('domain details') and enumerates the returned fields (URL, linked deployment, labels, status), which is enough to separate it from domains_list and domains_delete. It does not explicitly name a sibling to contrast against, so it falls short of the top score.

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 when-to-use guidance in the description itself — no mention of when to call this versus domains_list, domains_records, or domains_dns. The only routing hint ('Use domains_list to find names') lives in the schema's parameter description, not here.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful behavioral detail beyond the annotations: the response includes URLs, linked deployment, and status, and pagination terminates when cursor is null. It does not mention auth or rate limits, but this is a safe read operation.

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

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

Two sentences with zero waste. The core listing behavior is front-loaded, and pagination guidance follows naturally without 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?

Given the presence of an output schema and read-only annotations, the description covers what is listed, what fields are returned, and how pagination works. It omits sibling alternatives and any filtering context, but no filter parameters exist, so it is nearly complete for a simple list tool.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description restates cursor usage and adds that it is null on the last page, but adds no syntax or format detail for limit, so the baseline 3 is appropriate when the schema carries parameter 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 a specific verb and resource ('List all domains') and names the returned fields (URLs, linked deployment, status), so the tool's purpose is immediately clear. It does not explicitly distinguish itself from the sibling domains_get, but the list scope is implied.

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 tool's usage is implied by 'List all domains' and the description explicitly explains how to continue pagination. It gives no guidance on when to prefer this over siblings like domains_get or domains_records, and no exclusions or prerequisites are stated.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description usefully adds the sequencing dependency and the custom-domain restriction, but says nothing about authentication, rate limits, or how records are sourced, which is acceptable given the 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?

Two tight sentences with zero waste; the purpose is front-loaded and the constraint follows. Nothing could be removed without losing 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?

An output schema exists, so return values need not be explained, and the description covers the prerequisite and scope. For a single-parameter read tool this is close to complete, with only the sibling distinction left implicit.

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

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

Only one parameter exists and schema coverage is 100%, with the schema itself stating the domain must have been created via domains_set. The description adds no syntax, format, or example beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb and resource ('Returns the DNS records to configure at the domain's DNS provider') and scopes it to custom domains, which is clear enough to act on. It stops short of explicitly differentiating itself from the nearby domains_dns sibling, so an agent could still hesitate between the two.

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

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

Gives an explicit prerequisite ('Call after domains_set') and an explicit exclusion ('a ShipStatic domain has no records to configure'), which is strong when/when-not guidance. It does not name an alternative tool for the excluded case, which is the only thing keeping it from a 5.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds real behavioral context beyond them: a ShipStatic domain goes live as soon as a deployment is linked, while a custom domain requires DNS records first. It does not spell out that an update overwrites existing linkage/labels, which would have earned a 5.

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

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

Three dense sentences, front-loaded with the core action and its two branches before the operational modes. The repeated inline examples overlap with the schema's own examples, a small redundancy, but no sentence is filler.

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

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

With an output schema present, return values need no explanation, and the annotations carry the safety profile. The description covers the domain variants, the DNS prerequisite, and every mutation mode the tool supports, so nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters including the omit-to-reserve semantics. The description restates the domain-type distinction and the reserve case but adds no format or behavioral detail the schema lacks, making the baseline 3 appropriate.

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

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

States a specific verb+resource ("Create or update a domain") and immediately splits the resource into its two meaningful variants, ShipStatic vs custom, with examples. It also distinguishes itself from the sibling domains_records, so an agent can place it without opening another schema.

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

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

Enumerates the four usage modes clearly: reserve (omit deployment), link to a deployment, switch deployments, update labels, and points to domains_records as the follow-up for custom DNS. It lacks an explicit when-not/alternative (e.g. domains_delete for removal, domains_get for reads), so it falls just short of a 5.

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

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

Annotations already mark this read-only and non-destructive, and the description adds meaningful behavioral context beyond them: the resulting URL requires no API key, and the operation is a no-op for verified domains. It does not disclose link lifetime or revocation, which keeps it short of a 5.

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

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

A single dense sentence, front-loaded with the return value, followed by the two constraining clauses. Every clause carries information; nothing is padding.

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 an output schema present, the description need not explain the return shape, and it covers auth, scope, and eligibility adequately. Minor gaps remain around what happens on an ineligible domain (error vs empty), but an agent has enough to call it correctly.

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

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

Schema coverage is 100% and the single parameter is fully documented there, so baseline 3 applies. The description adds the 'custom domains only' constraint, which narrows what values are valid, but adds no syntax or format detail beyond the schema.

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

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

States a specific verb and artifact ('Returns a shareable DNS setup URL') and immediately names the audience ('for whoever manages the domain's DNS'). It is clearly distinguishable from siblings like domains_dns/domains_records, which return actual DNS data rather than a share link.

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

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

Gives explicit applicability conditions: custom domains only, and only while the domain is unverified, with a stated reason ('a verified domain has no setup left to share'). It does not name an alternative sibling, but the when/when-not boundary is unambiguous.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds that the call returns a normalized form and availability, which hints at behavior, but nothing about rate limits or what makes a domain 'valid'. With annotations carrying the main burden, a 3 is right.

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

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

Two tight sentences with the purpose front-loaded and zero filler. No structural problems, though it stops short of the routing information that would let it earn a 5.

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?

An output schema exists, so return values need not be expanded, and the description still summarizes the return payload (normalized form, availability). For a one-parameter read-only tool this is adequate, with the only real gap being disambiguation from domains_verify.

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

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

Only one parameter at 100% schema description coverage, so the schema already documents the argument and even the pre-call guidance. The description adds no format or normalization detail beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb and resource: validates and checks availability of a domain name, with the temporal context 'before creating it'. However, it does not distinguish itself from the sibling domains_verify, which an agent may reasonably confuse with this tool.

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 'before creating it' implies this is a pre-flight check, and the schema param description names domains_set directly. But the description itself never names the alternative tools (domains_set, domains_verify) or states when NOT to use it, so routing between validate and verify is left to inference.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false, openWorldHint=true), the description discloses key traits: the call is asynchronous, the returned status is stale, results must be polled via domains_get, and the operation is refused once verified. It also notes a verified domain serves nothing until a deployment is linked. This is rich behavioral context an agent cannot get from 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?

Tight, front-loaded prose: the core action leads, followed by prerequisite, exclusions, async caveat, and follow-up. Every clause carries actionable signal with no filler.

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

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

An output schema exists, so return-value explanation is unnecessary, and the description instead covers the async lifecycle and the follow-up reads/writes needed. For a single-parameter verification trigger, nothing an agent needs is missing.

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

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

Only one parameter with 100% schema description coverage; the schema already states it must be a domain previously created with domains_set. The description's prerequisite wording amplifies but does not add format or syntax detail beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb (trigger verification) and resource (DNS for a custom domain) in the first sentence. It is immediately distinguishable from siblings like domains_get (read status) and domains_set (link deployment), which it names explicitly.

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

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

Gives an explicit precondition (call after configuring DNS records from domains_records), an exclusion (custom domains only), a negative condition (refused once verified, use domains_get instead), and a follow-up routing (link with domains_set). Nothing is left to inference.

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

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

Annotations already declare the full safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=false), so the description carries a light burden. It adds a summary of what is retrieved, but since an output schema exists that already documents the return values, this is largely restatement rather than new behavioral context.

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

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

A single front-loaded sentence with no filler — verb first, then the exact fields returned. Every clause earns its place.

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

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

For a zero-parameter read tool with a full annotation set and an output schema, the description is essentially complete. The only omission is any mention of authentication or state assumptions, which is minor given openWorldHint=false and the self-referential 'your' framing.

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

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

The tool takes zero parameters, so there is no parameter semantics for the description to explain; the baseline for a no-arg tool applies. Nothing about argument form or filtering options is missing.

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

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

Specific verb ('Returns') plus precisely enumerated resources: the caller's email and name, and the account's plan, usage and caps. The sibling set is entirely deployment/domain CRUD operations, so there is no overlapping purpose to disambiguate against — the agent can identify this tool's job immediately.

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

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

Usage is only implied: an agent infers it should call this when it needs to know which account it is acting as. There is no explicit when-to-use statement, no prerequisites (e.g. auth required), and no named alternative — though none of the siblings compete here.

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