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

With no annotations provided, the description carries the full burden and does add value by stating 'Read-only' and 'live', which informs the agent that this is a safe, real-time query. It does not disclose output details or any rate/authentication nuance, but for a zero-parameter tool this is a reasonable level of 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 efficient sentence: it states the resource, the account scope, the live/current nature, and the read-only property. Every word earns its place and 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?

For a zero-parameter, read-only account information tool, the description tells the agent what data it will receive (account details and prepaid balance) and the operational characteristic (live, read-only). It is nearly complete; a small enhancement would be explicitly noting it returns the current INWX account balance, but nothing important is missing for 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 input schema has zero parameters and schema description coverage is 100%, so there is nothing missing. Per the rubric baseline, a zero-parameter tool earns a 4 because the description is not expected to explain parameters that do not exist.

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

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

The description names the exact resource ('Account details and prepaid balance of the INWX account') and clearly labels the operation as read-only. It does not start with an explicit verb like 'Retrieves', but the intent is unambiguous and distinguishes this tool from the domain/contact/nameserver 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 implies this is the tool to use when account-level details or prepaid balance are needed, and the 'live' qualifier suggests current data rather than cached values. However, it does not explicitly state when-not-to-use it or mention any alternative, though no sibling appears to overlap functionally.

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 must carry the behavioral burden, and it does disclose the most important risk: WRITE methods execute for real in live mode. It also directs agents to external documentation for method-specific behavior. It omits return format and error behavior, but the live-write disclosure is substantial and directly relevant to safe invocation.

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 filler: purpose, safety warning, and routing are all present. The most important operational fact, that writes execute in live mode, is front-loaded and cannot be missed.

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 generic passthrough tool, the description gives the essential context: what it calls, how it calls it, the live-write behavior, and how it relates to the named sibling tools. The external API documentation link fills in the long tail of method-specific details. It does not describe response shapes or error handling, but the external reference and low parameter count keep this reasonably 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 schema has 0% description coverage, so the description must compensate. It does add meaning by explaining that 'method' is a DomRobot method name and 'params' are raw parameters, and it links to the full API documentation. However, it provides no concrete examples or per-method parameter guidance, so the compensation is only partial.

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

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

The description clearly states the tool's verb ('call'), resource ('any DomRobot method'), and mode ('by name with raw params'). It also differentiates itself from the named sibling tools by positioning itself as the generic fallback. This leaves no ambiguity about what the 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?

The instruction to 'prefer the named tools' gives agents a clear default-versus-fallback decision rule. The warning that WRITE methods execute for real in live mode adds a critical when-to-be-careful condition. It does not explicitly state 'use only when no named tool exists', but the precedence is strongly implied.

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

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

With no annotations provided, the description carries the full burden. It discloses that this is a write operation via 'WRITE:' and surfaces the German address requirement. However, it does not cover side effects, validation failures, or the fact that ROLE is also an accepted type.

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

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

The description is two short sentences with the action front-loaded ('WRITE: create...'). No filler or redundant content.

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

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

Given 10 parameters, 8 required, low schema coverage, no annotations, and no output schema, this description is too sparse. It provides one useful domain rule but does not give enough context about parameter relationships, the ROLE type, or what a successful creation entails.

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

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

Schema description coverage is only 30%, so the description must compensate, but it adds little field-level meaning. It mentions ORG/PERSON and the German address requirement, but most required parameters like name, street, city, pc, voice, and email are left unexplained in both the schema and description. The exclusion of ROLE is also misleading relative to the schema.

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

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

The description states a specific verb and resource: 'create a contact handle (ORG or PERSON)', which clearly distinguishes it from read-oriented siblings like contact_list and contact_info. However, it omits the ROLE enum value that the schema permits, slightly narrowing the tool's actual capability.

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 'WRITE:' prefix and 'create' verb imply this is the creation operation among the contact tools, and the .de condition adds a concrete prerequisite. But there is no explicit guidance about when to use this versus alternatives or when not 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?

With no annotations provided, the description carries the behavioral burden. It does disclose the important read-only trait, but it gives no detail about authentication, invalid ID handling, or what 'details' are 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 only two short sentences and contains no filler. The core resource and read-only nature are front-loaded, making it very easy to scan.

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

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

Given there is no output schema, no annotations, and no parameter descriptions, this description is too thin. It does not explain what fields or details are returned, what a contact handle is, or how the id relates to other contact tools.

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

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

Schema description coverage is 0%, so the description should clarify the id parameter. It indirectly suggests that id identifies a contact handle, but it never explicitly defines the parameter or explains how to obtain a valid id.

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 a single contact handle as the resource and indicates a read-only retrieval operation. It is distinct enough from siblings like contact_list and contact_create, though it lacks an explicit verb like 'get' or 'fetch'.

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 'one contact handle' implies this tool is for retrieving a single handle rather than listing or creating contacts, but it does not explicitly state when to use this tool versus alternatives such as contact_list or contact_create.

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

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

With no annotations present, the description carries the safety burden and explicitly declares 'Read-only'. It also scopes the behavior to the current account. For a zero-parameter listing operation, this discloses the key behavioral trait; only minor details like output format or ordering are absent.

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 short, front-loaded sentence states the action, resource, scope, and read-only nature with no filler or repetition. 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 parameterless list tool, the description is largely complete: it names what is returned (contact handles) and the scope (account). It could improve by explicitly steering users to sibling tools for details, but that gap is minor given the simple invocation surface.

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 description coverage is 100%, so there is no parameter information missing. The description adds no parameter specifics, but none are needed; this is the appropriate baseline for a parameterless tool.

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

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

The description uses a specific verb ('List') and resource ('contact handles'), enumerates the handle types (owner/admin/tech/billing), and scopes the operation to the account. This clearly distinguishes it from sibling tools like contact_info (detail lookup) and contact_create (creation).

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 is clear from 'List... in the account' when to use this tool: to enumerate contact handles. However, it does not explicitly name alternatives such as contact_info for details, or state when not to use this tool, leaving routing mostly implied.

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

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

No annotations are present, so the description carries the behavioral disclosure burden. The explicit 'Read-only' label is valuable and discloses that the operation has no side effects. However, it does not mention response format, rate limits, authentication needs, or edge cases such as invalid domain formats or unsupported TLDs.

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, tightly written sentence with no filler. The core operation is front-loaded, and each clause contributes something useful: the action, the resource, the possible outcomes, and the read-only safety note.

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 with no output schema and no annotations, the description covers the main semantics and the outcome categories well. It does not describe the exact return shape or provide input format examples, but the simplicity of the tool makes those omissions relatively 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?

The schema provides only the parameter name and type, with 0% schema description coverage. The description compensates by clarifying that the domains parameter is a list of domain names to be checked and by indicating the possible status outcomes. It does not specify accepted domain syntax or normalization rules, but it adds meaningful semantics beyond the bare array-of-strings 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 ('Availability check') and resource ('domains'), and enumerates the result categories: registered elsewhere, free, or transferable. This distinguishes it clearly from sibling tools like domain_list or domain_info, which are about managing or viewing domains that are already known.

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 implies this tool is for checking domain availability rather than managing owned domains, but it never names alternatives or explains the conditions for choosing domain_check over domain_info, domain_list, or domain_price.

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 explicitly states 'Read-only' and notes that the auth code is included only 'where the registry exposes it,' which is useful conditional context. However, it does not disclose behavior for invalid or out-of-account domains, or what happens when fields are missing.

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 delivers high information density: what is returned is enumerated, the scope is constrained to one domain, and the read-only nature plus conditional auth-code caveat are included. No wasted words.

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 with no output schema, the description is largely complete: it enumerates the return fields and the read-only behavior. Minor gaps remain, such as input format specification and error behavior, but nothing critical for an agent to invoke it correctly on a known account domain.

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

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

Schema description coverage is 0% — the schema only declares a string 'domain' with no description. The description names the parameter implicitly ('one domain in the account') but does not compensate for the schema gap by specifying expected format (e.g., example.com vs. www.example.com, IDN/punycode, trailing dot). The parameter name is self-evident, but format semantics are left unaddressed.

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 resource (one domain in the account) and the scope of what is returned (status, contacts, nameservers, transfer lock, renewal mode, auth code). It implicitly differentiates from siblings like domain_list (list vs. details of one) and domain_check (availability vs. existing account domain), though the verb is implied rather than stated.

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

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

No guidance is provided on when to use this tool versus alternatives. Siblings such as domain_list, domain_check, contact_info, and nameserver_info overlap meaningfully, and the description does not state which scenarios route to domain_info instead of those tools.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It explicitly states 'Read-only' and describes what fields are returned and that filtering is supported. It does not mention pagination or response shape, but for a simple read-only list tool the core behavioral traits are covered.

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

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

Two short sentences deliver the core purpose, returned fields, read-only nature, and filtering capability with no wasted words. The most important information is front-loaded.

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

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

For a simple tool with three optional parameters and no output schema, the description is complete enough for an agent to invoke it correctly and understand what response fields to expect. It omits explicit pagination behavior, but the page/pagelimit parameter names and defaults make this inferable from the schema.

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

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

Schema coverage is only 33%, with page and pagelimit lacking descriptions. The tool description's 'Filter by substring or TLD' adds little beyond the schema's domain parameter example and does not compensate for the undocumented pagination parameters.

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

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

The description uses a specific verb ('List'), names the resource ('domains in the account'), and enumerates the returned fields (status, nameservers, renewal mode, expiry). It also clearly marks the operation as read-only, distinguishing it from sibling tools like domain_info or domain_check.

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

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

The description gives clear context: use this tool for account-level domain listing, with optional substring/TLD filtering, and it is explicitly read-only. It does not explicitly name alternative tools or provide when-not-to-use guidance, but the listing-vs-detail distinction is reasonably clear from 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 provided, the description carries the full burden and it does disclose 'Read-only', which is a valuable behavioral guarantee. It also lists the content types (transfers, updates, registry messages). However, it does not disclose output format, ordering, or how far back 'recent' goes, leaving gaps in behavior 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?

Two short sentences with no filler; the core purpose is front-loaded and the read-only disclosure is stated immediately. Every sentence earns its place.

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

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

The tool is simple with only two parameters, and the schema covers required/optional fields. Still, without an output schema the description does not explain the return shape, and it leaves pagination behavior vague. The essentials are present, but some operational details are missing.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that the 'domain' parameter refers to the domain whose logs are returned, but it says nothing about 'pagelimit' or its effect. The schema already provides type, default, min, and max, so the description adds no semantic value for that parameter.

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

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

The description clearly identifies the tool's purpose: returning recent log entries for a domain, specifically transfers, updates, and registry messages. This distinguishes it from sibling tools like domain_info (current status) and domain_list (enumerate domains).

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

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

The description implies this is the tool to use when you need recent activity logs for a domain, but it does not explicitly state when to use it versus alternatives, nor does it mention any exclusions or related tools. Usage context is implied rather than spelled out.

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

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

With no annotations, the description itself must disclose side effects; 'Read-only' does exactly that and adds account-currency context. It does not describe response shape or error/empty-list behavior, but for a simple read query the key behavioral trait is covered.

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; the first front-loads the functional scope and the second adds the read-only safety signal. No filler.

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

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

The tool is simple (one optional param, no output schema) and the description states the domain, price categories, currency, and read-only nature. It could be more explicit about the returned shape, but nothing essential for invocation is missing.

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

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

Schema coverage is 100%: the only parameter, tlds, is fully documented with format and empty-all semantics. Therefore the description need not add parameter detail; 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?

Describes a price list for TLDs, specifying covered price types (registration, renewal, transfer) and currency, so an agent can tell it apart from domain_info or domain_check. It lacks an explicit retrieval verb and does not name sibling alternatives, so it falls short of a fully distinguishing definition.

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

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

The description implies a pricing use case but never states when to prefer this tool over domain_check or domain_info, nor does it give exclusions. This is adequate context but relies on the tool name and noun phrase for routing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The leading 'WRITE, COSTS MONEY' explicitly warns that this is a mutating operation with financial consequences, which is the most critical behavioral trait for an agent to know. It does not cover every edge behavior, but it does disclose the two most consequential aspects.

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 tight, front-loaded sentence: 'WRITE, COSTS MONEY' appears first, followed by the essential operation. There is no filler, repetition, or unnecessary detail, making it easy for an agent to parse quickly.

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

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

For a tool that costs money and performs a write, the description is too thin. It does not explain the 'testing' parameter, which appears to be a safety mechanism, nor does it note prerequisites such as the domain being registered or managed at INWX. Without annotations or an output schema, this leaves important operational uncertainty.

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

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

Schema description coverage is only 33%, with only 'period' documented as 'e.g. 1Y'. The description adds only 'by N years,' which loosely maps to 'period' but provides no added meaning for 'domain' or the critical 'testing' boolean. Since 'testing' likely controls whether real charges are incurred, the lack of explanation is a significant gap.

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

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

The description states a specific verb ('renew'), a resource ('a domain'), a provider ('INWX'), and the dimension of the action ('by N years'). It is immediately distinguishable from sibling tools like domain_check, domain_price, or domain_transfer because only this tool performs renewals.

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 use case clear: use this when you need to renew a domain for a certain number of years. However, it does not explicitly state when not to use it, nor does it reference alternatives such as domain_info for checking expiry or domain_transfer for moving a domain.

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 disclosure. It explicitly warns 'WRITE, COSTS MONEY', states the need for an auth code from the current registrar, and explains TLD-specific term effects for gTLDs versus .de/.eu. It does not cover every edge behavior, but the most important financial and side-effect consequences are disclosed.

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 highly compact and front-loaded with the most critical warning ('WRITE, COSTS MONEY'), followed by the purpose, prerequisites, and TLD effects. Every sentence contributes meaningful information and there is 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?

The description covers the essential prerequisites, financial impact, and TLD-specific renewal behavior, which is strong for a mutation tool. But it does not mention the testing/validation mode, default contact handle behavior, or expected outcome of the call, and there is no output schema to fill that gap. For a 9-parameter money-spending operation, some of that context would improve completeness.

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

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

Schema coverage is 67%, so the schema already documents most parameters. The description adds meaning by explaining that the authCode comes from the current registrar and that four contact handles may be identical. However, it somewhat oversimplifies the schema by implying four handles are required when only registrant is required and tech/admin/billing default to registrant.

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

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

The description names a specific verb and resource: 'start an inbound transfer of a domain to INWX'. It immediately distinguishes itself from sibling tools like domain_renew, domain_update, and domain_check by clearly stating the operation is an inbound domain 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 gives useful context by listing the prerequisites (auth code, contact handles, nameservers) and notes the financial impact, which tells an agent this is not a free or side-effect-free operation. However, it does not explicitly compare against alternatives like domain_renew or domain_update or state when not to use this tool, so usage guidance remains implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden. The 'WRITE:' prefix signals mutation, and 'Only the given fields change' discloses partial-update semantics rather than full replacement. However, it does not mention permissions, side effects, timing, or the fact that changing transfer lock or renewal mode may have irreversible or externally visible consequences. Some important behavioral context is missing.

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 dense sentence that covers the operation type, the resource, the modifiable fields, and the partial-update behavior with no filler. Every phrase adds information, and the 'WRITE:' prefix is an efficient way to convey mutation intent.

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 nine-parameter write operation with no annotations, no output schema, and minimal schema descriptions. The description only sketches the domain and fields, leaving out the required 'domain' parameter context, the meaning of integer contact fields, the purpose of 'testing', and any expected response or error behavior. This is insufficient for correct invocation without additional lookup.

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

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

Schema description coverage is only 11%, so the description must compensate, but it only groups parameters into categories ('nameservers', 'transfer lock', 'renewal mode', 'contacts'). It does not explain that tech/admin/billing/registrant are likely contact IDs, what the 'testing' flag does, or how renewalMode enum values map to behavior. The mapping from description to the nine parameters is incomplete and leaves the agent uncertain about several fields.

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 'WRITE:' marker and states a specific action: changing nameservers, transfer lock, renewal mode, or contacts of an existing domain. This distinguishes it from siblings like domain_transfer and domain_renew, which perform different lifecycle actions. The phrase 'domain already at INWX' further scopes the operation.

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

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

The description clearly indicates this applies to an existing INWX domain, implying it is not for transfer, renewal, or availability checks. It does not explicitly name alternatives, but given sibling tool names the intended use case is inferable. The partial-update caveat 'Only the given fields change' gives practical guidance on how to use the tool.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does state 'Read-only,' which is a meaningful safety signal, and 'one' implies a single-zone scope. However, it does not disclose authentication requirements, error behavior, or any other operational constraints.

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

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

The description is two short sentences with no filler. The core subject is front-loaded before the read-only qualifier, making it easy to scan and quickly understand.

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 covers the essential context: the resource type, the scope, and the read-only nature. It does not explain the output format, but no output schema exists and the tool's simplicity makes that less critical.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by linking the 'domain' parameter to 'one INWX-hosted DNS zone,' which is useful context beyond the bare parameter name. Still, it does not specify the expected domain format or any additional constraints on the value.

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

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

The description indicates this tool returns records for a single INWX-hosted DNS zone and marks it as read-only, which clearly identifies the resource and operation type. It is reasonably distinguishable from siblings like nameserver_list, though it does not explicitly name that alternative.

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 such as domain_info, domain_list, or nameserver_list. The only contextual hint is 'INWX-hosted,' but there is no explicit statement of when this tool is the appropriate 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 disclosure burden. The explicit 'Read-only' statement is useful and communicates that this is a non-mutating operation. But the description does not cover return format, pagination, auth expectations, or the effect of the optional domain parameter.

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

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

Two compact sentences with no filler. The first states the action and read-only nature; the second gives a practical exclusion. Every sentence earns its place.

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

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

For a simple one-parameter read-only list tool, this is adequate: the core action and a key scope limitation are clear. The main gap is the completely undocumented 'domain' parameter, and the absence of any statement about what is returned. An agent could call it correctly but might not know how to use the optional filter.

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

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

Schema description coverage is 0%, and the description does not mention the optional 'domain' parameter at all. The property name hints at filtering by domain, but the tool text adds no meaning to the schema. With low coverage, the description needed to compensate and did not.

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 operation ('List DNS zones hosted on INWX nameservers') and adds a relevant scope exclusion for Cloudflare-hosted DNS. It is clear about what the tool does, though it does not explicitly name a sibling tool to distinguish itself from.

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 one clear when-not condition: it is not needed for domains whose DNS lives at Cloudflare. However, it does not name an alternative tool or explicitly state when to prefer this over nameserver_info or domain_list. Usage guidance is present but mostly implicit.

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