OSIR Domain Registrar

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

There are no annotations, so the description must carry the full behavioral burden. It only says the tool generates suggestions and does not disclose whether the operation is read-only, what the return shape is, whether there are rate limits, or any side effects. This is a notable gap.

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

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

The description is a single focused sentence with parentea included example values. There is no padding, and the core operation is front-loaded. Every part of the sentence adds useful information.

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

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

For a simple flat-parameter generation tool, this description covers the operation and all parameters with examples. However, with no output schema and no annotations, it omits return-value semantics and explicit alternative selection guidance. An agent could call it correctly but would have to infer outputs.

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 parameter documentation falls entirely on the description. The description provides concrete example values for every parameter ('mycompany', '@prefixes', 'com,net', 'eng', 20), which materially helps an agent understand expected formats without opening external docs. It still leaves some ambiguity around lang format and tlds syntax, but it compensates well.

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 ('Generate') and resource ('domain suggestions') with a clear method ('by adding prefixes'). This distinguishes it from sibling tools like addSuffixToDomain, and the example clarifies what kind of input is expected.

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 through the tool name and description, but the description does not explicitly say when to choose this tool over alternatives like addSuffixToDomain or generateDomainSuggestions. No when-not conditions or alternative guidance is 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?

With no annotations provided, the description carries the full burden of behavioral disclosure and succeeds. It reveals idempotency ('storing a key you already have returns the existing one instead of creating a duplicate'), that authentication is required, that it is safe to call repeatedly ('safe to call before every order'), and what it returns (the key id). This is precisely the behavioral context the absent annotations would otherwise need to supply, and there is 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?

Five short sentences, each carrying distinct information: purpose, idempotency, authentication, required parameter formats with examples, and return value. The structure is front-loaded with the core purpose, and no sentence is redundant with the schema — even the 'Required:' repetition adds examples the schema lacks.

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

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

Despite having no annotations and no output schema, the description covers the full call contract: what the tool does, authentication requirements, both required parameters' semantics and formats, idempotent behavior, the return value (key id), and how to use it downstream. Nothing an agent needs to invoke 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 only 33% — only sessionKey has schema documentation, while the two required parameters have none. The description compensates for this gap by defining name as 'a label, e.g. laptop' and publicKey with its required format and an example ('single-line OpenSSH public key, e.g. ssh-ed25519 AAAA... user@host'). It leaves sessionKey to the schema, which already documents its auth-flow-dependent behavior, so compensation is complete but not exhaustive.

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 — 'Store an SSH public key on your account' — and adds its purpose ('so it can be injected into VPS installs'). It is clearly distinguishable from sibling key tools like deleteShKey and listMySshKeys, and the return-value tie to orderVps/buildVpsInstance reinforces what this tool is for.

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

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

The description gives explicit when-to-use guidance: 'safe to call before every order' and explains the downstream integration (pass the returned key id to orderVps or buildVpsInstance). However, it does not explicitly name sibling alternatives (e.g., listMySshKeys, deleteSshKey) or state when not to use this tool, stopping 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?

No annotations are provided, so the description must carry the full behavioral burden. It only states that the tool generates suggestions by adding suffixes and lists some inputs; it does not disclose read-only status, response format, side effects, or behavior around missing/invalid inputs. This is minimal for a tool with no safety 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 main behavior is front-loaded in one clear sentence, followed by a compact required/optional parameter summary. Every clause earns its place and the description remains scannable without redundant prose.

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 input side is complete enough to make a basic call, since all five parameters have examples. However, with no output schema and no annotations, it omits return format/behavior and doesn't explain when this tool should be preferred over its many siblings, leaving it minimally complete.

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

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

Schema coverage is 0%, but the description compensates by giving every parameter an example: name ('mycompany'), vocabulary ('@uffixes' or custom), tlds ('com,net'), lang ('eng'), and maxResults (20). It distinguishes required from optional and provides plausible formats, though 'custom' vocabulary and exact defaults remain vague.

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 ('Generate domain suggestions') and names the distinguishing method ('by adding suffixes'), which separates it from sibling tools like addPrefixToDomain. It does not explicitly contrast with generateDomainSuggestions, but the suffix-specific method is still a clear differentiator.

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 invocation details (required and optional parameters) but gives no when-to-use guidance. It never mentions alternatives such as addPrefixToDomain, generateDomainSuggestions, or bulkDomainSuggestions, so an agent gets no help choosing among overlapping siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the operation is DESTRUCTIVE, erases all data including deployed applications, and cannot be undone. It also discloses that the install is asynchronous, requires authentication, and returns an actionId that must be confirmed before execution.

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

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

The description is dense but not bloated; every sentence adds necessary operational detail. The destructive warning is front-loaded, and the Required/Optional grouping plus explicit next steps keep the information scannable despite its length.

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

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

For a destructive asynchronous mutation with no output schema and no annotations, the description is remarkably complete. It covers prerequisites, parameter sourcing, irreversible data loss, async completion detection, and the required user approval workflow. An agent has everything needed to invoke the tool safely and follow up 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 only 17%, so the description must compensate, and it does. It explains instanceId, operatingSystemId, sshKeyIds, hostname, and swap in detail, including default behavior, allowed swap values, and where to obtain valid IDs. This is far more useful than the bare 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 opens with a specific action and resource: 'Stage an operating system install on a VPS instance.' It also explicitly states that this is how a reinstall works, which distinguishes it from VPS lifecycle siblings like orderVps, deleteVpsInstance, and getVpsInstanceDetails.

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 lists required and optional parameters, points to listVpsOsTemplates and listMySshKeys as sources for valid IDs, and warns that omitting an SSH key may leave the user unable to log in. It also gives the exact post-install workflow: poll getVpsInstanceDetails until buildState is COMPLETE, then present the returned actionId and call executeConfirmedAction if the user approves.

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

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

With no annotations provided, the description carries the full burden and handles it well. It discloses the grouped return structure, that returnedTlds may be a subset, the possible availability values ('available', 'taken', 'unknown'), and premium pricing considerations. This is substantive behavioral context beyond a simple action statement.

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 longer than average but tightly organized with clear sections (USAGE PATTERN, REQUIRED, OPTIONAL, Returns, Note). Every section earns its place, covering the call flow, parameter constraints, return shape, and caveats without redundant 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?

Given there is no output schema and no annotations, the description provides everything an agent needs to invoke the tool correctly: parameter constraints, the sequential dependency on listCategorizedTlds, the return group structure, and guidance for ambiguous availability results. It is complete for a suggestion-generation 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 0%, but the description compensates thoroughly: it defines the keywords range (1-10), TLDs range and hard cap (1-6), the no-leading-dot format requirement, lang default ('eng'), and maxResults default (20). This is far more than the bare schema 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 clearly states the verb ('Generate'), the resource ('domain name suggestions'), and the scope ('one or more keywords across a chosen set of TLDs'). It also specifies the grouping behavior ('grouped by originating keyword'), which differentiates it from the similarly named sibling generateDomainSuggestions.

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 prescribes the usage flow: call after listCategorizedTlds, then pick TLDs, then call bulkDomainSuggestions. It also instructs follow-up with checkDomainAvailability for 'unknown' or premium-priced results. However, it does not explicitly state when not to use this tool or mention the alternative generateDomainSuggestions, so it stops short of full exclusion guidance.

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

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

With no annotations provided, the description carries the full disclosure burden. It explicitly warns that the operation is DESTRUCTIVE and irreversible, notes that authentication is required, and reveals the staged two-phase behavior where cancellation is not completed until executeConfirmedAction is called.

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: it opens with the core purpose and destructive warning, then covers authentication, the required parameter, return value, and the exact follow-up action. Every sentence earns its place.

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

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

For a two-parameter tool with no output schema, the description provides the required inputs, the output contract (actionId), the authentication requirement, the destructive nature, and the next step. Nothing essential is missing for an agent to use 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 schema only documents sessionKey, while domain has no description. The description compensates for domain by marking it required and giving an example ('example.com'). It does not add much about sessionKey, but the schema already explains that parameter well.

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 ('Stage cancellation of a pending domain transfer') with the resource clearly identified as domain transfers. It also distinguishes this tool from executeConfirmedAction by framing it as the staging step rather than the execution step.

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 clearly indicates this is for pending domain transfers and provides an explicit workflow: present the summary to the user and call executeConfirmedAction with the returned actionId if the user approves. It lacks explicit 'do not use when' guidance, but the context is clear and the follow-up tool is 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?

No annotations exist, so the description carries the full burden. It only adds 'Requires authentication' and lists required inputs. It does not disclose whether the change is immediate, prorated, reversible, subject to restrictions, or what side effects might occur on the existing billing cycle.

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 compact sentence that front-loads the action and then lists the required parameters and valid values. The 'Requires authentication' and 'Required:' parts are somewhat redundant with the schema and annotations, but the overall structure is easy to scan.

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

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

This is a mutating billing operation with no annotations and no output schema, yet the description doesn't mention effects, error cases, or authentication flow details. Given the operation's financial impact, an agent needs more context to invoke it safely and 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 only 33%, so the description must compensate. It adds the allowed paymentTerm values ('MONTHLY', 'SEMI_ANNUAL', 'ANNUAL', 'BIENNIAL', 'TRIENNIAL') and repeats instanceId's type, but it does not explain how to obtain a valid instanceId or any constraints on changing between terms.

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 ('Change the payment term') and targets a clear resource ('a VPS instance'), with the synonym 'billing cycle' to remove ambiguity. No sibling tool appears to do exactly this, but the description doesn't explicitly differentiate itself from related billing or VPS tools.

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

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

The description implies the tool is used when someone wants to change a VPS's billing cycle, but it gives no guidance on prerequisites, when not to use it, or how it compares to related tools like orderVps, createPaymentSession, or payInvoice. 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It communicates that this is a polling operation, requires a device code, returns a sessionKey on success, and mandates that sessionKey be reused in subsequent authenticated calls. It does not describe failure or pending states, but the core behavior is well disclosed for a one-parameter polling tool.

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

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

Three concise sentences with no filler. The main purpose is front-loaded, followed by sequencing requirements and the essential parameter meaning. Every sentence 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?

For a simple tool with one parameter and no output schema, the description covers the prerequisite flow, the required input, the expected success result, and the downstream sessionKey usage. It could be more complete about error or pending states, but nothing essential to invoking 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?

The schema only defines deviceCode as a required string with no description. The description adds critical meaning by explaining that deviceCode is the device_code returned by loginWithDevice, which is exactly what an agent needs to supply the correct 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 uses a specific verb and resource: 'Poll for device login completion.' It clearly ties the tool to the loginWithDevice flow, making it easy to distinguish from auth-related siblings such as getAuthStatus and logout.

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

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

The description explicitly states when to call this tool: after loginWithDevice, after opening the verification URL, and after the user has signed in. It also explains what to do with the result. It does not explicitly name alternatives or exclusions, but the sequencing guidance is clear.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses authentication behavior (anonymous vs. authenticated pricing) and clarifies that this is a non-destructive lookup. It could add response-shape or rate-limit context, but the provided behavior is useful and accurate.

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 core purpose and required input are front-loaded, and the auth/pricing nuance is stated efficiently.

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

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

For a simple two-parameter lookup with no output schema, the description is largely complete: it names the required parameter, gives a format example, and explains the auth-dependent pricing behavior. It would be slightly stronger if it mentioned the return shape, but that is not essential for correct invocation.

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

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

Schema coverage is only 50%, but the description compensates by explaining the domain parameter with a concrete example and by tying the optional sessionKey to the anonymous/authenticated pricing difference. The schema already documents sessionKey's source and usage, so the description adds value where it is most needed.

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

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

The description states a specific action ('Check if a domain name is available for registration') with a clear resource (domain) and an added outcome (price). It is easy to distinguish from sibling tools like checkHostAvailability and checkKeywordAvailability, though it does not explicitly name them.

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

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

The description gives clear context: this is the availability-checking tool for domains, and it notes that no authentication is required. It also specifies the required input ('domain') with an example, but it does not explicitly contrast with alternative availability-checking tools.

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

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

No annotations are provided, so the description carries the burden. It discloses an authentication requirement, but does not describe the response format, whether the check is read-only, or what 'unavailable' means. Some behavioral context exists, but not full.

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

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

Three short sentences, each adding necessary information: the operation, the authentication prerequisite, and the required parameter with an example. No filler or redundancy.

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

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

For a simple two-parameter check tool, the core calling context is covered (purpose, auth, required hostname format). However, with no output schema, the description leaves the return shape and semantics of the availability result unstated, so it is only minimally complete.

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

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

Schema coverage is only 50%; hostname has no schema description. The description compensates with a concrete example ('ns1.example.com') and states it is required. sessionKey is already well documented in the schema, so the description need not repeat it.

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

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

Description specifies a precise operation: check availability of a host/glue record name for creation. This distinguishes it from sibling tools like createHost, getHostsForDomain, and validateDomainName by emphasizing the pre-creation availability check.

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?

Clear context: use before creating a host/glue record, and requires authentication. It does not explicitly name alternatives or state when not to use, but the intended use case 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?

With no annotations provided, the description carries the full transparency burden. It does disclose that the tool scans all supported TLDs/registries unless filtered, and that results are detailed. However, it does not state whether this is a read-only operation, what the detailed result structure contains, whether defaults apply, or any rate-limits or side effects—leaving meaningful behavioral gaps.

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

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

The description is compact and front-loaded with the core action, then immediately provides required and optional parameter examples. Every sentence earns its place; there is no filler or repetition of schema fields.

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 purpose and all parameters with examples, which is enough to make a basic call. However, there is no output schema, and 'detailed results' is too vague about the return shape, availability semantics, or default behavior, so an agent cannot fully anticipate the response before 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?

Schema description coverage is 0%, so the description must compensate. It does add semantics by marking keyword as required, registries/tlds as optional, and providing concrete comma-separated example values for each parameter. This gives an agent a better understanding than the bare schema alone, though exact registry/TLD enumeration and dot conventions are not specified.

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

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

The description states a specific verb ('Check'), resource ('keyword availability'), and scope ('across all supported TLDs and registries'). It also signals 'detailed results', which helps differentiate it from the sibling checkKeywordAvailabilitySummary. This is a clear, actionable purpose statement.

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 choose this tool over checkDomainAvailability, checkHostAvailability, or checkKeywordAvailabilitySummary. The description only explains required and optional parameters, not the use case or exclusions. An agent must infer the appropriate context from the tool name and sibling list.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It discloses a key behavioral trait: it returns summary statistics rather than detailed domain results, and that it is faster. However, it does not explicitly state whether the operation is read-only or describe any side effects, though the verb 'Check' strongly implies a safe query. The disclosure 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 only two sentences, with the purpose and primary differentiator front-loaded in the first sentence and parameter guidance in the second. Every word contributes value, and there is no repetition of schema 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 relatively simple read-only summary tool with no output schema, the description covers purpose, scope, speed trade-off, and all parameters with format examples. It does not describe the response format, but 'summary statistics' gives a reasonable expectation. Overall, the essential information an agent needs to invoke it 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 0%, so the description must compensate for the bare input schema. It does: it marks keyword as required with an example ('example'), and identifies registries and tlds as optional with comma-separated format examples ('verisign,pir' and 'com,net'). This adds meaningful semantic guidance for all three parameters beyond their data types.

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: 'Check keyword availability summary statistics' and explicitly contrasts with 'without detailed domain results (faster)', which distinguishes it from the sibling tool checkKeywordAvailability. This gives an agent a precise understanding of what the tool does and how it differs from related 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 phrase 'without detailed domain results (faster)' implicitly tells the agent when to use this tool: when summary statistics are sufficient and speed is preferred over detailed results. It does not explicitly name the alternative tool, but the sibling list includes checkKeywordAvailability, making the contrast clear. No exclusions or when-not-to-use guidance is 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the authentication requirement and implies a read-only aggregate operation via 'total count', which is meaningful context. However, it does not explicitly state that the operation is side-effect-free, what happens with zero instances, or the exact 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?

Two short sentences with zero wasted words. The core purpose is front-loaded in the first sentence, and the authentication requirement is a valuable clarifying second sentence. Every word earns its place.

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

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

For a simple tool with one optional parameter and no output schema, the description is largely complete: purpose, scope, and auth requirement are all covered. The main gap is that no output schema exists and the description does not clarify the exact return shape (e.g., a bare integer vs. an object with a count field), though 'total count' strongly implies a numeric return.

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 fully documents the sessionKey parameter, including its format, origin, and when to include or omit it. The description adds no parameter-level information, so the baseline of 3 applies since the schema does the heavy lifting.

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

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

The description uses a specific verb ('Get') and a specific resource ('total count of VPS instances') with a clear scope ('owned by the authenticated user'). It clearly states an aggregate/count operation rather than a listing operation, which implicitly distinguishes it from listMyVpsInstances, but it does not explicitly name or differentiate any 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 states a precondition ('Requires authentication') but provides no guidance on when to use this tool versus alternatives such as listMyVpsInstances or getVpsInstanceDetails. There are no exclusions, no when-to-use conditions, and no mention of scenarios where the count tool is preferable over listing instances.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does this thoroughly: it reveals that the tool sends a verification email, that calling it again re-sends the email, that no authentication is required, and that account capabilities depend on verification state. It also clarifies that acceptedTerms must reflect the principal's actual consent.

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 long but densely informative. Each sentence earns its place by covering workflow sequencing, state behavior, parameter requirements, or principal-agent semantics. It is slightly heavier than necessary, but the complexity of the onboarding flow justifies most of the length.

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

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

For a multi-step onboarding tool with no annotations and no output schema, the description covers the workflow, state machine, required parameters, and next step very well. The main gap is that it does not describe the response shape, such as whether an account ID is returned or what status object the caller should expect, which would be useful for an agent invoking this 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 0% description coverage, so the description must compensate, and it does. It lists every required and optional parameter with meaningful context: accountType values, phone format (+CC.number), country as 2-letter, the required contact subfields, and the audit-trail purpose of principalReference. This goes far beyond what the bare schema provides.

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

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

The description states a specific verb and resource, 'Create a new OSIR customer account,' and immediately distinguishes it from the follow-up verifyAccount step. It clearly identifies this as the first step of onboarding, so an agent can differentiate it from sibling tools like createContact or verifyAccount.

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

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

The description explicitly says no authentication is required, this is step 1 of onboarding, and the next step is verifyAccount with the emailed code. It also explains when the tool can and cannot be used by describing PENDING_VERIFICATION vs ACTIVE state restrictions, giving clear guidance on when to call this tool versus alternatives.

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

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

No annotations are provided, so the description carries the full burden. It discloses that authentication is required and imposes phone/country format constraints, but it does not mention what happens on success, whether duplicates are allowed, or what the return value contains. These are notable gaps for a mutation tool.

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

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

The description is compact and front-loaded: purpose, authentication, then required/optional fields. Every sentence earns its place, and the field list is easy to scan despite the large parameter count.

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 input requirements are well covered, but the description does not state the response shape or return value, and there is no output schema to fill that gap. It also leaves the sessionKey authentication flow implicit, though the schema partially covers that.

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 only 8%, and the description compensates by enumerating all required and optional contact fields. It adds real meaning by specifying E.164 for phone and ISO 3166-1 alpha-2 for country. It does omit sessionKey, but the schema itself provides a thorough description for that parameter.

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-resource pair, 'Create a new contact', and states the purpose, 'for use with domain registrations.' This clearly distinguishes it from sibling tools such as updateContact, deleteContact, getContact, and listContacts.

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

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

The description gives clear context: create a contact for domain registrations, and it states the required authentication precondition. It does not explicitly explain when not to use it or contrast it with updateContact for existing contacts, but the intended use case is clear.

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

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

With no annotations provided, the description carries the full disclosure burden. It explicitly states that authentication is required and discloses the non-obvious behavior that missing DNS zones are initialized automatically. It does not describe response format, propagation time, or duplicate-record handling, but the key side effects and prerequisites are surfaced.

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 efficient and front-loaded with the core purpose. The parameter guidance is compact and organized, with required vs optional clearly separated, and every sentence adds useful information without redundancy.

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

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

Given the lack of annotations and output schema, the description covers the essential invocation details: authentication, parameter values, defaults, and automatic zone initialization. It falls slightly short by not describing the shape of the response or how to interpret the result, but it is sufficient for a competent agent to make a correct call in most cases.

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 only 14%, so the description must compensate. It does by explaining domain, name, type, content, ttl, and priority with examples and defaults. However, the 'content' parameter is only described as 'record value,' leaving the type-specific format ambiguous for MX, SRV, TXT, and other record types.

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 action and resource: 'Create a new DNS record for a domain.' This clearly distinguishes the tool from siblings such as updateDnsRecord, deleteDnsRecord, getDnsRecord, and listDnsRecords. The type list further clarifies the exact scope of records it can create.

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

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

The description gives clear invocation context, including required vs optional parameters and the automatic zone initialization for newly registered domains, which implicitly tells users they do not need to call initializeDnsZone first. It does not explicitly mention when to prefer an alternative like updateDnsRecord, but the context is strong enough for most routing decisions.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds useful context: authentication is required, this creates a new record, and it provides examples of expected input shapes. However, it does not disclose duplicate handling, response/return behavior, or failure modes.

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 with the action. Every clause serves a purpose: what the tool does, the use case, the authentication requirement, and the required parameters with examples. No filler or redundancy.

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

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

For a simple three-parameter create tool with no output schema, the description provides enough information to invoke it correctly: required inputs, formats, and authentication. It could be improved by mentioning return values or duplicate-host behavior, but those are not critical 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 only 33%, so the description compensates by naming the required parameters and giving concrete examples ('ns1.example.com' and IPv4 addresses). It does not mention sessionKey, but the schema already documents that parameter thoroughly.

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

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

The description states a specific action and resource: 'Create a new host/glue record', and clarifies the use case with 'e.g., for custom nameservers'. This distinguishes it from related siblings like deleteHost, getHostsForDomain, and checkHostAvailability.

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

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

It gives clear context for when to use the tool (creating host/glue records, typically for custom nameservers) and notes the authentication prerequisite. It does not explicitly name alternatives or when-not conditions, so it misses the top score.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states that the tool is BILLABLE, requires authentication, stages rather than instantly creates, returns an actionId, and that the password appears exactly once. This is exemplary transparency for a paid creation flow.

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 long but every sentence carries operational value. It is front-loaded with the billing warning, then prerequisites, parameters, workflow, and critical password-handling instruction. The structure makes it easy to scan and act on.

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 complexity, the absence of output schema, and lack of annotations, this description is remarkably complete. It explains prerequisites, billing, the two-step confirmation flow, what the returned actionId means, what the result contains, and what to do with the password and client settings. An agent has enough to call the tool correctly and follow through.

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 only 20% (sessionKey has a description), so the description must compensate. It adds substantive meaning to all other params: domain must be ACTIVE, localPart is the part before the @, packageId comes from listMailPlans with no default, and term has explicit values with a default. It greatly exceeds what the schema 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 says 'Stage creation of a paid mailbox on a mail-enabled domain,' which is a specific verb and resource. It also distinguishes this staging action from the later executeConfirmedAction step and from related mail tools. An agent can immediately tell what this tool is for and what it is not.

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

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

The description gives an explicit workflow: get a quote with getMailboxQuote, confirm price with the user, then call executeConfirmedAction with the returned actionId. It also says the user can later change the password with setMailboxPassword, providing clear guidance on when to use 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It honestly reveals that this tool only stages the payment session, that user confirmation is required before execution, and that the executed result exposes checkoutUrl, expiresAt, and pollTool. It does not cover failure modes or edge-case behavior, but the two-phase workflow is well explained.

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

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

The description is dense but every sentence earns its place, covering purpose, required/optional inputs, return values, and the full confirmation/polling workflow. It is front-loaded with the main purpose and avoids 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?

There is no output schema, so the description correctly enumerates the key return fields: actionId, checkoutUrl, expiresAt, and pollTool. It also explains the overall flow from staging to confirmation to polling. Minor gaps like input validation, error handling, and exact authentication mechanics remain, but the tool is sufficiently complete for correct invocation.

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

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

Schema description coverage is only 33%, so the description compensates by adding type and default details for amount (double, in USD) and currency (string, default 'USD'). The remaining sessionKey parameter is well described in the schema with its usage and format, so all parameters are interpretable.

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 with a specific verb and resource: 'Stage creation of a Stripe payment checkout session to add funds to account balance.' It distinguishes this from related payment tools by explaining it only stages, and explicitly names the follow-up executeConfirmedAction and polling via getPaymentTransactions.

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 step-by-step usage flow: requires authentication, takes amount and optional currency, returns actionId, then instructs to call executeConfirmedAction after user approval and poll with getPaymentTransactions until balance credit appears. It does not explicitly contrast this with alternatives like previewPaymentFees or payInvoice, but the workflow guidance is strong.

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

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

No annotations are provided, so the description carries the full burden. It flags the operation as DESTRUCTIVE, states that authentication is required, reveals the staged-deletion behavior, and discloses the active-domains constraint. It also explains the critical behavior of returning an actionId that must be used with executeConfirmedAction, which is far beyond what the schema alone provides.

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: destructive warning, key constraint, required parameter, and the confirmation workflow are all delivered in two sentences with no filler. The handoff to executeConfirmedAction is explicitly stated, making the structure highly efficient.

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

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

For a destructive two-phase tool with no output schema, the description explains the key return value (actionId), the required follow-up step, and the blocking condition. It could add detail about the error behavior when a contact is assigned to active domains or clarify what 'summary' means, but the essential invocation and completion flow 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 only 50%: sessionKey is documented in the schema, but contactId has no schema description. The description only repeats 'Required: contactId (string)', which adds no semantic value beyond the schema's type and required flag. It does not explain what contactId represents, where it comes from, or how it maps to the target contact.

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

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

The description opens with a specific verb and resource: 'Stage deletion of a contact.' It also distinguishes itself from the sibling executeConfirmedAction by clarifying that this tool only stages the deletion and returns an actionId for later confirmation.

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 clearly states when to use the tool: when a contact needs deletion, and it explicitly instructs calling executeConfirmedAction with the returned actionId if the user approves. It also provides a key exclusion: the contact cannot be deleted if assigned to active domains. It does not mention non-destructive contact alternatives like updateContact or getContact, but the two-phase workflow is well explained.

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

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

With no annotations provided, the description fully carries the behavioral disclosure burden and does so well: it warns 'DESTRUCTIVE — irreversible', requires authentication, and explains that deletion is staged until a separate confirmation call. This is exactly the kind of high-stakes behavioral context an agent needs.

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

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

The description is three short sentences with no filler. It front-loads the destructive warning, then states requirements, then defines the follow-up action. Every sentence earns its place.

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

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

For a simple 3-parameter tool with no output schema, the description covers everything needed to invoke it correctly: required inputs, authentication, the destructive nature, the returned actionId, and the mandatory confirmation step via executeConfirmedAction. Nothing essential is missing.

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

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

Schema description coverage is only 33%, so the description compensates by explicitly naming domain and recordId as required and giving an example for domain and a type for recordId. The sessionKey parameter is already well described in the schema, so the description's omission there is acceptable.

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 ('Stage deletion of a DNS record') and immediately clarifies that this is a staging action, not the actual deletion. It is clearly distinguishable from updateDnsRecord and executeConfirmedAction, which are its closest siblings.

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

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

The description explicitly states required inputs, the authentication prerequisite, and the exact follow-up flow: present the summary, then call executeConfirmedAction with the returned actionId if approved. It does not enumerate exclusions or alternative approaches, but the workflow context is clear and actionable.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It prominently warns that the deletion is DESTRUCTIVE and irreversible, requires authentication, and clarifies that the actual destructive action happens only after executeConfirmedAction is called. This is excellent transparency for a deletion-capable tool.

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

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

The description is compact and front-loaded: action, danger warning, authentication, required input, and next step all fit in a few sentences. Every sentence contributes necessary operational or safety information without redundant 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?

The description is sufficiently complete for a mutation tool with no output schema: it covers required input, authentication, return value, and the follow-up action. The only minor gap is that the sessionKey usage is not echoed in the description, though the schema already documents it clearly.

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

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

Schema coverage is 50%, so the description must compensate at least partially. It adds a required-hostname note with a concrete FQDN example ('ns1.example.com'), which helps clarify expected format. However, it does not explain the semantic relationship to host/glue records beyond that, and it leaves the sessionKey parameter entirely to 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 action ('Stage deletion') on a specific resource ('host/glue record'), which clearly distinguishes it from sibling delete tools like deleteDnsRecord, deleteVpsInstance, and deleteSshKey. The verb and object make the tool's purpose immediately understandable.

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 operational guidance: authentication is required, hostname is mandatory, the call returns an actionId, and executeConfirmedAction should be called only if the user approves. It does not explicitly contrast this tool with alternative deletion paths, but the staged-deletion workflow is clearly spelled out.

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

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

With no annotations, the description carries the full burden and does well: it discloses immediate mailbox stoppage, data destruction after 14 days, authentication need, and the actionId-based confirmation flow. It does not mention whether staged deletion can be cancelled or idempotency, but the destructive impact and sequencing are clearly communicated.

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

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

Three sentences front-load the core purpose, then cover effects, auth, parameter source, return value, and the next action. Every sentence adds necessary information with no filler or redundancy.

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

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

For a destructive, two-phase operation with no output schema, the description is remarkably complete: it explains the required parameter, the immediate and delayed consequences, the auth requirement, the returned actionId, and the exact follow-up call to executeConfirmedAction.

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 leaves mailboxId undocumented, but the description compensates by noting it is required and sourced from listMailboxes. sessionKey already has a thorough schema description, so the 50% coverage gap is meaningfully filled.

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

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

The description opens with a specific verb-resource pair, 'Stage deletion of a mailbox', which clearly distinguishes this from immediate permanent deletion and from sibling delete* tools. It also explains the staged nature by stating the mailbox stops working immediately but data is destroyed only after a 14-day grace period.

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

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

It explicitly says the required mailboxId comes from listMailboxes, requires authentication, and instructs to call executeConfirmedAction with the returned actionId if the user approves. This provides strong usage context and a clear follow-up, though it does not explicitly list when not to use it or mention any alternative deletion pathway.

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

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

With no annotations provided, the description carries the full burden. It discloses the non-destructive effect on existing servers, the reversibility of adding the key again, and the authentication requirement. This goes beyond a bare 'delete' statement and helps an agent anticipate consequences.

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 action is stated first, followed by the most decision-relevant caveats. Every sentence contributes either operational guidance or behavioral context, with no filler.

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

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

For a two-parameter delete operation with no annotations and no output schema, the description adequately covers purpose, side effects, reversibility, authentication, and parameter sourcing. It doesn't describe return values or error behavior, but those are less critical for this simple 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?

The description adds real value for the required keyId parameter by specifying it is an integer and directing the agent to listMySshKeys as the source. The sessionKey parameter is already documented in the schema, so the 50% schema coverage is compensated where it matters most.

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

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

The description opens with a specific verb and resource: 'Remove an SSH key from your account.' This clearly distinguishes it from sibling tools like addSshKey and listMySshKeys, and explicitly says the deletion is scoped to the account.

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

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

The description gives clear context: the key is removed from the account but not from already-built servers, and it can be re-added later. It doesn't explicitly name alternatives like addSshKey, but the behavioral context is enough for an agent to infer the appropriate use case versus other SSH-key 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It openly warns that the action is destructive and irreversible, states that authentication is required, and clarifies that this is only a staging step returning an actionId rather than an immediate deletion. This is strong transparency for a destructive tool.

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

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

The description is compact and front-loaded, starting with the destructive warning and then explaining the required workflow. Every sentence serves a purpose, with no filler or redundant background.

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, no-annotations, no-output-schema tool, the description covers the essential workflow, safety concerns, authentication, required input, and follow-up action. Minor gaps exist, such as not mentioning how to obtain the instanceId or explicitly distinguishing this from other deletion-related tools, but the core information an agent needs 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 coverage is only 50%, with instanceId lacking a schema description, but the description merely restates 'Required: instanceId (string)' without adding meaningful semantics such as where to find the ID or any format constraints. The sessionKey parameter is already well described in the schema, so the description adds almost no value beyond the structured data.

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 ('Stage deletion/cancellation') and a clear resource ('VPS instance'), making it immediately distinguishable from sibling tools like deleteHost, deleteSshKey, and deleteContact. The two-step nature is also implied by 'Stage' and the reference to executeConfirmedAction.

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

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

The description gives clear usage context: requires authentication and must be followed by executeConfirmedAction only if the user approves. It does not explicitly list exclusions or when not to use the tool, but the resource-specific wording and workflow make the intended usage clear.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly. It discloses that the operation is free, publishes DNS records automatically or returns them for manual publication, and warns that takeoverConfirmed=true repoints a foreign MX and moves live email. It also explains the PENDING_DNS state and the need for explicit user consent on conflict.

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

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

The description is dense but every sentence adds value. It starts with the core purpose, then pricing and auth, then required/optional parameters, and finally the conflict-handling flow. It is well-structured and front-loaded, 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?

The tool has five parameters and no output schema, but the description covers all needed call context: ownership, authentication, DNS mode behavior, follow-up via verifyMailDns, and the consent-and-retry flow for conflicts. An agent has enough information to invoke it correctly and handle failures.

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?

Given only 20% schema description coverage, the description compensates by explaining the meaning of domain (owned), dnsMode (both enum-like options and their consequences), spfMergeConfirmed (replace foreign SPF), and takeoverConfirmed (repoint foreign MX). This goes well beyond the schema, which only describes sessionKey.

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: 'Enable email hosting on a domain you own.' It clearly distinguishes the tool from siblings like createMailbox, verifyMailDns, or listMailDomains by defining the core action and its ownership prerequisite.

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: requires authentication, domain ownership, and the domain must use our nameservers for the default dnsMode. It also explains the alternative EXTERNAL_MANUAL flow and how to handle DNS conflicts, though it does not explicitly state when not to use the tool or name sibling alternatives.

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

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

With no annotations provided, the description carries the burden of explaining behavior. It discloses that the action is destructive or financial, that it expires after 5 minutes, and that it can only be executed once. This is strong behavioral context, though it stops short of describing side effects, error cases, or what happens after execution.

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

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

Three short sentences with no filler. The main purpose is front-loaded, and each sentence adds a distinct piece of critical information: what it does, the required parameter, and the constraints on execution.

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 no output schema and no annotations, the description covers the essential operational details: prerequisite, approval requirement, expiry, and one-time use. It does not enumerate which staging tools produce actionId or what the response contains, but the core calling context is sufficiently complete.

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

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

Schema description coverage is 50%. The description compensates for the undocumented actionId by explaining that it is the UUID returned by the staging tool and is required. The sessionKey parameter is already described well in the schema, so the description does not need to repeat it.

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

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

The description uses a specific verb ('Execute') and clearly identifies the resource ('a previously staged destructive or financial action after user approval'). It distinguishes this tool from siblings that create, modify, or pay for resources because it is explicitly the confirmation/execution step for a staged action.

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 clearly states the context for use: only after user approval and only with the actionId returned by the staging tool. It does not explicitly name alternative tools or list when-not-to-use cases, but the staging-and-approval precondition 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It says the tool 'generates' suggestions but does not reveal whether this is a read-only operation, what the response contains, how results are ordered, or whether TLDs are validated against a known list.

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, efficient sentence that leads with the core action and then packs required and optional parameters with examples. No filler or redundant wording is present.

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

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

The tool has no annotations and no output schema, so the description must carry more context. It covers parameters and core purpose, but it omits return-value shape, limitations, and any relationship to sibling tools. This is minimum viable but leaves clear gaps for an agent deciding between similar suggestion 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 description coverage is 0%, yet the description adds meaningful semantics for all five parameters, including allowed formats, example values, and a default for maxResults. It could be slightly richer (e.g., what 'useNumbers' actually controls), but it compensates well for the empty 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 tool's function: generating domain name suggestions from keywords, with a concrete example ('mycompany'). However, it does not differentiate from closely related siblings like bulkDomainSuggestions or spinDomainWords, so the agent must infer which one fits the task.

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 such as bulkDomainSuggestions, suggestAlternatives, or spinDomainWords. The description only explains parameters, not the intended use case 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?

No annotations are provided, so the description carries the full burden. It discloses the authentication requirement but says nothing about failure behavior, return format, currency, or whether repeated calls have side effects. The verb 'Get' implies a read operation, but this is left implicit rather than stated.

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

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

Two short sentences with no wasted words. The core purpose is front-loaded, and the authentication note is placed after the main action, making the description easy to parse quickly.

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

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

For a simple one-parameter read tool, the description covers the essential purpose and authentication requirement, and the schema handles the parameter documentation. However, with no output schema, the description does not indicate what the balance value looks like, and it offers no comparison against getAccountSummary, leaving some context 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 100%, and the sessionKey parameter is already fully documented in the schema, including the osk_ prefix and when to pass or omit it. The tool description adds no new parameter-level meaning, 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 uses a specific verb and resource ('Get the current account balance') and clearly scopes it to the authenticated user. It doesn't explicitly distinguish itself from sibling getAccountSummary, but the phrase 'account balance' makes 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 a precondition ('Requires authentication') but no guidance on when to choose this tool over alternatives such as getAccountSummary or getAuthStatus. There is no mention of when not to use it or what differentiates it from related account tools.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It does state that authentication is required, which is a useful prerequisite. However, it does not disclose read-only status, potential backend aggregation cost, or behavior on missing or invalid credentials beyond requiring authentication.

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 resource, uses a colon to enumerate the included data categories, and ends with the auth requirement. It has no filler words; every clause adds concrete 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 no output schema, the description compensates by listing the key components of the returned summary (profile, balance, domain count, VPS count, pending transfers), giving an agent a concrete idea of what to expect. It also covers the auth prerequisite. It does not specify the response shape or field types, but for a low-complexity optional-parameter tool that is a minor gap.

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

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

The sole parameter sessionKey is already fully described in the schema, including its format (osk_...), when to pass it (device flow), and when to omit it (OAuth), so schema coverage is 100%. The tool description itself adds no parameter details, placing it at the baseline for high 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 names a specific verb ('Get') and resource ('comprehensive summary of the user's account') and enumerates the exact contents: profile, balance, domain count, VPS count, and pending transfers. This clearly scopes the tool apart from the many sibling getters, each of which targets a single data category.

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

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

No explicit when-to-use or when-not-to-use guidance is provided relative to sibling tools such as getAccountBalance, getMyProfile, or listPendingTransfers. The 'comprehensive summary' phrasing implies it is an aggregating alternative, but the description never states that an agent should prefer it over multiple individual calls or when it should be avoided.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses that the tool returns status and token expiry and explains the sessionKey behavior, which is helpful. It does not mention side effects, auth requirements, or error behavior, but 'Check whether...' reasonably implies a non-mutating 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?

The description is three short sentences with no filler. It front-loads the purpose, then states return values, then gives the parameter usage guidance. Every sentence earns its place and the whole is easy to scan.

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

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

For a low-complexity status-check tool with one optional parameter and no output schema, the description covers the essential points: what it checks, what it returns, and how to handle sessionKey. It could mention how to interpret the authenticated status or what happens when unauthenticated, but this is not a major gap.

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

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

Schema coverage is 100%, so the schema already documents sessionKey clearly. The description adds value beyond the schema by explaining where the key comes from ('from checkDeviceLoginStatus') and specifying when to pass it versus omit it, which is not present in 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 uses a specific verb and resource: 'Check whether the current session is authenticated' and states what it returns ('authenticated status and token expiry'). It is clear about the tool's core function, but it does not explicitly differentiate from the similar sibling checkDeviceLoginStatus.

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 on when to include sessionKey: 'Pass it on every call when logged in via the in-chat device flow; omit when connected via OAuth.' It also references checkDeviceLoginStatus as the source of sessionKey. However, it does not explicitly state when to prefer this tool over sibling alternatives.

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

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

The description discloses important authentication requirements, which is useful since no annotations are present. However, it does not describe what happens on missing/invalid contactId, what response shape to expect, or whether the operation is strictly read-only beyond the verb 'Get.'

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, front-loaded, and contains no filler. Each sentence contributes either the core purpose or the key call constraint (authentication and required parameter).

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 get-by-ID tool, this is minimally adequate: it names the resource, the required parameter, and the auth requirement. But with no output schema and no annotation context, the description omits useful details about response contents, error behavior, and the OAuth vs sessionKey distinction that the schema only partially covers.

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 only restates 'Required: contactId (string),' which duplicates the schema's required/type declaration and adds no meaning about how to obtain or use the contactId. It does not mention the sessionKey parameter at all, leaving the schema's sessionKey description as the only real guidance for that parameter.

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: 'Get detailed information about a specific contact.' This clearly distinguishes it from sibling list/create/update/delete contact tools and implies a lookup action by contactId.

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

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

It provides clear context: use this when you need detailed information for one specific contact. It does not explicitly name alternatives like listContacts or getContactsForDomain, but the 'specific contact' framing gives enough direction for an agent to select it over list-style siblings.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that authentication is required, which is useful behavioral context. Yet it does not state whether the operation is read-only, what happens if the domain has no contacts, or any error/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 a compact two-sentence definition, front-loading the action and scope, then adding authentication and the required parameter. No redundant or filler language.

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 getter with two parameters and no output schema, the description covers the core purpose, authentication requirement, and required domain argument. It could be more complete with explicit alternative guidance or return-shape hints, but the essential information for invoking the tool 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?

The description compensates for the missing domain parameter description by providing an example ('example.com') and clarifying that the contacts are 'assigned to a domain.' The sessionKey parameter is already fully described in the schema, so the combined coverage is adequate.

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 ('Get') and resource ('contacts assigned to a domain'), and enumerates role types (registrant, admin, tech, billing). This clearly distinguishes it from sibling tools like getContact (single contact) or listContacts (by filtering 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?

The description implies when to use it: whenever you need all contact roles for a specific domain. However, it does not explicitly mention when not to use it or point to alternatives like listContacts or getContact, so the agent is left to infer the boundary from the domain-specific wording.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds 'No authentication required,' which is a useful behavioral note. However, it does not mention whether the operation is read-only, whether pagination exists, or how results are ordered/returned, though 'Get all' implies a non-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?

The description is a single, front-loaded sentence that states the purpose and the key auth requirement with no wasted words. Every piece of information is relevant.

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 no-parameter catalog-fetch tool, the description is largely complete: it specifies the resource type, the data included (pricing and specifications), and the auth requirement. The absence of an output schema and pagination details is a minor gap but acceptable given 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?

The tool has zero parameters, so the baseline is 4. The description correctly does not invent or explain parameters, and since the schema is empty, no parameter documentation is needed.

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

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

The description states a clear verb and resource: 'Get all available dedicated server configurations with pricing and specifications.' 'Dedicated server configurations' distinguishes it from VPS-related siblings like listVpsPackages and from broader catalog tools like getProductCatalog, though it doesn't explicitly contrast with those alternatives.

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

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

No guidance is given about when to prefer this tool over siblings such as getProductCatalog, listVpsPackages, or getVpsPackageDetails. The description does not mention filters, prerequisites, or alternatives, leaving the agent to infer the appropriate context from the tool name alone.

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

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

With no annotations, the description must carry the behavioral burden. 'Get details' implies a read-only operation, and 'Requires authentication' discloses a precondition. It lacks explicit statements about lack of side effects, return shape, or error behavior, but for a simple read tool this is acceptable.

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 contain all essential information: purpose, authentication requirement, and required parameters with an example. There is no fluff or redundancy, though 'Required:' partially restates the schema's required array.

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

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

For a simple 3-parameter read tool with no output schema, the description covers purpose, authentication, and required args, including a domain format example. It could note how to obtain recordId (e.g., from listDnsRecords), but the param name and sibling tool make this inferable.

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 only 33%, so the description must compensate. It adds a concrete domain format example, but for recordId it merely repeats the string type without semantic context such as where the ID comes from. sessionKey is already well-described in the schema, so the description adds little over the structured data.

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 ('Get') and resource ('details of a specific DNS record'), clearly indicating a single-record read operation and distinguishing it from listDnsRecords or mutation tools. It does not explicitly name a sibling or contrast itself, so it stops short of the strongest possible differentiation.

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

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

The description states prerequisites: authentication is required, and both domain and recordId must be supplied. It gives a useful domain format example, but does not explain when to choose this tool over listDnsRecords or describe any exclusion conditions, leaving usage guidance mostly implicit.

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

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

With no annotations, the description must disclose behavioral traits itself. It adds 'Requires authentication', but does not mention that this is a read-only operation, what the audit trail contains, pagination, or any limits.

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 with the core purpose. 'Requires authentication' adds value, but 'Required: domain (string)' largely duplicates the input schema.

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 two parameters, the description covers purpose and authentication but, with no output schema, it does not describe the expected return structure or any audit trail filtering/pagination 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?

Schema coverage is only 50% because 'domain' has no schema description. The description reaffirms domain as required and ties it to a specific domain, but does not explain its format or address sessionKey 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 specific verb ('Get') and resource ('audit trail ... for a specific domain'), and clarifies it is the history of all changes. It is clear on its own, though it does not explicitly contrast with sibling tools like getMyAuditLogs.

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 a specific domain' implies the natural use case: retrieving change history for one domain. However, it does not state when to prefer this over getMyAuditLogs/getRecentActivity or 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add one useful fact—'No authentication required'—and the 'get' prefix implies a read-only operation. However, it does not mention response format, pagination, currency, or caching behavior, which are relevant for a tool that returns pricing data.

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 that conveys scope, output content, and authentication status without any filler or repetition. Every word contributes useful information.

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

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

For a zero-parameter list operation, the description states what is returned ('all available domain extensions ... with pricing information') and that no auth is required, which is sufficient for an agent to select and invoke it. It lacks explicit details about response structure or currency, but the core contract is clear enough for this simple 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 tool has zero parameters and the schema has 100% coverage with an empty properties object. Per the rubric, 0 params earns a baseline of 4; there is no parameter information for the description to add.

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 names the resource ('domain extensions (TLDs)') and the verb ('Get'), and specifies that pricing information is included. However, it does not differentiate this from the sibling tool listCategorizedTlds, which may also return TLD data, so the purpose is clear but not fully distinguished.

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 about when to use this tool versus listCategorizedTlds or other TLD-related tools. The description only states what the tool does and that no authentication is required, leaving usage decisions entirely 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?

With no annotations, the description must carry behavioral disclosure. 'Get' clearly implies a read operation and the listed fields indicate the output, but the description does not state whether the domain must be managed/owned, mention authentication prerequisites, or note error behavior. It is not misleading, just thin.

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?

Definition is a single front-loaded sentence followed by the required-parameter hint. No filler; every phrase 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 two-parameter read-only getter, the core call shape is clear, and the schema covers sessionKey. However, with no output schema, the description only partially enumerates return fields and does not clarify preconditions or when this tool applies versus sibling lookup 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 coverage is only 50%: domain lacks a schema description, and the tool description fills that gap with an example ('example.com'). The sessionKey parameter is already thoroughly documented in the schema, so no additional description is required there.

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 ('Get') and resource ('detailed information about a domain'), and names concrete fields (expiration date, nameservers, status). It does not explicitly contrast with sibling tools like checkDomainAvailability or getDomainAuditTrail, but the field list makes the general-info purpose recognizable.

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

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

There is no guidance about when to choose this tool over related siblings (e.g., listUserDomains, checkDomainAvailability, getDomainAuditTrail). The only usage hint is the required domain example, which is input guidance, not decision guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does state the authentication requirement and the optional filtering behavior, which are useful. However, it omits what happens when the optional extension is omitted, the response structure, and whether pricing includes renewals or transfers, leaving meaningful behavioral gaps.

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

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

The description is two short sentences with no filler. It front-loads the core purpose, then states the authentication requirement and the optional parameter in a compact, scannable way.

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 adequate for a simple optional-parameter getter, but it lacks clarification of default behavior when no extension is provided and does not explain the return format. It also does not position itself relative to related tools like getDomainExtensions or getProductCatalog, which would improve 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?

The schema leaves the extension parameter completely undocumented, and the description compensates by explaining it is optional and used to filter results, with concrete examples ('com', 'net', 'org'). The sessionKey parameter is already well described in the schema, so the description does not need to repeat it.

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

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

The description states a specific verb and resource: 'Get pricing for domain extensions from the product catalog.' This is clear and distinguishes it from broad catalog tools like getProductCatalog by narrowing to domain extensions. However, it does not explicitly differentiate from sibling getDomainExtensions, which could also involve domain extension data.

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 explicit guidance on when to use this tool versus alternatives such as getDomainExtensions or getProductCatalog. It does mention 'Requires authentication' and an optional filter, but these are operational details, not usage-vs-alternative guidance.

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

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

With no annotations provided, the description carries the full burden and does so well: no authentication required, free builds, going live runs on a VPS, prices are display-only, and the authoritative amount is computed at purchase. These are non-obvious behavioral details beyond a simple 'get'.

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-load the purpose, then add necessary usage and pricing caveats. There is no filler, no repetition of the tool name, and every sentence contributes actionable 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 one-parameter getter with no output schema, the description is nearly complete: it lists what the response will contain, states call timing, and warns about price display semantics. The only minor omission is a precise output shape, but the listed categories and caveat cover the agent's needs.

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%, but the description identifies the only parameter and gives a concrete format example ('domain (e.g., 'example.com')') and clarifies it should be the domain from an availability check/registration context. For a single string parameter, this is adequate compensation.

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 ('Get') and resource ('hosting options and exact prices for a specific domain'), and enumerates the included categories: VPS packages, email plans, web forwarding, and app/site deployment. This clearly differentiates it from sibling tools like getDomainPricing or listVpsPackages.

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

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

It explicitly tells the agent when to call ('ONCE after a successful availability check or registration') and when not to ('do not repeat the offer in the same conversation'). This is actionable routing guidance, even though no sibling 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?

With no annotations provided, the description carries the behavioral disclosure burden. It states that authentication is required, which is useful, and the verb 'List' clearly implies a read-only operation. It does not, however, describe any behavioral nuances such as whether the result includes only exact matches, whether subdomains are included, or what the response shape will be.

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. It front-loads the core purpose, then adds the authentication requirement and the key parameter detail. Every sentence contributes meaningful guidance.

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 straightforward listing tool with only two parameters, the description covers the essential context: what it returns, that authentication is needed, and which parameter is required. There is no output schema, but the phrase 'List all host/glue records associated with a domain' sufficiently communicates the expected result. A small gap is the lack of any mention of the sessionKey parameter, though the schema covers it.

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

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

The schema only documents sessionKey, leaving domain with no description, so schema coverage is only 50%. The description compensates for the undocumented domain parameter by providing a clear example: 'e.g., \'example.com\''. It also reinforces that domain is required. The sessionKey semantics are fully handled by the schema, so the description does not need to repeat them.

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

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

The description uses a specific verb and resource: 'List all host/glue records associated with a domain.' This clearly distinguishes it from siblings like getDnsRecord, listDnsRecords, and getContactsForDomain. The purpose is immediately understandable without needing to inspect the schema.

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

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

The description gives useful context: it is for listing host/glue records for a domain, requires authentication, and the domain parameter is required. However, it does not explicitly state when to prefer this over sibling tools such as listDnsRecords or getDnsRecord, or when it should not be used. The usage is mostly implied rather than explicitly guided.

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

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

With no annotations, the description discloses the essential auth requirement and the read-like nature of 'Get,' plus that line items are included. It does not describe possible errors, response shape, or side effects, but for a simple fetch tool these omissions are moderate rather than severe.

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-load the core purpose and add the auth note. The 'Required: invoiceId (string)' fragment is redundant with the schema, but the overall size is appropriate.

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 adequate for a simple retrieval tool: it identifies the target, the auth requirement, and that line items are returned. It lacks guidance on where invoiceId comes from (likely listInvoices) and what errors/return shape to expect, and there is no output schema or annotations to cover those 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 description merely restates that invoiceId is required and a string, which duplicates the input schema and adds no meaning about how to obtain or use it. The sessionKey parameter is well documented in the schema, but the description does not compensate for invoiceId's missing schema description.

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

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

Description states a specific verb and resource: 'Get detailed information about a specific invoice including line items.' This clearly distinguishes it from list-oriented siblings like listInvoices and getInvoiceStatistics by emphasizing a single invoice and its line items.

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

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

The intended use is implicit: call this for one invoice's details rather than listing invoices. However, it never explicitly names alternatives, when-not-to-use conditions, or the prerequisite of obtaining invoiceId from listInvoices; 'Requires authentication' is a prerequisite, not usage-routing guidance.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does add 'Requires authentication' and the verb 'Get' implies a read-only operation, but it does not explicitly confirm non-mutating behavior, error scenarios, or behavior when no invoices exist.

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

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

The description is a single compact sentence that front-loads the operation and result fields, then adds the authentication requirement. There is no wasted wording 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 low-complexity call with one optional parameter and no output schema, the description adequately names the summary fields and the auth prerequisite. It could further clarify whether statistics cover all invoices for the authenticated user or a specific period, but this is a minor gap given 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?

Schema description coverage is 100% and the single optional sessionKey parameter is already fully documented in the input schema. The description adds no additional parameter-level meaning, 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 a specific operation: 'Get summary statistics of invoices' and enumerates the output fields (total paid, pending, overdue amounts). It distinguishes itself from detail/list tools through the word 'summary', though it does not explicitly name siblings like listInvoices or getInvoiceDetails.

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

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

No explicit guidance is given on when to use this tool versus closely related alternatives such as listInvoices, getInvoiceDetails, or getPaymentTransactions. The intended use is merely implied by the name and phrase 'summary statistics', with no when/when-not conditions or alternative routing.

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

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

No annotations are provided, so the description carries the full burden. It clearly communicates that this is a non-binding, display-only quote, that authentication is required, and that the backend re-derives the authoritative price at purchase. It does not describe the response shape or error behavior, but the essential behavioral caveats are present.

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

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

Three compact sentences front-load the purpose, then state required and optional inputs, and end with an important caveat about price authority. There is no filler, no tautology, and no unnecessary repetition of the tool name.

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

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

For a read-only quote tool with only three parameters and no output schema, the description covers the necessary input sourcing, term choices, authentication, and the non-authoritative nature of the quote. It does not specify the return shape, but that is a minor gap given the simplicity of the operation and the absence 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?

Schema description coverage is only 33%, but the description compensates well: it explains that packageId comes from listMailPlans and that term accepts MONTHLY or ANNUAL with a default. Combined with the schema's description of sessionKey, all parameters have meaningful guidance.

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

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

The description states a specific verb ('Get'), a specific resource ('mailbox plan'), and a key qualifier ('display-only'), which clearly distinguishes it from purchase or transfer quote tools. It also references listMailPlans as the source of packageId, further grounding the agent in the correct workflow.

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 concrete usage context: authentication is required, packageId must come from listMailPlans, and term accepts MONTHLY or ANNUAL with a default. It does not explicitly name sibling alternatives or state when not to use this tool, but the 'display-only' wording and the 'authoritative price at purchase' caveat make the intended pre-purchase use case clear.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses that the tool is a read operation ('Get'), specifies output semantics in relation to bytes and per-mailbox usage, and calls out the authentication requirement. It does not describe response shape or edge cases, but the core behavior is adequately transparent for a simple read-only tool.

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

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

The description is one focused sentence, front-loaded with the key action and resource, and includes only useful context about quota display and authentication. 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 single-parameter read tool with full schema coverage, the description gives the essential context: what it returns, in what unit, why it is used, and that authentication is required. It could be more complete by describing the return shape or explicitly differentiating from getMailboxQuote, but nothing critical is missing for basic invocation.

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

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

Schema description coverage is 100%, and the sessionKey parameter is fully documented in the schema, including when to pass it and when to omit it. The description adds no additional parameter-level meaning beyond the auth requirement, 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 explicitly states the operation: 'Get disk usage per mailbox in bytes.' It names the exact resource (mailbox), the quantity (disk usage), and the unit (bytes). The phrase 'for quota display alongside the plan's quotaBytes' clarifies its role and helps distinguish it from siblings like getMailboxQuote.

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

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

The description gives a clear use context: this is for quota display next to the plan's quotaBytes, and it notes the authentication requirement. It does not explicitly name alternative tools or state when not to use it, 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?

No annotations are provided, so the description carries the behavioral burden. It discloses authentication requirements and scopes the tool to external DNS management. It does not clarify whether the tool returns recommended records vs. live DNS lookups, how invalid/unconfigured domains are handled, or the response shape, which would be valuable with no 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 compact and front-loaded with the core action and resource. The only minor inefficiency is that 'Required: domain' restates schema information, but the overall length is appropriate and free of unnecessary prose.

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

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

For a simple two-parameter tool with no output schema, the description adequately covers the purpose, the target user scenario, authentication, and representative record types (MX, SPF, DKIM). It stops short of full completeness because it does not define the output structure or explicitly distinguish itself from mail DNS verification and generic DNS record 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 description coverage is only 50%, and the undocumented 'domain' parameter is not explained beyond repeating that it is 'Required'—which the schema already states. The description does not explain domain format or constraints, and it says nothing about sessionKey beyond what the schema already provides. It fails to 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?

Description states a specific action ('Get') and a precise resource: 'the DNS records a mail domain needs (MX, SPF, DKIM, ...)'. This clearly distinguishes it from generic DNS sibling tools like listDnsRecords or getDnsRecord by framing it around mail-domain requirements for externally managed DNS.

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 useful context with 'for customers managing DNS externally' and notes authentication, so an agent can infer the intended scenario. However, it does not explicitly name alternatives like listDnsRecords or verifyMailDns, nor does it state when not to use this tool. Usage guidance is implied rather than explicit.

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

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

With no annotations present, the description carries the behavioral disclosure burden. It does mention an important precondition ('Requires authentication') and the broad scope, which is useful. However, it does not disclose the authentication flow tied to sessionKey, potential error conditions, rate limits, or pagination behavior details, leaving some gaps for a definition with no annotation support.

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 with the core purpose, followed by authentication and parameter hints. The final sentence about optional parameters is slightly redundant with the schema, but it keeps the description scannable without adding significant bloat.

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 paginated endpoint with no output schema, the description covers the essential context: what is returned, whose logs, across what scope, and that authentication is needed. It is not fully exhaustive about return shape, ordering, or pagination defaults, but those are reasonably inferable for a retrieval tool of this 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?

Schema description coverage is only 33%, so the description needed to compensate for under-documented parameters. It only repeats that page and size are optional integers, which the schema already communicates, and it does not explain the meaning of page/size or mention the sessionKey parameter at all. The useful sessionKey guidance lives only in the schema, not 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 verb 'Get', the resource 'recent audit logs', and a precise scope: 'for the authenticated user across all services'. It is specific and readable, though it does not explicitly differentiate itself from similar sibling tools like getRecentActivity or getDomainAuditTrail.

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

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

The description provides clear context: this is for the authenticated user and spans all services, and it explicitly notes that authentication is required. It does not mention when to prefer alternatives such as getRecentActivity, but the scope statement gives enough context for an agent to judge basic applicability.

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

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

With no annotations, the description carries the burden and it does disclose the auth requirement and the returned data shape. It doesn't explicitly state read-only behavior or failure modes, but 'Get' plus the field list makes the side-effect profile reasonably inferable.

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-loads the operation, lists the key returned fields, and adds the auth prerequisite with no filler. Every clause contributes.

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-required-parameter profile getter with no output schema, the field enumeration and auth note make the call outcomes clear. It is slightly incomplete in not routing the agent away from getAccountSummary/getAccountBalance, but that is not essential for invoking this tool correctly.

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

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

Schema coverage is 100%, so the sessionKey parameter is already documented. The description's 'Requires authentication' hints at why the sessionKey may be needed, but adds no new parameter-level 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?

The description names a specific operation ('Get the authenticated user's profile and account information') and enumerates the returned fields, so the agent knows what it does. It doesn't explicitly differentiate from getAccountSummary or getAccountBalance, but the 'profile' framing is distinct enough.

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 the prerequisite that the user must be authenticated, which is useful context. However, it gives no guidance on when to prefer this tool over the similar siblings getAccountSummary or getAccountBalance, leaving alternatives 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals only that authentication is required and that the result is scoped to the authenticated user. It does not disclose return format, pagination behavior, defaults, error conditions, or whether the operation is read-only, which is especially important given the absence of an 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 efficient sentence with no filler, and the primary action is front-loaded. It is slightly unstructured (parameters are tacked on as a clause), but overall it is appropriately short and scannable for an agent.

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 three parameters, no annotations, and no output schema, the description is not complete enough. It fails to explain the return shape, pagination semantics, sessionKey usage rules already implied by the schema, or typical use cases. An agent would likely need to guess about defaults and response structure.

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 only 33%, so the description should clarify the undocumented parameters. It mentions 'page' and 'size' are optional integers, but the schema already indicates their types and optionality. It does not explain what page/size control, valid ranges, defaults, or how sessionKey relates to authentication, leaving meaningful gaps.

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

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

The description states a clear verb ('Get') and resource ('payment transaction history') scoped to the authenticated user. It identifies the tool as a history/listing operation, which is distinct from related invoice or balance tools, though it does not explicitly name a sibling to differentiate against.

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 notes that authentication is required and that page/size are optional, giving some operational context. However, it does not say when to prefer this tool over alternatives like getInvoiceDetails, getRecentActivity, or getAccountBalance, nor does it describe any exclusions or limitations.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It usefully states that no authentication is required, and 'Get' implies a read-only operation. However, it does not mention whether the response is paginated, cached, large, or structured in any particular way, leaving some behavioral gaps.

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

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

The description is a single, front-loaded sentence that states the core purpose first, then enumerates the included categories, then adds the auth requirement. There is no wasted wording.

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

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

For a parameterless, read-only catalog retrieval tool, the description is mostly complete: it says what the tool returns, the scope of that return, and that no authentication is needed. It could be slightly stronger by clarifying that this is the umbrella catalog vs category-specific siblings, but that is not essential for correct invocation.

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

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

The tool has zero parameters, so the baseline is 4. The description adds value by clarifying what the returned catalog contains, even though no parameter documentation is needed.

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

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

The description names a specific verb and resource: 'Get the complete product catalog'. It also enumerates the included categories (domain extensions, VPS packages, dedicated servers), which clearly distinguishes it from narrower siblings like getDomainExtensions, getDedicatedServerCatalog, and listVpsPackages.

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 'complete product catalog' implies this is the right tool when a broad catalog is needed rather than a category-specific one, and 'No authentication required' gives an access condition. However, it does not explicitly mention alternatives or state when a sibling tool such as getDedicatedServerCatalog or getDomainExtensions should be preferred.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It does state that authentication is required and that the activity spans all domains and services, which is useful. However, it does not disclose whether the call is read-only, pagination/limits, or what form the returned activity takes.

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

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

The description is one sentence, front-loads the action and scope, and contains no filler. Every word contributes.

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 optional-parameter read call the description is mostly sufficient, but with no output schema it does not describe what the agent should expect in the response or the recency window. It also does not point to sibling audit-log tools, leaving some selection ambiguity.

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

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

The schema already documents sessionKey with 100% coverage, including when to pass it and when to omit it, so the description adds little parameter-level meaning. The baseline of 3 applies because the schema does the heavy lifting.

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

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

The description uses a specific verb ('Get') and names the resource ('most recent activity across all domains and services for the user'), so an agent can tell what it operates on. It does not explicitly distinguish this from nearby siblings like getMyAuditLogs or getDomainAuditTrail, so it stops short of full differentiation.

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

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

The description gives no guidance about when to use this tool versus alternatives such as getMyAuditLogs or getPaymentTransactions. It only states that authentication is required, which is a precondition rather than usage direction.

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

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

With no annotations, the description carries the burden of behavioral disclosure, and it does usefully state that authentication is required and enumerate the returned fields. However, it does not explicitly disclose whether the quote is non-binding, whether a transfer is not initiated, or whether any charge occurs.

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-load the purpose and then pack authentication, required input, and return values with no filler. Every sentence earns its place.

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

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

For a simple two-parameter operation with no output schema, the description covers the essential agent needs: authentication, required input, and exact returned values. It is slightly incomplete in not distinguishing from similar transfer-related tools, but those distinctions are secondary for invoking this quote 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 already documents sessionKey well, but the 'domain' parameter has only a type, so the description compensates with a concrete example and a required marker. It does not provide deeper domain-format guidance, leaving some parameter-semantic burden unmet.

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 'Get' and clearly identifies the resource as a transfer price quote for a domain, listing the returned data: price, currency, extension years, and new expiration date. It is clear and distinguishable from name alone, but it does not explicitly contrast it with sibling tools like getTransferStatus or initiateTransfer.

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

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

The description states the operation and authentication requirement but provides no explicit guidance on when to choose this tool over related siblings such as getTransferStatus, initiateTransfer, or getDomainPricing. Usage context is implied by the name and purpose rather than directly 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?

With no annotations, the description carries the behavioral burden. It explicitly states authentication is required and enumerates the returned fields. It also implies a non-mutating operation through 'check' rather than a modification verb, though it doesn't explicitly say 'read-only' or describe error behavior.

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

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

Three short sentences with the main action front-loaded, followed by necessary auth/parameter context, then return values. There is no fluff and the description does not merely restate the tool name.

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

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

For a simple two-param read tool with no output schema, the description covers purpose, auth precondition, required argument, and the fields the caller will receive. An agent has enough to invoke it correctly and interpret the result.

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

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

Schema description coverage is only 50%, and the description compensates for the undocumented domain parameter by marking it required and giving an example ('example.com'). It does not repeat sessionKey semantics already documented in the schema, which is acceptable.

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

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

Description opens with a specific verb+resource: 'Check the current status of a domain transfer.' It also lists the return fields (status, request date, current registrar, expected completion), which distinguishes this status tool from mutation/quote siblings like transferDomain, cancelTransfer, and getTransferQuote.

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 prerequisites ('Requires authentication', 'Required: domain') and implies the use case by saying it checks status. However, it never contrasts itself with alternatives such as listPendingTransfers or getTransferQuote, so the when-not-to-use guidance 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?

With no annotations, the description carries the full burden. It discloses 'Requires authentication' and the required instanceId, but does not describe potential errors, permission requirements beyond authentication, or whether the call has side effects. For a read-only 'get' tool this is minimally adequate.

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 fluff. It front-loads the core purpose and then adds the necessary authentication and required-parameter note, making it easy to parse quickly.

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

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

For a low-complexity read tool with one required parameter, the description plus schema is reasonably complete. It states the purpose, the required parameter, and authentication need; the optional sessionKey is already documented in the schema. Some details about response structure or error cases are absent, but nothing critical blocks 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 only 50%, and the description's 'Required: instanceId (string)' merely repeats the schema rather than adding semantic meaning. It does not explain what an instanceId looks like, how to obtain it, or clarify the optional sessionKey, leaving the agent with a partial understanding of the 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 states a specific verb ('Get'), a clear resource ('detailed information about a specific VPS instance'), and a distinguishing aspect ('including resource usage'). This separates it from siblings like listMyVpsInstances and getVpsPackageDetails, which cover listing and package-level details.

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

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

The description implies when to use the tool: when you need detailed information and resource usage for one specific VPS instance. However, it does not explicitly compare with alternatives or state when not to use it, leaving the routing partially implicit.

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

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

With no annotations provided, the description carries the full burden. It adds useful behavioral context: authentication is required and the operation is read-only in intent ('Get detailed information'). However, it does not disclose return format, whether the response includes any nested pricing structures, or any rate-limit/error behavior.

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

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

Three sentences with no filler. The core purpose is first, followed by auth/required-parameter guidance, then a clear routing note. Every sentence earns its place.

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

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

For a simple two-parameter read tool with no output schema, the description covers the essential call context: what it does, auth requirement, required parameter, and when to use a sibling. It does not describe the response shape, which might matter for parsing, but the low complexity keeps this from being a major gap.

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

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

Schema description coverage is 50%; packageId has no schema description, but the description supplies its meaning and requiredness: 'Required: packageId (string)'. It also explains the anonymous alternative. sessionKey is already documented in the schema, so the description adds value where the schema is weakest.

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

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

The description states a specific verb ('Get detailed information'), a specific resource ('specific VPS package'), and a distinguishing scope ('including all pricing tiers'). It clearly differentiates from siblings: listVpsPackages lists packages, getVpsInstanceDetails targets instances, while this targets package details.

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

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

It explicitly says authentication is required, names the required parameter packageId, and provides a direct alternative: 'For anonymous browsing use listVpsPackages'. This tells an agent exactly when to use this tool and when to route to a sibling.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the important safety trait that calling it on existing zones will not overwrite records, and clarifies that registration normally initializes the zone automatically. It does not mention authorization requirements or failure conditions, but the key non-destructive behavior is clearly stated.

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

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

The description is compact and front-loaded. Each sentence adds distinct value: purpose, when it is unnecessary, when it is necessary, safety behavior, and the required parameter with an example. No filler or redundant restatement.

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 relatively simple two-parameter tool with no annotations and no output schema, the description covers the core decisions needed to invoke it correctly: what it does, when to use it vs. not, the required parameter format, and its non-destructive behavior. An agent has enough context to select and call it.

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

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

Schema coverage is 50%, with domain lacking a schema description. The description compensates by marking domain as required and providing a concrete example ('example.com'). The sessionKey parameter is already well documented in the schema, so the description does not need to repeat it.

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

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

The description opens with a specific verb and resource: 'Initialize (create) the DNS zone for a domain.' It clearly distinguishes this tool from related operations like createDnsRecord and registerDomain, and even states when it is not needed.

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

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

Explicit usage guidance is provided: the tool is not needed after registerDomain, and should only be used for pre-existing domains without a zone, such as after a transfer or when registration opted out with initializeDnsZone:false. This leaves little ambiguity about when to invoke 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?

With no annotations provided, the description carries the behavioral burden. It discloses that the call deducts from the account balance, requires authentication, and returns an actionId pending user approval. It does not cover edge behaviors such as insufficient balance or invalid authCode handling, so a 5 is not justified.

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

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

Four concise sentences, each adding necessary value: purpose, financial/auth implications, required parameters, and next-step workflow. The key purpose is front-loaded, and there is 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?

Covers the essential facts: what the tool does, cost, auth, required params, and the expected follow-up action. It does not mention failure modes or explicitly explain when not to use it versus transferDomain, but the staged-confirmation workflow is clearly enough 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 coverage is only 33% (only sessionKey is described), so the description must compensate. It explicitly defines 'domain' with a concrete example and 'authCode' as an EPP authorization code from the current registrar, giving both required parameters meaningful semantics 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 resource: 'Stage initiation of a domain transfer from another registrar.' It clearly distinguishes the staging action from the later confirmation step by telling the agent to call executeConfirmedAction, and from the broader context of transferDomain.

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 a clear workflow: stage the transfer, get the actionId, present the summary to the user, then call executeConfirmedAction. It does not explicitly contrast with sibling tools like transferDomain or cancelTransfer, so it stops short of a full when-to-use vs alternatives guide.

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

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

No annotations are provided, so the description carries the full burden, and it delivers: auth not required, output is structured candidates only, no ranking/scoring, prices are decimal strings, and hasPremium semantics are explained to prevent misinterpretation. It also clarifies what excludePremium does not mean.

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?

Long but well organized with a front-loaded purpose sentence, a numbered workflow, controlled vocabulary lists, and price-format note. Every section earns its place, and there is no repetition of schema fields or 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 tool with no output schema and no annotations, the description explains the return shape (candidates with categories and audience arrays), the pricing format, the intended workflow, and the meaning of each important filter. The only real gap is the unexplained registry parameter, which is minor against the overall 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 0% schema description coverage, the description compensates strongly by explaining maxRegisterPrice, excludeCcTLDs, excludeRestricted, and excludePremium with concrete triggers. However, the registry parameter is never explained, leaving one of five parameters without semantic guidance.

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: 'List TLDs from the OSIR catalog that have category and audience metadata populated.' It also explicitly contrasts itself with ranking/scoring tools, and the usage pattern names bulkDomainSuggestions as the downstream sibling, so an agent can distinguish it from nearby 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?

Provides a numbered usage pattern with explicit next steps, plus conditional filter guidance: maxRegisterPrice for budget-conscious users, excludeCcTLDs for 'no country domains', excludeRestricted for casual mentions of regulated industries, and clear when-not-to-use guidance for excludePremium. This is unusually actionable and complete.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It usefully states that authentication is required and that search is optional, and 'List' implies a read-only operation. However, it does not disclose pagination, response shape, or other runtime 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 and front-loaded with the core purpose. There is minor redundancy in saying 'with optional search' and then 'Optional: search', but overall it remains concise and skimmable.

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

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

For a simple list tool with two optional parameters, the description covers the main behavioral context: authentication requirement, scope, and search semantics. It omits return-format or pagination details, but the operation is simple enough that the description is generally sufficient 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?

The schema only describes sessionKey, leaving 'search' as an undocumented string. The description compensates by specifying that search filters by name, email, or org, which adds meaningful semantics beyond the schema. sessionKey is already well described in 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 identifies a specific verb ('List') and resource ('all contacts for the authenticated user'), which clearly distinguishes it from sibling tools like getContact and getContactsForDomain. However, it does not explicitly name or contrast itself with those siblings, so it stops just short of top-tier differentiation.

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

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

The description establishes clear context: list all contacts for the authenticated user, with optional search. It does not state when to prefer this over getContact or getContactsForDomain, nor does it mention exclusions or alternative conditions. Usage guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It mentions authentication but does not disclose pagination, empty-result behavior, error handling, or whether the domain must exist. Minimal behavioral context for a read-only list 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 tight sentences without filler. The core purpose is front-loaded, followed by authentication and parameter guidance. Every sentence earns its place.

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

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

Adequate for a simple list tool with only one required parameter, but the absence of an output schema means the description should ideally note the return format, pagination, or failure behavior. It covers the minimum viable information but leaves 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 coverage is 50% because domain lacks a schema description. The description adds an example format ('example.com') and confirms domain is required, compensating partially. sessionKey is already well described in the schema, so no additional value is added there.

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 DNS records for a domain'), which clearly distinguishes it from singular getDnsRecord or mutating DNS tools like create/delete/updateDnsRecord. The scope is unambiguous.

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

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

It provides useful context by mentioning authentication requirements and the required domain parameter, but it does not explicitly contrast with sibling tools like getDnsRecord or state when not to use this tool. Usage is implied rather than fully guided.

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

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

With no annotations available, the description carries the disclosure burden. It discloses the authentication requirement and default pagination values, but it does not mention response shape, error behavior, ordering, or whether an absent status means 'all'. This is useful but not rich 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?

The description is short and front-loaded with the main operation, followed by auth and parameter details. The parameter list is slightly redundant with the schema but earns its place by adding enums and defaults; a bulleted layout would improve scannability.

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

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

For a simple list tool with no annotations and no output schema, the description covers the essentials: what is listed, who it is for, optional filters, and pagination defaults. However, it leaves out routing to related invoice tools and any return/error semantics, so an agent is not fully equipped to use it in all contexts.

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 low (25%) because page, size, and status lack schema descriptions. The tool description compensates by enumerating the allowed status values and giving defaults for page and size, adding real meaning beyond the bare property types. It does not go into bounds or interaction between filters, so not a perfect score.

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 starts with a specific verb and resource ('List invoices for the authenticated user') and mentions optional filtering and pagination, making the core purpose unmistakable. It does not explicitly contrast with sibling tools like getInvoiceDetails or getInvoiceStatistics, so it falls short of full 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?

It states a prerequisite ('Requires authentication') and describes configurable options, but gives no guidance about when to choose this tool over alternatives such as getInvoiceDetails or when pagination is appropriate. No exclusions or alternative conditions 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?

With no annotations, the description carries the disclosure burden. It usefully states that authentication is required and enumerates returned fields, and 'List' implies a read-only operation. However, it does not disclose output structure, pagination behavior, or whether the mailbox identifier/address is included.

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

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

The description is one short, front-loaded sentence that immediately states the action and scope. The authentication note is relevant and not redundant.

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