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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals only the core operation—charging a card and adding funds—but omits side effects, irreversibility, failure behavior, authorization requirements, or fund availability, which are material for a financial mutation.

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

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

The description is a single, front-loaded sentence that states the verb, resource, and effect without filler. The API reference link is a helpful addition and does not detract from clarity.

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

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

For a two-parameter tool with no output schema, the description plus schema gives the essential information needed to invoke it. However, for a financial operation, missing context about consequences, response format, and constraints means the agent may need to consult the linked API reference.

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% with clear descriptions and an example for amount. The description adds only marginal context by linking amount to 'add funds' and payment_id to the 'verified card profile,' so it stays at the baseline.

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

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

The description clearly specifies the action: charging a verified card profile and adding funds to the account. This distinguishes it from the many domain-management siblings and from getAccountBalance, which only reads the balance.

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, nor are exclusions or prerequisites beyond the word 'verified' mentioned. The description states what the tool does but not the conditions under which an agent should select it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the core action but does not explain side effects such as billing implications, whether the call is idempotent, or what happens if the domain is not eligible. The included API-reference link may help discovery but does not itself disclose 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 single sentence that immediately states the tool's purpose, and the API reference link is a compact addition. There is no fluff or redundant information.

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

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

For a mutation that turns on auto-renewal for a domain, the description lacks important context: whether the domain must already be registered with the account, whether this commits the user to a charge, and what the response or error behavior looks like. The presence of the API reference link mitigates this slightly, but the description alone is not complete enough for reliable tool 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 already describes the only parameter as 'Domain' at 100% coverage, so the description does not need to add parameter details. The description contributes no additional semantic information about the domain parameter, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Turn on') and resource ('auto-renewal for a domain'), stating exactly what the tool does. The action is unambiguous and is clearly the inverse of the sibling tool removeAutoRenewal, so an agent can distinguish it without opening the schema.

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

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

The description implies the tool should be used when auto-renewal needs to be enabled for a domain, but it provides no explicit when-to-use or when-not-to-use guidance. It does not mention prerequisites such as domain ownership or contrast this with renewDomain or removeAutoRenewal.

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 reveals that the operation is free, but it does not disclose mutation effects, prerequisites, reversibility, or the response/status behavior. For a mutating action 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 sentence with the action and object front-loaded, and it includes a link to reference documentation. Every word earns its place; there is no 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?

This is a simple one-parameter tool, so the core purpose is captured. However, with no output schema and no annotations, the description does not specify return values, failure conditions, or behavior when privacy is already enabled. It is minimally viable but not complete.

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

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

Schema description coverage is 100% and the single domain parameter is already documented in the schema. The description adds no extra semantic detail about domain format, validation, or context, so the baseline score applies.

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

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

The description states a specific action ('Enable'), a specific resource ('a domain'), and the exact feature ('free WHOIS privacy'). It is clearly distinguishable from the sibling removePrivacy and other domain-management 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 intended use is implied by the verb 'Enable' and the resource, but the description provides no explicit guidance on when to use this tool versus removePrivacy or other domain tools, nor any prerequisites or conditions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states a 'Register' action. It does not explain whether this creates a new resource, whether it can be done alongside other nameserver changes, whether it is immediately effective, or what account/domain state is required.

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

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

The description is a single well-formed sentence that immediately states the action and resource, with an API reference link appended. There is no fluff or redundant repetition of parameter names.

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 15-parameter mutation tool with no annotations and no output schema, but the description provides no information about response format, side effects, propagation, or failure modes. The schema is thorough on parameters, but the description does not supply enough operational context for an agent to confidently invoke this among many similar domain 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 100%, with each parameter already having a meaningful description such as 'Host label to create, e.g. ns1' and 'Primary glue IPv4/IPv6 address'. The tool description adds little beyond the word 'glue', so the schema carries the parameter semantics; a baseline of 3 is appropriate.

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

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

The description states a specific verb ('Register') and a specific resource ('a glue nameserver host for a domain'), which clearly conveys what the tool does. This also distinguishes it from sibling tools such as deleteRegisteredNameServer, listRegisteredNameServers, and modifyRegisteredNameServer through the operation and resource.

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 for when to use this tool versus alternatives like changeNameServers or modifyRegisteredNameServer. The intended context is only implied by the verb and resource; there are no exclusions, prerequisites, or decision rules 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 disclosure burden. It does disclose the most material behavioral trait: the tool spends or commits funds. It does not mention whether bids are binding, can be retracted, or how proxy bidding behaves, leaving some gaps, but the financial warning is a meaningful contribution.

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

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

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

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

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

For a simple three-parameter tool with full schema coverage and no output schema, the description plus schema provide the essential context: what the tool does, the required fields, and the financial consequence. It lacks an explicit distinction from buyNowAuction, but that is largely a usage-guidelines concern rather than a completeness gap for executing a bid.

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%: all three parameters (bid, proxyBid, auctionId) already have descriptive text in the schema. The tool description adds no additional parameter-level meaning, 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 starts with a specific verb+resource: 'Place a bid on an auction.' It adds the distinguishing consequence 'Spends / commits funds,' which separates this from read-only auction tools like listAuctions and viewAuction, and from buyNowAuction, making the purpose unmistakable.

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 purpose is stated so directly that the intended context is clear: use it to bid on an auction. The 'Spends / commits funds' warning provides critical context about the impact. However, it does not explicitly name alternatives or state when not to use it, such as preferring buyNowAuction for immediate purchase.

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. 'Spends funds' is a useful, essential warning that this is a financial transaction, but it does not disclose prerequisites such as sufficient account balance, whether the purchase is reversible, or the response on success/failure.

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

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

The description is a single front-loaded sentence with the core action first, followed by the critical financial warning and an API reference link. Every component earns its place and no redundant text 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?

For a one-parameter tool with no output schema, the description covers the core purpose and a key behavioral consequence. It is slightly incomplete because it omits any indication of what the caller should expect in response and does not clarify account-fund prerequisites, though the API reference link partially compensates.

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%: auctionId is already described as 'Auction ID'. The description adds no additional meaning or format details for the parameter, so it remains at the baseline for documented 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 action (buy) and resource (auction listing at the buy-now price), making the tool's function immediately clear. The buy-now qualifier distinguishes it from sibling bidAuction without needing to open the schema.

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

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

The description implies the use case: use when you intend to purchase an auction listing at its fixed buy-now price. However, it does not explicitly contrast with bidAuction or state when not to use it, leaving the routing decision 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It honestly indicates a mutation with 'Set,' but it does not mention that existing nameservers are likely replaced, that ns1+ns2 are effectively required for a valid call, or how partial failures across up to 200 domains are handled. The API link is a fallback, not inline transparency.

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

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

The description is one tightly written sentence plus a reference link. The core action and essential call requirements are 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?

Parameter semantics are nearly fully covered by the schema, and the description supplies the key invocation rule. Still, with no annotations and no output schema, the description does not disclose the response format, batch error behavior, or whether the operation replaces all existing nameservers; the API reference link partially mitigates this.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by making the operative call pattern explicit: 'Provide ns1+ns2 (or nameservers[]),' which is not marked as required in the schema itself. The 200-domain limit is also surfaced in the compact 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 and resource: 'Set nameservers for up to 200 domains.' It conveys the scope and batch nature of the operation. However, it does not explicitly distinguish this tool from sibling tools like modifyRegisteredNameServer or dnsUpdateRecord, 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?

No guidance is provided on when to use this tool versus alternatives. The instruction 'Provide ns1+ns2 (or nameservers[])' explains how to invoke it, but nothing describes when domain-level nameserver changes are appropriate or when to prefer sibling DNS/nameserver 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, the description carries the transparency burden. It adds a meaningful behavioral trait by saying 'right now', indicating a live availability check, and it sets an upper bound of 200 domains. However, it does not disclose response format, error behavior, rate limits, or whether the check has side effects, so the burden is only partially met.

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

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

The description is a single focused sentence with no filler, and the main action is front-loaded. The API reference link is directly useful without bloating the definition.

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

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

The tool is simple with one well-documented parameter, but no output schema exists and the description does not explain what the response contains. The API reference link helps, but an agent still lacks explicit information about the result format or per-domain availability details.

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

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

The input schema already fully documents the domains parameter, including comma-separated string/array and max 200. The description repeats the 200-domain limit but adds no new parameter semantics, 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 uses a specific verb ('Check') with a clear resource ('whether up to 200 domains can be registered') and a time qualifier ('right now'). It clearly serves a different purpose from sibling checkTransferAvailability and other domain 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 this is used before registering domains to verify current availability, but it does not explicitly state when to use it versus sibling tools or when not to use it. It gives useful context ('right now', up to 200 domains) but leaves the routing decision mostly 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 behavioral disclosure burden. It signals that this is a non-mutating check rather than an actual transfer, which is useful, but it does not describe the result format, per-domain reporting, failure behavior, or rate 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 a single, direct, front-loaded sentence with no filler. The API-reference link is the only additional element and is plausibly useful rather than distracting.

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

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

The tool is simple, with one fully documented parameter, so invocation requirements are clear. However, with no annotations and no output schema, the description leaves the response shape and per-domain availability semantics implicit, so it is adequate but not fully complete.

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

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

The input schema already fully documents the only parameter, including accepted formats (comma-separated string or array) and the 200-domain maximum. The description adds no new parametric meaning beyond duplicating 'up to 200'.

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 ('check whether') and resource ('domains can be transferred into the account'), and explicitly scopes it to up to 200 domains. This clearly distinguishes it from checkRegisterAvailability (registration availability) and transferDomain (initiating a transfer).

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 frames the intended use case: determining whether domains are eligible for transfer into the account before performing a transfer. It does not explicitly name alternatives or when-not-to-use cases, but the context is unambiguous and the sibling list reinforces the distinction.

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. The verb 'Get' implies a read-only operation and no modification of the transfer, but the description does not explicitly confirm side effects, required permissions, or what status values may be returned.

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 sentence that expresses the core action with no filler or redundancy. The API reference link is useful and does not detract from the description.

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

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

For a one-parameter read-only tool, the description is minimally adequate. However, there is no output schema and the description does not explain what the returned status looks like, what possible status values exist, or any prerequisites for calling the tool.

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

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

The single parameter 'domain' is fully described in the schema as 'Domain being transferred', so the schema already provides most of the meaning. The description adds the 'inbound transfer' context, but does not add meaningful detail beyond that.

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 operation: 'Get status of an inbound transfer' with a specific verb and resource. It is immediately distinguishable from sibling tools like checkTransferAvailability and transferDomain because it targets transfer status rather than availability or transfer initiation.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that this is for transfers already in progress, nor does it distinguish when to use checkTransferAvailability or transferUpdate* tools instead.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It reveals that the tool mutates state ('Create or update') and explains the forwarding model, but it does not disclose idempotency, whether existing forwards are replaced or appended, permission requirements, rate limits, or any side effects. The external documentation link is not a substitute for self-contained 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 a single, front-loaded sentence that states the verb, resource, and data model efficiently. It includes a documentation link without padding. Every element 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 mutation tool with no annotations and no output schema, the description is thin. It does not explain what happens when the forward already exists, whether all forwarding destinations are replaced, what the API returns on success or failure, or any prerequisites. The external link may help but the description itself is not sufficient for an agent to invoke the tool with confidence.

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 fully documents every parameter. The description adds only a high-level mapping of local part to destination addresses, which is mildly helpful but does not meaningfully go beyond what the parameter descriptions already state. Baseline 3 is appropriate.

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

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

The description states a clear action ('Create or update') applied to a specific resource ('email forward') and clarifies the data model ('local part → destination addresses'). This distinguishes it from sibling tools like listEmailForwards and deleteEmailForward without needing to inspect schemas.

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 'Create or update' implies when to use it — for creating a new forward or modifying an existing one — but it does not explicitly mention alternatives or exclusion criteria. Sibling tools like listEmailForwards and deleteEmailForward are not referenced, so some inference is required.

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 only states that a contact profile is created and contact_id is returned, but does not mention side effects, required authentication, validation rules, or error behavior. For a mutating operation with zero annotation coverage, this is a substantial 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 two short sentences plus a documentation link, with no filler or repetition. The core action and return value are front-loaded. The brevity is a strength, even though behavioral gaps are credited elsewhere.

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 18 parameters, 9 required fields, no annotations, and no output schema, the description should provide more operational context, such as how the returned contact_id is used or what conditions must be satisfied for creation. It only states the action and return value, with a generic link to API reference. The link mitigates but does not make the description self-sufficient.

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 provides 100% coverage, including descriptions for all 18 parameters and a clear required list. The description adds no additional parameter-level meaning, mentioning only the returned contact_id. Baseline 3 is appropriate because the schema already documents the parameters 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 opens with 'Create a contact profile,' a specific verb plus resource that clearly defines the operation. This distinguishes it from siblings like contactUpdate, contactDelete, contactList, and contactDomainAssociate, which all imply different actions. Mentioning the return of contact_id further clarifies the tool's purpose.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives, such as using contactUpdate for modifying an existing profile or contactList for retrieval. Usage is only implied by the verb 'Create' and the tool name.

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 behavioral disclosure burden. It states deletion and the not-in-use condition, implying a destructive and conditional operation, but it does not mention irreversibility, what happens if the contact is in use, or any authorization requirements.

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

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

The description is a single front-loaded sentence that states the action and the key precondition, with an API reference link appended. Every word contributes meaning.

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

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

For a single-parameter tool, the description is mostly complete: it identifies the action, the resource, and a precondition. However, with no annotations or output schema, it does not explain failure behavior when the contact is in use or confirm the permanence of deletion.

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

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

The input schema already documents contact_id with 100% coverage, and the description's 'contact profile' aligns with the parameter meaning. The description adds no extra format, source, or validation guidance, but the schema is sufficient on its own.

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

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

The description uses a specific verb, 'Delete', with a clear resource, 'a contact profile', and adds a distinguishing constraint, 'that is not in use'. This clearly separates it from sibling tools like contactUpdate or contactAdd.

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 'that is not in use' provides clear context for when deletion is allowed. However, it does not explicitly name alternatives such as contactUpdate for modifying an in-use profile or contactDomainAssociate for reassigning 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, the description must disclose behavioral traits, but it only states the basic action and does not mention side effects, overwriting behavior, validation of contact IDs, or required permissions. The external API-reference link may contain more, but the description itself carries little behavioral detail beyond the nominal 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 action, target, and role options without filler. The parenthetical roles are informative and the API reference link is a reasonable supplement.

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 association tool with a well-covered schema, the description gives the essential action but omits usage context and behavioral caveats. Since there is no output schema, a bit more detail about the expected effect or preconditions would make it more complete, but the core information needed to identify the operation is present.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description adds no new meaning beyond grouping roles in parentheses, and it does not explain the relationship between contact_id and role-specific parameters, which the schema already states.

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 ('Attach') and resource ('contact profiles to a domain') and enumerates the four roles (registrant/admin/billing/tech), which provides a clear picture of the operation. It does not explicitly contrast with sibling tools like portfolioDomainAssociate or contactAdd, so it stops 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?

No guidance is given about when to choose this tool over alternatives, and no prerequisites or exclusions are mentioned. The intended use can be inferred from the name and action, but the description leaves the selection criteria to the agent.

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. It does reveal the conditional behavior of the optional contact_id parameter, but it does not state whether results are paginated, what data is returned, or any rate-limit/auth implications. The read-only nature is implied by 'List' but not explicitly assured.

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

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

A single sentence front-loads the main operation and then adds the optional lookup variant, with a link to API reference. No filler or repetition of schema details.

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

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

For a tool with one optional parameter and no output schema, the description covers the two invocation modes clearly. It does not mention pagination or return structure, but those gaps are minor given the tool's simplicity and the embedded API reference link.

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 describes contact_id only as 'Contact profile ID'. The description adds that this parameter switches the tool from listing all profiles to fetching a single one, giving the agent actionable semantic context 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 opens with a specific verb and resource ('List contact profiles') and adds a clear alternative mode ('fetch one by contact_id'). This distinguishes the tool from CRUD siblings like contactAdd, contactUpdate, contactDelete, and non-contact list tools such as listDomains.

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

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

The description makes the core usage explicit: list all contact profiles unless a contact_id is supplied, in which case return a single profile. It does not name alternatives or state when-not-to-use, but the intended context is clear for a read operation among contact management 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 full responsibility for behavioral disclosure. It only says 'Update an existing contact profile' and does not mention whether it performs a partial or full replacement, validation rules, authentication needs, side effects, or response format. The external API reference link is not sufficient inline 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 a single clear, front-loaded sentence with a reference link and no wasted words. It is concise, though it could have used its length to include more usage or behavioral context.

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

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

This is a complex mutation tool with 19 parameters, 10 required fields, no output schema, and no annotations. The description is minimal and does not cover behavior, response expectations, or selection guidance, making it insufficient for an agent to confidently call the tool correctly without external lookups.

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

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

Schema description coverage is 100%, so every parameter already has a clear description. The tool description adds no additional parameter meaning, but the schema carries the workload, so a baseline ​3 is appropriate.

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

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

The description states a specific action ('Update') and a specific resource ('existing contact profile'), and the word 'existing' helps distinguish this from contactAdd and contactDelete. However, it doesn't explicitly enumerate what fields can be updated, relying on the schema for that.

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

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

No guidance is given on when to use this tool versus contactAdd, contactDelete, or contactDomainAssociate. The 'existing' phrasing implies it is for already-created contacts, but no explicit context or exclusions 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 burden; it clearly states the scoped read-only behavior ('domains in the account') and the filtering window. It does not explicitly state the return shape or whether expiring boundaries are inclusive, and only points to an external API reference for those details.

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

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

A single sentence that front-loads the action and resource, with the condition and a reference link. There is no filler or redundant 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 one-parameter count operation with full schema coverage, the description covers the essential call context. The API reference link mitigates the lack of an output schema, though a brief statement that the response is just the count would make it fully self-contained.

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 parameter `daysCount` is already described as a 'look-ahead window in days'; the description repeats this as 'N days' but adds no new format or constraint information 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 uses a specific verb ('Count') and resource ('domains in the account') with an explicit expiration condition, so the operation is clear. It does not explicitly distinguish itself from listExpiringDomains, but the 'Count' wording makes the aggregation intention apparent.

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

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

The intended use is implied: call this when a numeric count of soon-expiring domains is needed, while listExpiringDomains exists for listing details. However, there is no explicit when-to-use/when-not-to-use guidance or named alternative, so the agent must infer the choice.

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 full burden of behavioral disclosure. It only says 'Delete', which implies mutation, but it does not explain whether deletion is permanent, what effects it has, or whether any authorization is required. This is a minimal disclosure, not a transparent one.

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

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

The description is a single concise sentence with the action front-loaded. It contains no redundant filler, though the generic API reference link adds limited specific value. It is appropriately sized but not especially rich.

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 mutation tool with no annotations and no output schema, yet the description only states the operation. It lacks information about return values, error behavior, prerequisites, or how this relates to the existing email-forward lifecycle. An agent can infer the basic action but not confidently handle edge cases or verify success.

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

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

The input schema already describes both parameters: 'domain' and 'email' with the email field noted as 'Local part only, e.g. info'. Schema description coverage is 100%, so the description adds no additional parameter meaning. A baseline of 3 is appropriate because the schema handles the parameter semantics.

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

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

The description clearly states the operation as 'Delete an email forward', using a specific verb and resource. It distinguishes itself from sibling tools like configureEmailForward and listEmailForwards by naming the delete action explicitly.

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

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

There is no guidance about when to use this tool versus alternatives, no mention of prerequisites, and no exclusions. Sibling tools like listEmailForwards and configureEmailForward exist, but the description does not help an agent decide which one fits the scenario.

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

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

No annotations are provided, so the description carries the full burden. It only states the action without disclosing that deletion is likely irreversible, that the glue record must exist, or any permission or rate-limit constraints. The API-reference link is not a behavioral disclosure.

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

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

The description is a single sentence that states the action and resource up front, with no filler. The API-reference link adds a small extra, but overall it is appropriately sized and front-loaded.

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

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

For a simple two-parameter delete, the description plus schema are minimally sufficient, but the lack of any output schema or behavioral notes leaves the agent without information on success/failure responses or side effects. Since it is a mutating operation with no annotations, a bit more context would make it 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 100% and each parameter has a description, so the baseline is 3. The tool description adds no additional meaning beyond the schema; 'Host label to delete' already clarifies current_host.

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 'Delete' and the resource 'registered glue nameserver', clearly distinguishing it from sibling tools like addRegisteredNameServer, modifyRegisteredNameServer, and listRegisteredNameServers. The action and target are unambiguous.

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

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

The description provides no explicit guidance on when to choose this tool over alternatives, nor any exclusions or prerequisites. Usage is only implied by the 'Delete' verb and the resource type, leaving the agent to infer that this is for removing an existing glue record host.

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 only states the action 'Add' without mentioning side effects, API constraints, authentication requirements, or error behaviors. A mutation tool should disclose more about consequences, but the description is silent beyond the purpose.

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 action and includes a helpful API reference link. There is no fluff or redundancy; every element serves a purpose.

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

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

For a mutation tool with no output schema and no annotations, the description is too sparse. It does not mention required permissions, the response shape, whether the operation is idempotent, or any constraints (e.g., domain must exist). An agent may be able to call it correctly using the schema, but it lacks important behavioral and contextual details.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters, including rrtype enums and defaults for rrttl. The description adds no parameter-level information beyond the schema, so baseline 3 is appropriate.

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

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

The description 'Add a DNS resource record' clearly states the verb and resource, making the purpose unambiguous. It distinguishes from sibling tools like dnsListRecords, dnsUpdateRecord, and dnsDeleteRecord by the action verb alone, 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 provides no guidance on when to use this tool versus alternatives such as dnsUpdateRecord or dnsDeleteRecord. There is no mention of prerequisites, typical scenarios, or exclusions, leaving the agent to infer usage solely from the verb 'Add'.

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 full responsibility for behavioral disclosure. It states that a record is deleted, which implies destructiveness, but it does not mention irreversibility, propagation effects, authorization requirements, or any side effects. The API reference link may help, but it does not provide inline 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 a single concise sentence that states the core purpose and includes a reference link. There is no wasted wording, and the essential action is front-loaded.

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

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

The tool is simple with two well-documented parameters, so the schema covers the invocation details. However, with no annotations and no output schema, the description is quite minimal and does not explain destructive behavior or expected return format. The external API reference partially compensates, making this minimally adequate but not 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?

The input schema has 100% coverage, documenting both 'domain' and 'rrid' with descriptions. The tool description adds no additional parameter meaning, but the schema already explains that rrid is the 'Record ID from dnsListRecords', which is sufficient context for correct invocation.

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

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

The description clearly states the action ('Delete') and the resource ('a DNS resource record'), which distinguishes it from sibling tools like dnsListRecords, dnsAddRecord, dnsUpdateRecord, and dnsSecDeleteRecord. The verb is specific and the resource is unambiguous.

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

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

The description implies when to use the tool (when a DNS resource record must be deleted) but provides no explicit guidance about prerequisites, alternatives, or exclusions. The schema's note that rrid comes from dnsListRecords gives some context, but the description itself offers no 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 must carry the behavioral burden. 'List' clearly signals a read-only, non-destructive operation, and 'for a domain' scopes the resource. However, it does not mention authentication prerequisites, whether the domain must already exist in the account, pagination, or the exact record types returned.

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 the primary action front-loaded and an API-reference link appended. It contains no fluff, though the parenthetical link could be considered extra rather than essential.

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 list operation the description is close to sufficient: it names the action, resource, provider, and points to full API docs. The absence of any usage guidance, return-shape hints, or behavioral details beyond 'List' leaves minor gaps, but the low complexity keeps this at a mid score.

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

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

The input schema already describes the only parameter ('domain') with 100% coverage, so the description need not add much. It adds only 'for a domain,' which restates the schema, and offers no format or normalization guidance. Baseline 3 applies because the schema carries the burden.

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

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

The description uses a specific verb ('List'), a clear resource ('DNS resource records'), and names the provider ('NameSilo DNS') with an API-reference link. It is unambiguous about what the tool does, though it does not explicitly distinguish itself from sibling dnsSecListRecords or the DNS mutation tools.

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

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

No guidance is given about when to use this tool instead of siblings such as dnsAddRecord, dnsUpdateRecord, dnsDeleteRecord, or dnsSecListRecords. The read-only nature is inferable from the verb, but the description does not state exclusions or 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 must stand alone. 'Add' indicates mutation but the description does not disclose permissions, side effects, idempotency, or what happens if the domain already has DS records. This is thin for a mutating API call.

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

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

The description is a single sentence with no filler, and the action is front-loaded. The API-reference link is supplementary. It is concise, though brevity alone does not compensate for missing usage and behavior context.

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

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

With no annotations, no output schema, and five required parameters, the description is too sparse. It does not explain the meaning of a DS record in DNS, how this differs from dnsAddRecord, what a successful response looks like, or any expected side effects.

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

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

The schema description coverage is 100% and includes useful details like digest type examples. The tool description itself adds no parameter-level semantics beyond pointing to the API reference, so the baseline score of 3 applies.

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

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

The description says 'Add a DS (DNSSEC) record', which names a specific action and resource type. It clearly identifies this as DNSSEC-specific, which helps distinguish it from generic DNS record tools like dnsAddRecord, even though sibling differentiation is not explicit.

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

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

There is no guidance about when to use this tool versus dnsAddRecord or dnsSecDeleteRecord. It does not mention prerequisites such as DNSSEC being enabled on the domain, nor does it state any conditions that would make this tool the correct choice.

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 only states the delete action but does not mention that the operation is destructive and potentially irreversible, whether it affects DNS propagation, or what authorization is required.

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

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

The description is a single concise sentence with the action and resource front-loaded, plus a useful reference link. It wastes no words, though it could benefit from a bit more structured detail without sacrificing brevity.

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

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

For a destructive operation with five required parameters and no annotations or output schema, this description is too thin. It does not explain how keyTag, digest, digestType, and alg work together to identify the record, nor what happens after deletion or what success/failure looks like.

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

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

Schema description coverage is 100%, so the input schema already documents all five parameters. The description adds no extra meaning beyond identifying the resource type, which is acceptable but does not enrich understanding of how the parameters uniquely identify a DS record.

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 ('Delete') and resource ('DS (DNSSEC) record'), clearly distinguishing it from related tools like dnsSecAddRecord and dnsSecListRecords. The scope is unambiguous even without the tool name.

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

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

No when-to-use guidance or alternatives are mentioned. The description does not explain when to choose this over dnsSecListRecords or dnsSecAddRecord, nor does it mention any preconditions such as the record needing to exist. The API reference link is not a substitute for explicit usage context.

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

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

With no annotations, the description carries the full burden. 'List' makes clear this is a read operation with no mutation, which is useful, but nothing is disclosed about response format, pagination, errors, or whether DNSSEC must already be enabled. The description is sufficient for a simple list call but lacks deeper behavioral detail.

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

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

A single, front-loaded sentence states the action and resource without wasted words. The API reference link is a compact, useful addition that does not clutter the description.

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

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

The tool is simple with one required parameter and no output schema, but no annotations exist to cover safety or side effects. The description does not mention return values, prerequisites, or how it differs from related tools beyond the DNSSEC qualifier. The external link helps but may not be reliably accessible to an agent, so the description itself is only partially 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 100% and the only parameter, 'domain', is adequately documented in the schema. The description adds no extra meaning beyond the schema; it merely restates that the action is 'for a domain'. This matches the baseline of 3 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 uses a specific verb ('List') and resource ('DS (DNSSEC) records') with a clear scope ('for a domain'). It explicitly distinguishes this from the sibling dnsListRecords by specifying DNSSEC DS records, making the tool's purpose immediately 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 phrase 'List DS (DNSSEC) records' implies this is the read-only counterpart to dnsSecAddRecord and dnsSecDeleteRecord, but it never explicitly states when to choose this over dnsListRecords or provides any exclusions. The API reference link offers external documentation but no in-description 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?

No annotations are provided, so the description carries the full burden for behavioral disclosure. It only says 'update an existing DNS resource record', which conveys mutation but does not explain overwrite behavior, whether the existing record is replaced or merged, authentication needs, rate limits, or response behavior. The linked API reference is useful but not part of the description's substance.

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

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

The description is a single sentence with no filler and includes a reference link. The word 'existing' adds meaningful scope, and the structure is front-loaded with the core action and resource. It is concise, though the brevity comes at the cost of substantive 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 mutation tool with six parameters, no output schema, and no annotations, the description is too minimal. It does not clarify where rrid comes from, what the response will contain, or what side effects the update has. The schema covers parameter meaning but not the operational context an agent needs to call the tool confidently.

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

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

The input schema has 100% description coverage for all six parameters, so the schema already documents each parameter's meaning and requirement. The description adds no additional parameter-level detail, which is acceptable under the baseline of 3 when schema coverage is high.

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: updating an existing DNS resource record. The word 'existing' helps distinguish it from creating or deleting records, and the resource type 'DNS resource record' is specific. However, it does not explicitly name sibling tools like dnsAddRecord or dnsDeleteRecord, so sibling differentiation is implicit rather than direct.

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

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

No usage guidance is provided. The description implies the tool is for modifying an existing record, but it does not state when to choose this tool over dnsAddRecord, dnsDeleteRecord, or dnsListRecords. There are no exclusions, prerequisites, or alternative tool mentions.

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 only states the action and does not mention that this is a mutating operation, any domain ownership/prerequisite requirements, side effects on DNS, or what the response contains. This is a significant gap for a configuration-changing 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 concise sentence that front-loads the core action, with a reference URL appended. It is appropriately short and immediately readable, though the URL could be considered boilerplate; overall it earns its place.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, this description is incomplete. It lacks side effects, prerequisites, response format, and any distinction from related forwarding tools. The 100% schema coverage fills parameter gaps but does not address behavior or selection context.

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

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

Schema description coverage is 100%, so each of the 7 parameters is already documented in the schema. The description adds no extra parameter-level meaning, but the baseline of 3 is appropriate since the schema does the heavy lifting and the enums and examples in property descriptions are clear.

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 ('Forward') and a clear resource ('a domain') with a destination ('another URL'), which is unambiguous. It does not explicitly distinguish from the sibling domainForwardSubDomain, but the name and scope make the intended operation clear 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?

The description provides no guidance on when to use this tool versus alternatives like domainForwardSubDomain or dnsAddRecord. There are no prerequisites, context, or exclusions mentioned, leaving the agent to infer usage from the schema 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?

No annotations are provided, so the description bears the full burden of disclosing behavior. 'Create or update' signals mutation but does not explain whether existing forwards are overwritten, whether the operation is idempotent, what response to expect, or whether special authorization/account settings are needed. This is a significant gap for a state-changing 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 extremely concise and front-loaded with the core action and resource. It includes a reference link without adding verbose filler, so every part earns its place.

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

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

With 8 parameters, 5 required, no output schema, and no annotations, the description is too sparse to fully enable correct invocation. An agent still lacks guidance on how create versus update behavior is decided, what the redirect semantics imply, and what a successful result returns. The generic API reference link helps only if accessed externally.

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

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

The input schema has 100% description coverage, so the schema already documents all parameters. The tool description itself adds no additional parameter-level meaning, but because the schema carries the burden effectively, a 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 states a specific action ('Create or update') and a specific resource ('subdomain forward'), which distinguishes it from the sibling tool domainForwardSubDomainDelete and generally from domainForward by naming the subdomain scope. It does not explicitly contrast it with the sibling domainForward tool, so it falls just short of a 5.

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

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

The description gives no guidance on when to use this tool versus the sibling domainForward tool or when a delete operation would be more appropriate. There is no mention of prerequisites, idempotent behavior, or conditions that would make a create versus update distinction relevant.

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 only says 'Delete a subdomain forward' and does not mention irreversibility, permission requirements, side effects, or whether related records are also removed. The API reference link is not a substitute for explicit behavioral detail.

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, direct sentence with no filler. The API reference link is the only addition and is relevant for external details. It is appropriately concise and front-loaded.

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

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

The tool is a simple two-parameter delete operation and the description plus schema covers the core invocation. However, with no output schema and no annotations, information about return values, success/failure behavior, and when this endpoint is appropriate is missing. It is adequate but not 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 100%, so the schema already documents both parameters. The descriptions 'Domain' and 'Subdomain label' are minimally useful but add no additional meaning beyond the schema. This meets the baseline for schema-driven parameter understanding.

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 ('Delete') and a clear resource ('subdomain forward'), making the tool's function immediately obvious. It also differentiates itself from sibling tools like domainForward and domainForwardSubDomain, which likely create or manage forwards rather than delete subdomain forwards.

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 alternatives. Sibling tools such as domainForwardSubDomain and domainForward are related but the description does not explain when to choose domainForwardSubDomainDelete over them.

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 reveals the security effect of locking, but does not mention reversibility, permissions, side effects on pending transfers, or response format. This is minimal but not misleading.

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

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

One concise sentence with no filler; the action and purpose are front-loaded. The link to API reference is an optional extra and does not detract.

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 one-parameter, low-complexity tool, but it omits practical context such as expected output, error conditions, and whether the lock is reversible or requires special permissions. The agent can call it correctly but with limited surrounding knowledge.

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

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

Schema description coverage is 100% for the single 'domain' parameter, so the schema carries the parametric meaning. The description adds no further detail about domain format or constraints, matching the baseline.

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

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

States a specific action ('Lock a domain') and its intended outcome ('prevent unauthorized transfer'), clearly distinguishing it from sibling operations such as domainUnlock. The verb and resource are explicit.

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

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

The purpose phrase implies when to use it (when transfer protection is needed), but it does not explicitly mention alternatives or exclusions. There is no direct contrast with domainUnlock or other domain-management 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 mentions the recipient-existence precondition but does not state that the push transfers ownership away from the current account, whether it is reversible, what happens to associated services, or any auth/lock requirements. For a mutation tool, this is a significant 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 tight sentence with a useful precondition in parentheses and an API reference link. It is front-loaded with the action and contains 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-required-parameter tool with full schema coverage and no output schema, the description plus schema provides enough to make the call: action, target account, domains, and a critical precondition. It is slightly less complete for a potentially irreversible mutation since it omits consequences, but the low complexity keeps the gap small.

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

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

Schema description coverage is 100%, so the schema already documents recipientLogin and domains. The tool description adds no additional parameter meaning beyond the implicit target of 'another NameSilo account,' which is already captured by the schema. 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 opens with a direct verb and resource: 'Push domains to another NameSilo account.' This clearly states the operation and distinguishes it from transfer-related siblings like transferDomain, which handle external registrar transfers. The parenthetical adds a key precondition without confusing the purpose.

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

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

The description implies the use case of moving domains between NameSilo accounts and states that the recipient must exist. However, it does not explicitly name alternatives or say when not to use this tool, leaving the agent to infer routing from the operation itself.

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 states the core effect (domain becomes unlocked and transferable), but does not disclose prerequisites, reversibility, exact consequences for the domain lock status, authentication needs, or potential error conditions.

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

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

The description is a single sentence with no wasted words, and the core purpose is front-loaded. The API reference link is supplementary but not distracting.

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?

Although the tool is simple with one parameter, the description lacks important contextual details: no return value/response behavior, no prerequisites, no conditions under which unlocking might fail, and no explicit linkage to sibling tools like domainLock or transferDomain. The API reference link helps but does not compensate for the missing inline guidance.

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

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

The schema has 100% description coverage for the only parameter, so the baseline is 3. The description does not add additional meaning about domain format, requirements, or edge cases beyond saying 'domain.'

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: 'Unlock a domain so it can be transferred away.' This clearly distinguishes it from sibling tools like domainLock, and the purpose is 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 context: this tool is used to unlock a domain in preparation for transferring it away. It does not explicitly name alternatives such as domainLock or state when not to use it, but the intended use case is evident.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It states that an email is sent but does not disclose side effects, idempotency, rate limits, or what happens if verification is already complete.

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

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

The description is a single front-loaded sentence with no wasted words; the action and resource appear first. The appended external documentation link is of limited direct value to an agent but does not significantly harm clarity.

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

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

The tool is simple and has only one parameter, but important context is missing: when to use it instead of related tools, prerequisites, and what the response means. Since this action sends an external email and there are no annotations, the description is not fully adequate for correct selection and 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 sole parameter 'email' is fully described in the schema as 'Registrant email address' (100% coverage). The description adds no additional format or validation details, so the baseline of 3 is appropriate.

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

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

The description clearly identifies the action ('Send (or re-send)') and the resource ('ICANN registrant email verification message'). It distinguishes the tool from status-related siblings like registrantVerificationStatus, though it does not explicitly contrast with other resend tools.

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

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

No guidance is provided about when to use this tool versus alternatives. The description does not mention prerequisites, such as having a registered domain or valid registrant contact, nor does it point to registrantVerificationStatus for checking verification state.

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. 'Get' implies a read-only operation and 'current balance' defines scope, but there is no mention of authentication, rate limits, or what the response contains. Adequate for a simple getter, but not richly transparent.

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

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

One sentence with zero wasted words, front-loading the operation and resource, and including a link to the API reference. Efficient and to the point.

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, low-complexity read operation, the description is nearly complete. The absence of an output schema and lack of detail about the return value format are minor given how simple the tool is, and the API reference link helps fill 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 tool has zero parameters, so there is no parameter ambiguity. The description does not need to compensate for schema gaps, and the baseline of 4 applies.

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

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

The description uses a specific verb ('Get') and a clear resource ('current NameSilo account funds balance'), making the tool's purpose immediately obvious. It is clearly distinct from related siblings like addAccountFunds.

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

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

The description gives no guidance on when to use this tool versus alternatives, and does not mention any related tools or prerequisites. The usage context must be inferred entirely from the name and description.

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

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

No annotations are provided, so the description carries the burden. The verb 'Get' implies a read-only operation, and the attribute list indicates what is returned. However, it does not explicitly state side-effect-free behavior, authentication requirements, rate limits, or that the domain must belong to the account. The API reference link provides a pointer but not behavior detail.

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

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

One tightly packed sentence that lists all key return categories and includes an API reference link. There is no filler, redundant wording, or repeated schema content. Every part 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 one-parameter getter with no output schema, the description is nearly complete. It tells the agent what data will be retrieved and provides a reference link. Missing context includes that the domain must already be in the account (though the schema says this) and the exact meaning of 'dates' (registration/expiry/updated), but these are minor for this tool's complexity.

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

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

The input schema already describes the only parameter ('Domain in the account') with 100% coverage. The description adds no additional meaning about the parameter's format, constraints, or behavior. Baseline 3 applies because the schema handles parameter documentation.

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

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

The description uses a specific verb 'Get' and names the resource with a precise list of returned attributes: status, dates, lock, privacy, NS, and contacts. This clearly states what the tool does and differentiates it from sibling tools that handle only one aspect (e.g., domainLock, addPrivacy, changeNameServers) or raw WHOIS 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 gives no guidance on when to use this tool versus siblings like whoisInfo or listDomains. It does not mention alternatives, exclusions, or the condition that the domain must be in the account. Selection is left 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 provided, the description carries the full burden of explaining behavior. It clearly indicates a read-only price retrieval action and lists the price categories, but it does not disclose response format, authentication needs, rate limits, or how the TLD input maps to output. The linked API reference partially compensates, but the description itself is minimal.

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

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

The description is a single front-loaded sentence that states the action, scope, and resource without wasted words. The API reference link is a useful addition and does not bloat the description.

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 price lookup with no output schema, the description conveys the core purpose, but it omits practical invocation details such as expected return shape and direct usage criteria. The external API reference helps, but the description alone 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 description coverage is 100%, so the parameters are already documented in the schema. The description adds the concept of transfer and renew pricing, but it does not clarify how the two parameters relate to those categories. Baseline 3 is appropriate 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 states a specific verb ('Return') with a clear resource ('NameSilo registration / transfer / renew prices') and a clear scope ('by TLD'). It is easily distinguished from all sibling tools, which are registration, renewal, transfer, DNS, and account operations rather than price lookups.

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

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

The description implies usage as a price lookup before registration/transfer/renewal decisions, but it does not explicitly state when to use this tool instead of related tools or provide any exclusions. The purpose is inferable from sibling context, but no direct guidance is given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Search' implies a read-only operation and the API-reference link adds some external context, but the description does not mention pagination, default sorting, response shape, or any side effects. This is minimal disclosure.

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

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

The description is one short sentence with the action front-loaded and an API-reference link included, so there is no wasted text. It is efficient, though arguably too sparse for a tool with 12 optional parameters.

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 12 optional parameters, no annotations, no output schema, and a dense cluster of sibling auction-related tools, this one-line description is not enough for an agent to confidently call the tool or interpret its results. It does not state return values, defaults, or how it differs from viewAuctions, and the external link only partially compensates.

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

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

Schema description coverage is 100%, and each of the 12 parameters has a schema-level description, so the schema already carries the parameter documentation burden. The description adds no additional meaning about parameter defaults, combinations, or which filters are most useful, keeping this at the baseline of 3.

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

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

The description states a specific verb ('Search') and a specific resource ('NameSilo expired-domain auctions'), so an agent can tell this tool deals with searching/filtering auction listings. It does not explicitly differentiate itself from sibling tools like viewAuctions or viewAuction, so it stops short of a 5.

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

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

There is no guidance on when to use listAuctions versus sibling auction tools such as viewAuctions, viewAuction, viewAuctionHistory, bidAuction, or buyNowAuction. The description only identifies the object being searched and gives no conditions, exclusions, or alternative-routing hints.

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 burden of behavioral disclosure. 'List' implies a read-only operation, and the description clarifies the active-domain scope. However, it does not mention pagination, response format, required authentication, or the meaning of 'active,' leaving some behavioral details to the linked API reference.

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

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

The description is two sentences with no wasted words. The core action is front-loaded, the optional filter is stated clearly, and the API reference link is a useful addition without clutter. Every element contributes to understanding.

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 covers the essential invocation context: what it lists and how to filter. It does not describe return values or pagination, but the API reference link compensates, and the absence of required parameters keeps the call straightforward.

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

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

The schema provides 100% coverage of the only parameter, 'portfolio,' with a description already explaining it as a filter. The tool description adds 'Optionally filter by portfolio,' reinforcing optionality but adding little beyond the schema. Baseline 3 applies because the schema handles the semantic load.

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

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

The description states a specific verb and resource: 'List active domains in the account.' The word 'active' distinguishes it from the sibling listExpiringDomains and other domain-related tools, so an agent can identify the correct tool without needing to infer.

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

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

The description provides clear context: the tool lists active domains account-wide and optionally filters by portfolio. It does not explicitly name alternatives or exclusion conditions, but the scope is unambiguous and the optional filter is stated, giving an agent enough direction on when to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List' conveys a read-only operation and 'configured on a domain' scopes the operation, but the description does not disclose error behavior, authentication requirements, or any potential quirks. It is adequate but minimal.

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

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

The description is a single clear sentence with no wasteful filler. The core operation and scope are front-loaded, and the API reference link provides additional context without bloating the text.

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

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

For a simple one-parameter read-only tool, the description gives enough to understand the basic purpose and invoke it with the required domain parameter. However, with no output schema, it does not explain what the returned list will contain, and it lacks any usage prerequisites or edge-case warnings.

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% since the only parameter 'domain' is documented as 'Domain'. The description adds no extra semantic detail beyond the schema, and the baseline of 3 applies. The domain parameter is simple and self-explanatory, so no compensation is needed.

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

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

The description uses a specific verb ('List') and resource ('email forwards configured on a domain'), which clearly states the operation. It is easily distinguished from the sibling tools configureEmailForward and deleteEmailForward, which are mutate operations.

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

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

The description implies this tool is for reading existing email forwards because it says 'List', and siblings like configureEmailForward and deleteEmailForward imply the create/delete counterparts. However, it does not explicitly provide when-to-use guidance, exclusions, or mention when a sibling would be more appropriate.

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

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

With no annotations provided, the description carries the full burden, but it offers only a straightforward read-only listing behavior with an N-day filter. It does not disclose pagination defaults, ordering, response shape, or possible limitations (e.g., only active domains). The included API reference link can supplement, but the description itself adds only minimal behavioral detail.

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 action, resource, and condition with no filler. The API reference link is a lightweight addition. Every word earns its place, and the structure makes 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?

The description is sufficient for a simple listing tool with fully documented parameters, and the schema covers all arguments. However, there is no output schema, and the description does not explicitly describe the return format or mention default/max values for daysCount or pageSize. The API reference link helps close that gap, but the description itself is not fully self-contained.

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?

All three parameters (daysCount, page, pageSize) already have meaningful descriptions in the schema, giving 100% schema description coverage. The description's 'N days' mirrors daysCount but adds no new meaning beyond the schema. The baseline of 3 is appropriate 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 and resource: 'List domains in the account that expire within N days.' The scope is clearly defined by the expiration window, which distinguishes it from related tools like listDomains (all domains) and countExpiringDomains (count only). The tool's intent is immediately clear 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 clearly implies the use case—finding domains expiring soon—but it does not explicitly state when to choose this tool over siblings such as listDomains or countExpiringDomains, nor does it mention any exclusions or pruning conditions. The context is understandable but not fully 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 burden of behavioral disclosure. It only says 'List...' with no mention of pagination, ordering, response format, or authentication requirements. This is not a contradiction, but it provides minimal behavioral context beyond the verb itself.

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 immediately states the action and target. It contains no filler and includes a useful API reference link as supplemental context.

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

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

For a zero-parameter tool, the description provides the essential scope ('account order history') and a link to the API reference. It does not describe return shape or pagination, but the low complexity and absence of parameters make those gaps minor.

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?

This tool has zero parameters, and the schema description coverage is 100%, so there is no parameter semantics burden on the description. The baseline of 4 applies because 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 specific verb and resource: 'List account order history.' This clearly communicates what the tool does, but it does not explicitly differentiate it from sibling tools such as orderDetails or listDomains.

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

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

There is no guidance on when to use this tool versus alternatives like orderDetails or listExpiringDomains. The only usage context is the phrase 'account order history,' which is implied by the tool's purpose rather than explicitly 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 provided, the description carries the full burden of behavioral disclosure. It only says 'List' and clarifies 'glue' nameservers, but it does not disclose that the operation is read-only, any domain prerequisites, or what response the caller should expect. The parenthetical adds a small amount of semantic context, but most behavioral traits are left to the API reference link.

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

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

The description is a single front-loaded sentence with no filler, and the API-reference link is compact. It earns its place by stating the action and resource clearly, though it does not provide deeper operational 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?

The tool is simple and the schema fully documents the required parameter, so a long description is not necessary. However, with no annotations and no output schema, the absence of return-value or usage-alternative information leaves a modest gap; the API-reference link partially compensates.

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

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

The input schema already documents the sole parameter 'domain' with 100% coverage. The description's phrase 'for a domain' adds no meaningful information beyond what the schema provides, so the schema-driven baseline of 3 is appropriate.

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

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

The description states a specific verb, 'List', and a specific resource, 'registered (glue) nameservers for a domain'. The parenthetical 'glue' adds a meaningful distinction from ordinary nameserver operations and from sibling mutation tools such as add/modify/delete. It is clear, though it does not explicitly contrast with related sibling tools like changeNameServers.

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; there are no conditions, exclusions, or references to sibling tools. The only implied usage is 'for a domain,' which is too thin to help an agent decide between this and the many related nameserver operations.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It conveys a read-only listing action and scopes results to 'active' listings, but it omits additional behavioral details such as pagination, sort order, authentication assumptions, or response shape. The API-reference link partially mitigates this 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 front-loaded sentence that states the action and resource, followed by a useful API-reference link. There is no filler, repetition, or unnecessary detail.

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 listing tool, the description provides enough information to select and invoke it correctly. It would be stronger if it summarized the shape of a returned listing, but the low complexity and external reference link keep 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?

The tool has zero parameters, and the schema already fully captures invocation requirements. There is no parameter semantic gap for the description to fill, so the baseline score of 4 applies.

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

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

The description states a specific verb ('List') and a precise resource ('your active NameSilo Marketplace listings'), making the tool's purpose immediately clear. The qualifiers 'active' and 'Marketplace' help distinguish it from auction and domain-management 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 clearly signals when to use the tool: when the caller needs their active NameSilo Marketplace listings. However, it does not explicitly name alternatives or provide when-not conditions, leaving some sibling differentiation 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?

No annotations are provided, so the description carries the full burden of explaining behavior. While it identifies the action as create/update/cancel and notes domain ownership, it does not disclose potential side effects, whether updating overwrites existing sale settings, cancellation behavior, fee implications, or authentication requirements. For a mutation tool this is a significant transparency 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 front-loaded sentence that efficiently names the operation, resource, and ownership prerequisite, plus a documentation link. It is concise without wasted words, though the terseness does limit the behavioral and usage guidance it provides.

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

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

This is a complex tool with 18 parameters, three distinct actions, and no output schema or annotations. The description only provides a high-level summary and a link, leaving the agent to infer which parameters are relevant for each action and what the response/effects will be. Given the complexity, the description is not complete enough.

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

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

Schema description coverage is 100%, so every parameter already has an individual description. The tool description itself adds no additional parameter-level meaning, such as which parameters apply to add versus modify versus cancel actions. Baseline 3 is appropriate because the schema handles the heavy lifting.

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

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

The description clearly states the tool creates, updates, or cancels a Marketplace sale for a domain the user owns. This is a specific verb+resource combination that distinguishes it from sibling tools like marketplaceActiveSalesOverview, listAuctions, and bidAuction, which cover viewing or bidding rather than managing a listing.

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

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

The description gives useful context ('for a domain you own') and an API reference link, but it does not explicitly say when to prefer this tool over related siblings, nor does it mention exclusions or alternatives. The usage context is implied rather than 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 provided, the description carries the full burden of behavioral disclosure. It indicates mutation through 'Update,' but does not disclose whether the operation overwrites existing landing-page settings, requires special permissions, is reversible, or what response the agent should expect. This is a significant transparency gap for a mutating 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 a single front-loaded sentence with a clear verb and resource. However, the embedded URL '[https://www.namesilo.com/api-reference]' is extraneous and appears awkwardly attached to 'domain,' slightly undermining the structure. It is concise but not perfectly clean.

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 mutating tool with ten parameters, no annotations, and no output schema, the description is too thin. The schema explains parameters, but the description lacks guidance on when to call this tool, what effects to expect, and how it relates to marketplaceActiveSalesOverview and marketplaceAddOrModifySale. An agent could select the wrong sibling or invoke this without understanding the side effects.

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

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

Schema description coverage is 100%, so the input schema already documents all ten parameters. The tool description adds no parameter-level meaning beyond the schema, and it does not mention any of the mp_* fields or domain. A baseline score of 3 is appropriate when the schema carries the parameter documentation burden.

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

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

The description states a clear operation and resource: 'Update the Marketplace for-sale landing page for a domain.' This is a specific verb+object combination. However, it does not explicitly differentiate this from the similar sibling marketplaceAddOrModifySale, so the agent must infer the boundary between updating a landing page and adding/modifying a marketplace sale.

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

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

No usage guidance is provided. The description does not explain when to use this tool versus alternatives like marketplaceAddOrModifySale, nor does it mention prerequisites, exclusions, or a preferred workflow. The only contextual clue is the phrase 'for a domain,' but that merely restates the required domain parameter rather than giving decision criteria.

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 for behavioral disclosure. It only says what is changed and says nothing about side effects, propagation, whether existing glue IPs are replaced or merged, or whether this affects live domain resolution. The external API reference link does not compensate for in-description 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 one compact sentence with the core operation front-loaded and an external reference appended. There is no filler, redundancy, or unnecessary detail.

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 16 parameters, 4 required fields, no output schema, and no annotations, a one-sentence description is insufficient for safe autonomous invocation. It does not explain how current_host and domain identify the existing nameserver, what valid values look like, or what the response indicates. The API reference link is helpful but the description itself remains incomplete.

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

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

The input schema describes all 16 parameters at 100% coverage, so the schema is already doing the heavy lifting. The description adds a useful high-level mapping between 'host name' and glue IPs and the parameters, but it does not clarify the required relationship, especially since new_host and ip1 are both required despite the 'and/or' phrasing.

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 ('Change'), the target resource ('a registered nameserver'), and the exact things that can be changed ('host name and/or glue IPs'). This clearly differentiates it from sibling tools like addRegisteredNameServer, deleteRegisteredNameServer, and changeNameServers.

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 use this tool versus addRegisteredNameServer, deleteRegisteredNameServer, or changeNameServers. It does not state prerequisites such as the nameserver already being registered or the need for domain ownership/access.

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 only says 'Get line items,' which implies a read operation, but it does not disclose return format, error behavior, rate limits, authentication needs, or any other operational traits.

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

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

The description is a single concise sentence that communicates the core action immediately. The API reference URL is somewhat auxiliary but not harmful. It is efficient, though not especially rich in structure.

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

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

For a simple single-parameter read tool, the description is minimally viable: it names the operation and resource, and the schema provides the required parameter. However, with no output schema and no annotations, the agent is left without explicit information about the response structure or edge 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?

The input schema has 100% description coverage: order_number is described as 'Order number from listOrders,' which adds cross-tool context. The tool description itself adds no parameter-level meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Get'), the resource ('line items'), and the scope ('single order'), which distinguishes it from sibling tools like listOrders and the many domain/contact operations. No ambiguity remains about what this tool does.

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 context is implied: use it when you need line items for one order, especially after calling listOrders. However, the description does not explicitly state when to prefer this over alternatives, nor does it name excluded cases.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the create action and gives no information about idempotency, duplicate handling, permissions, side effects, or the response format.

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

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

The description is very short and front-loaded, placing the core action first. The appended API-reference link is generic and adds little local value, but the overall structure is 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 one-parameter create operation with no annotations and no output schema, the tool still needs behavioral context such as duplicate behavior, authentication requirements, or expected response. The single-sentence description leaves these gaps and does not help an agent distinguish it from related portfolio 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 100% for the single 'portfolio' parameter, and the schema already describes it as 'Portfolio name.' The description adds no additional parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb and resource ('Create a portfolio'), so the core purpose is clear and not tautological. However, it does not explicitly distinguish itself from sibling tools like portfolioDelete, portfolioList, or portfolioDomainAssociate.

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

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

There is no when-to-use or when-not-to-use guidance, and no mention of alternatives such as portfolioDomainAssociate for attaching domains or portfolioList for viewing portfolios. An agent receives no explicit decision support beyond the action itself.

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 disclose behavioral context on its own. It only restates the delete operation and does not mention irreversibility, effects on associated domains, permission requirements, or response behavior. The generic API reference link does not provide specific behavioral details in the description.

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

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

The description is extremely concise, containing no redundant wording, and the core action is front-loaded. It loses points only because it is so minimal that it omits useful context, but as a concise definition it is well-formed.

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

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

This is a destructive operation with no annotations and no output schema, yet the description only states the basic action. It lacks details about what happens to domains associated with the portfolio, whether the deletion is reversible, or what errors or confirmations the API returns. The generic link to an API reference is not enough.

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 only parameter, 'portfolio', is described as 'Portfolio name' in the schema. The tool description adds no additional meaning or constraints beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Delete') and the resource ('a portfolio'), which unambiguously identifies the tool's purpose. It does not explicitly differentiate from sibling tools, but the resource name is distinct enough among portfolio-related 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 phrase 'Delete a portfolio' implies the tool should be used when a portfolio needs to be removed. However, it provides no explicit guidance about when not to use it, prerequisites, or alternatives such as portfolioList or portfolioDomainAssociate.

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 only states the mutation ('Assign') and the 200-domain cap, but does not mention whether the operation overwrites existing assignments, whether it is reversible, what permissions are required, or what the response contains. The external API reference link is a pointer, not a substitute for in-description transparency.

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

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

The description is a single, front-loaded sentence with no redundant filler. Every token adds meaning: the verb, the target resource, the count limit, and the external reference. It is appropriately compact for the tool's two-parameter surface.

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

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

Given the simple two-parameter schema, the description is functionally sufficient for basic invocation. However, it does not disclose return values, failure modes, or behavioral edge cases (e.g., invalid portfolio names), and with no output schema or annotations, this leaves notable gaps for an agent relying solely on the description.

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

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

Schema description coverage is 100%, so the schema already explains both required parameters. The description adds only the 'up to 200' context, which is also repeated in the domains parameter description. This meets the baseline, but the description does not significantly enrich parameter understanding 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 uses a specific verb ('Assign') with clear objects ('up to 200 domains to a portfolio'), making the operation unambiguous. It also inherently distinguishes this from sibling tools like contactDomainAssociate (assigns contacts) or portfolioAdd (creates a portfolio). The 200-domain limit adds useful operational specificity.

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

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

The description provides no guidance on when to choose this tool over alternatives, when not to use it, or what prerequisites exist (e.g., whether the portfolio must already exist). It states the action but leaves usage context entirely to the agent's 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?

No annotations are provided, so the description carries the behavioral transparency burden. 'List' and 'in the account' convey a read-only, account-scoped operation, but the description does not disclose authentication needs, pagination, or output structure.

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

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

The description is a single front-loaded sentence with no filler. The API reference link is mildly redundant but does not detract from clarity.

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

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

For a zero-parameter list operation this is mostly sufficient, but because there is no output schema, the description does not state what portfolio fields or identifiers will be returned. 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?

There are zero parameters, so the input schema already captures everything needed. Per the baseline for no-parameter tools, this is adequate and needs no additional parameter explanation.

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

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

The description uses a specific verb ('List') and resource ('portfolios') and scopes it to 'the account.' This clearly distinguishes it from mutating portfolio siblings like portfolioAdd, portfolioDelete, and portfolioDomainAssociate, as well as from listDomains.

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 it should be used when the agent needs the set of portfolios in the current account. However, it does not explicitly state when not to use it or mention any alternative tools, so the agent must infer routing from sibling names.

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 does disclose the critical side effect that funds are spent and mentions the payment method, which is valuable. It does not mention reversibility, failure behavior, output format, or any prerequisite conditions beyond the contact_id preference.

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

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

The description is very brief and front-loaded: the core action is stated first, followed by two high-value operational hints and a reference link. Every sentence earns its place with no unnecessary 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 the tool's 40 parameters, high schema coverage, and no output schema or annotations, the description provides a useful high-level orientation but omits several contextual details an agent would need after invocation, such as expected response shape, failure modes, or whether registration is immediate. The link to the API reference partially compensates but is not self-contained.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful guidance beyond the schema by instructing the agent to prefer an existing contact_id, reducing ambiguity about whether to supply the many address fields. The funds/payment_id note also adds practical parameter-selection context.

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

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

The description opens with a clear verb and resource: 'Register a domain.' It distinguishes the action from related sibling tools like renewDomain and transferDomain, though it does not explicitly contrast with the similarly named registerDomainDrop.

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 guidance by warning that the operation spends account funds or requires payment_id, and by recommending use of an existing contact_id. However, it does not explicitly state when to choose this tool over alternatives like checkRegisterAvailability or registerDomainDrop.

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