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

The annotations already declare readOnly, idempotent, and non-destructive behavior, and the description does not contradict them. The description adds context about the consequence of insufficient balance, which is helpful but not required given the annotations.

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

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

The description is two sentences long and contains no fluff. Every word adds value: it states the return value, the recommended usage, and the reason for that usage.

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 fully covers the tool's purpose and when to use it. While it doesn't describe the output format, the simplicity of the operation (returning a balance) makes this omission acceptable, and the presence of an output schema (mentioned in context signals) further mitigates the need.

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 nothing to explain. According to the baseline for 0 parameters, a score of 4 is appropriate since the description doesn't add extra parameter-related context (none 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 clearly states the tool's function with a specific verb ('Returns') and a specific resource ('prepaid balance'). It is easily distinguishable from sibling tools, which focus on DNS, domains, SSL, and other distinct operations.

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

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

The description provides explicit usage guidance: 'Check it before any operation that spends credit' and explains the rationale ('an insufficient balance is a common cause of a rejected order'). This tells the agent exactly when to invoke this 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the safety profile is fully covered. The description adds useful behavioral detail beyond annotations: id omission switches to list mode, pagination behavior is implied by 'lists the account's profiles filtered by type and role', and it hints at preconditions for related save operations. This is strong but not exceptional—there is no explicit mention of open-world listing behavior or output format details, though the output schema covers return values.

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

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

Three sentences with zero filler. The first sentence front-loads the core behavior (get by id vs list), and the second sentence gives actionable guidance for sibling tools. Every sentence adds useful information and the definition remains compact.

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

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

Despite a 10-parameter schema, the description is sufficient because the schema covers all parameter semantics at 100% and the output schema exists for return values. The description supplies the missing context: which sibling tools to use first/next, and the id-vs-list mode distinction. A 5 would require explicit pagination guidance or open-world caveats, but those are minor given the schema and annotations.

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 every parameter. The description adds a small amount of meaning by tying id omission to list mode and mentioning the field-type/role filters in the tool purpose, but it does not materially expand on the parameter meanings beyond the schema. Baseline 3 is appropriate because the schema carries the heavy lifting and the description only lightly reinforces it.

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

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

The description clearly states the tool returns one contact profile by id, or lists profiles filtered by type/role when id is omitted. It explicitly distinguishes itself from eurodns_contact_save_profile and eurodns_contact_set_as_default_profile, so an agent can select correctly among sibling contact 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?

It provides explicit when-to-use guidance: read a profile before saving because save needs every field, and set_as_default_profile chooses which profile future orders use. This differentiates the read/list operation from mutating alternatives and gives the agent a clear procedural context.

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

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

Annotations already establish that the tool is not read-only and not destructive, but the description adds useful behavioral context: it sends a new email to contacts and returns validation state. It does not detail external side effects or rate-limit implications, but the core behavior is clearly 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?

Two tight sentences: the first explains the mechanism and return value, the second gives a concrete trigger and a pointer to a sibling tool. Every sentence earns its place and the key purpose 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 description is complete for selection and invocation: it explains the action, when to use it, what input format to expect, and what the return provides. The output schema exists, so the agent can rely on it for return structure, and no critical guidance 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%, and the body's description adds cross-tool semantics by explaining that contactsDetails should be identified as eurodns_domain_get returns them. This helps an agent construct correct input beyond the bare field names email and phone.

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 (sends a new validation email to a domain's contacts) and a specific resource (contact validation links), and also notes it returns the validation state. This clearly distinguishes it from sibling tools like eurodns_ssl_resend_approver_email.

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

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

Gives explicit guidance: use it when a contact validation is pending or expiring soon, and points to eurodns_domain_search as the way to find such domains. This tells an agent both when to invoke the tool and how to identify qualifying inputs.

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

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

Beyond annotations (readOnlyHint=false, idempotentHint=false), the description discloses the critical full-overwrite behavior ('the API clears anything omitted'), the return value, and the scope of change (future orders only, not existing domains). This is exactly the kind of non-obvious behavioral trait an agent must know before invoking.

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

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

Three sentences, zero filler, with the main verb front-loaded and the most dangerous caveat (field clearing) immediately following it. 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 tool with an 18-field nested body, create/update branching, and a full-overwrite semantics, the description covers all the risky decision points and points to the read sibling for the update workflow. With an output schema present and no need to detail return values, it is nearly complete; it could optionally note whether creating a profile triggers contact validation, but nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100%; the id parameter description already explains 'Omit it to create a new profile' and the body description already states the overwrite rule. The description adds the get_profile workflow hint, but otherwise repeats semantics the schema provides, 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 states a specific verb and resource: 'Creates a contact profile when id is omitted, or updates the profile with that id, and returns the saved profile.' It precisely defines the create/update branching and differentiates the tool from siblings like eurodns_contact_get_profile (read) and eurodns_contact_set_as_default_profile (role assignment).

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

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

The description gives an explicit workflow directive — 'start from eurodns_contact_get_profile' — for the update path, and clarifies the effect scope ('Domains already registered keep their contacts; this changes what future orders use'). It doesn't explicitly name alternatives to avoid, but the create/update decision rule and the get-first workflow are clear enough for an 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?

Annotations already declare readOnlyHint=false and idempotentHint=true; the description adds the behavioral nuance that the change applies only to future orders and that the call 'returns the roles now applied,' which is useful state-disclosure beyond the structured fields. The mutation framing is consistent with readOnlyHint=false, so no contradiction exists.

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

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

Two sentences with no waste: the first carries the action and return value, the second carries the impact scope and a pointer to the relevant sibling tool. Nothing repeats schema content or annotations.

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 full parameter coverage, an output schema, and idempotency annotations, the description covers the essential semantics: effect scope, return value, and how to obtain the id. The only gap is that none of the body's boolean fields are required, so an agent is not told what happens if an empty body is sent.

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 id and body are already fully described, including the source of the id and the meaning of each body boolean. The description's prose mapping of roles (registrant, admin, technical, billing) mirrors the schema's body fields (org, admin, tech, billing) without adding new detail. Baseline 3 applies because the schema does the heavy lifting.

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

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

States a specific action (making a profile the default) applied to a precise resource (contact profile) with an explicit scope (registrant, admin, technical or billing roles). The line 'This affects future orders, not domains already registered' sharpens the semantics further, and the verb-resource pairing clearly distinguishes it from siblings like eurodns_contact_save_profile and eurodns_contact_get_profile.

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

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

Provides clear contextual guidance: the effect is limited to 'future orders, not domains already registered,' which tells an agent when this tool applies, and it points to eurodns_contact_get_profile for locating the profile. However, it does not explicitly contrast with eurodns_contact_save_profile or state when to prefer one contact operation over another.

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

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

Annotations already note that this is mutating, non-idempotent, and non-destructive. The description adds useful behavioral context: the operation saves immediately, skips the validation step, and returns the saved zone. It goes beyond the annotations, though it does not elaborate on error behavior or idempotency consequences.

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

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

The description is two sentences with no wasted words. Core behavior comes first, the immediate-save and no-validation caveat is included, and the sibling alternative is named succinctly. It is extremely efficient 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?

Given the rich schema, output schema, and annotations, the description is largely sufficient: the agent knows what the tool does, when to avoid it, and what it returns. It could add failure-mode or multi-record behavior details, but the surrounding structured data covers most of the missing 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%, and the input schema already documents domainName and the body array with detailed field descriptions. The tool description does not add new parameter-level meaning beyond stating that records are appended, which is the baseline expectation at this coverage level.

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 object: 'Appends records to a zone.' It clearly distinguishes itself from eurodns_dns_upsert_record by stating what it does not do (validate) and what it does do (save immediately, return saved zone). An agent can identify this tool's unique role among DNS-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 description explicitly directs agents to eurodns_dns_upsert_record for two specific conditions: when validation is desired, or when an existing record should be updated rather than duplicated. This is clear, actionable routing guidance with no ambiguity.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this with 'without changing anything' and 'Nothing is saved.' It also adds useful behavioral context: the report is per-record and the tool is a pre-save diagnostic step. This exceeds the baseline provided by the annotations.

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

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

Two sentences carry a high amount of signal: what the tool does, its side-effect-free nature, and how it relates to save_zone. There is no redundant filler or restatement 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?

Given the rich output schema, annotations, and full parameter documentation, the description provides the missing contextual pieces: when to call it, what makes it valuable versus save_zone, and that the body should match get_zone's response shape. An agent has enough information to select and call the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters well. The description adds meaningful extra semantics by stating that the body is 'in the shape eurodns_dns_get_zone returns,' which tells an agent exactly how to populate the nested body object, and by reaffirming that nothing is saved.

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 ('validates'), a clear resource ('candidate zone'), and states the outcome ('returns a per-record report'). It also explicitly differentiates the tool from eurodns_dns_save_zone, so an agent can distinguish it from a key sibling without inspecting the schema.

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

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

The description gives explicit guidance: use this tool before eurodns_dns_save_zone, because a rejected save only returns a generic error while this tool reports the reason for each offending record. This directly answers when and why to use the tool versus the relevant alternative.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value beyond those annotations by explicitly stating 'without saving anything' (confirming the operation is purely non-persistent), describing the output shape as 'a per-record report', and disclosing that the sibling save tool fails with generic errors only. It does not elaborate on side effects or edge cases, but for a read-only validation tool with openWorldHint=true, the disclosures are adequate.

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

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

Two sentences, zero filler. The first sentence front-loads the core action and the non-persistence guarantee; the second delivers targeted usage guidance naming two siblings. Every clause earns its place, and the structure mirrors an agent's decision sequence: what → when → versus what.

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 validate-only tool with a rich output schema (the report structure is fully documented), an existing schema covering the single input parameter, and annotations covering the safety profile, the description is complete. It covers the operation's purpose, its non-destructive nature, its position in the save workflow, and its distinction from the live-zone checker. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% (the single required 'body' parameter is described as 'The candidate profile to validate: name, records, urlForwards and mailForwards. Nothing is saved.'), so the schema carries the parameter-documentation burden. The tool description reinforces that the body is a 'candidate zone profile' but adds no syntax, defaults, or format details beyond what the schema already states. This matches the baseline 3 for full 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 ('Validates') and a specific resource ('candidate zone profile'), and immediately states what it returns ('a per-record report') and what it does not do ('without saving anything'). It explicitly names two siblings to distinguish itself: eurodns_dns_save_zone_profile (the follow-up action) and eurodns_dns_check_zone (checks a live zone instead of a template). An agent can tell this tool apart from all 48 siblings 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 gives an explicit workflow position: 'Use it before eurodns_dns_save_zone_profile', with the rationale that the save tool's 'rejections carry only a generic error'. It also draws a precise boundary between templates and live zones by contrasting with eurodns_dns_check_zone. This is exemplary when-to-use guidance with both an inclusion and an exclusion.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true. The description adds valuable behavioral detail beyond these: it resolves the record id from the live zone when type/host are given, and it refuses ambiguous selections rather than guessing. This gives an agent realistic expectations about failure modes and safety without contradicting the annotations.

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

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

Three sentences, each earning its place: the main action and modes, the ambiguity safety rule, and the prerequisite read step. The most important information is front-loaded and there is no redundant phrasing 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?

Given the tool's moderate complexity and the presence of an output schema, the description covers everything an agent needs to select and invoke it correctly: the two identification strategies, disambiguation rule, and a concrete precondition. Return values are already documented by the output schema, so no gap remains.

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

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

Schema coverage is 100%, so the baseline is 3. The description enhances the schema by explaining the relationship between recordId and type/host (mutually exclusive paths) and clarifying when rdata is necessary ('several records share a type and host'). This adds meaning beyond the individual property descriptions.

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

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

The description states a specific action ('Deletes one DNS record from a zone') and names the two distinct invocation modes (by recordId or by type and host). This clearly distinguishes it from sibling tools like eurodns_dns_add_records and eurodns_dns_upsert_record, making its purpose unambiguous.

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

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

The description gives clear context on how to identify the target record and explicitly advises reading the zone first with eurodns_dns_get_zone. It does not explicitly enumerate when not to use this tool versus alternatives like save_zone, but the selection logic and prerequisite are valuable enough to earn a 4.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false; the description adds important context: the deletion is permanent, no snapshot exists for restoration, and success returns nothing. This helps the agent set user expectations and take caution. There is no contradiction.

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

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

Three sentences front-load the core action and result, then add the risk caveat and the sibling alternative. No filler; each sentence contributes useful decision 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?

With one well-schemaed parameter, strong annotations, and an output schema, the description covers the outcome, the irreversibility, the prerequisite check, and the alternative tool—enough for an agent to call it correctly.

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

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

The single parameter is fully documented in the schema (100% coverage), including how to obtain the id. The description references the id but introduces no new parameter semantics beyond the schema, so baseline 3 applies.

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

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

The description uses a specific verb ('Deletes'), names the resource ('zone profile'), and qualifies the action as permanent. It also distinguishes itself from siblings by explicitly routing edit operations to eurodns_dns_save_zone_profile and verification to eurodns_dns_get_zone_profile.

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 tells the agent to first confirm the id and contents with eurodns_dns_get_zone_profile, and explicitly says to use eurodns_dns_save_zone_profile when the intent is to change rather than remove. This is explicit when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value beyond annotations by disclosing the diff-like output breakdown (added, updated, unchanged) and explicitly noting it writes nothing. It does not contradict any annotation, but could still disclose edge-case behavior; the strong annotation baseline makes 4 appropriate.

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

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

Two sentences with no wasted words. The first sentence front-loads the core behavior and result categories, while the second gives concise routing guidance. 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 read-only diff tool with only 2 required parameters, full schema coverage, and an output schema present, the description fully covers the necessary context: what it does, when to use it, and which sibling tools to avoid. Combined with the annotations and schema, nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents domainName and records thoroughly, including the allowed TTL values and the 'rdata' field reminder. The description's phrase 'proposed record set' adds minimal semantic value beyond the schema, so the baseline 3 applies.

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

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

The description uses a specific verb ('Reports what would change') and resource ('the given records applied to a zone'), and clearly distinguishes itself from siblings by naming eurodns_dns_upsert_record and eurodns_dns_check_zone. It also states the exact output categories (added, updated, unchanged), leaving 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 description explicitly says to use this tool to review a change before performing it with eurodns_dns_upsert_record, and directs users to eurodns_dns_check_zone for the API's validation report on a full zone document. This is a clear when-to-use directive with concrete alternatives, leaving nothing to inference.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds value beyond those hints by stating exactly what it returns (DNSSEC-signed status, keys, DS data) and by flagging a temporal behavior: checking before DNSEC mutations and after nameserver changes.

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 front-loaded sentences contain no filler. The first sentence states the tool's function and output; the second provides actionable usage guidance. Every sentence earns its place.

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

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

For a single-parameter, read-only, idempotent tool with an output schema, the description is complete. It covers what the tool reports, what data it returns, and when to use it, leaving no critical gap for correct invocation.

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

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

The input schema covers the sole parameter fully, defining domainName with an example and clarification that the domain's DNS must be hosted here. The description adds no extra 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 states a specific action and resource: 'Reports whether the zone is DNSSEC-signed and returns its keys and DS data.' This clearly distinguishes the tool from the many DNS-related siblings by focusing on DNSSEC status, keys, and DS data rather than general zone records or profiles.

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

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

The description gives explicit usage timing: check before eurodns_dns_set_dnssec or eurodns_domain_set_dnssec, and again after changing nameservers. This is clear context, though it does not explicitly exclude alternatives among the other DNS get tools.

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

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

Annotations already indicate read-only and idempotent behavior; the description adds useful workflow context by noting record IDs are returned for other tools, with no contradictory side-effect claims.

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 focused sentences, front-loading the main purpose and immediately giving actionable usage guidance without 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?

Given the output schema exists and the tool is a straightforward read operation, the description sufficiently explains what is returned and how it fits into the broader workflow.

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 covers the single parameter with a clear format example; the description does not add further parameter behavior beyond what the schema provides.

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

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

Description clearly states the tool returns a full DNS zone including records and forwards, and distinguishes it from editing tools by naming 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?

Explicitly instructs to start here before making changes and directs users to upsert/delete tools for single-record edits instead of saving the whole zone.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: the mode-switching behavior (get-by-id vs. list when id is omitted), the content scope of a full profile ('records, URL forwards and mail forwards'), and the destructive-replace semantics of the sibling save tool. No contradiction with annotations.

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

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

Two sentences with zero filler: the primary return behavior is front-loaded, the domain concept (profile vs. zone template) is established in a clause, and the critical read-before-save warning earns its place. Every sentence carries load-bearing 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 six-parameter, dual-mode tool, the combination is nearly complete: output schema documents return values, annotations cover idempotency and safety, the schema documents pagination and sorting, and the description covers the conceptual model and the save relationship. The only residual gap is that it never explicitly tells an agent to use eurodns_dns_get_zone when live zone data — not a profile template — is needed; it only implies the distinction.

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 schema's own parameter descriptions are unusually rich (pagination semantics, character-limit truncation, sortField spelling). The description's 'by id, or lists ... when id is omitted' restates what the id parameter schema already says ('Omit it to list the account's zone profiles'), so the description adds essentially no net-new parameter meaning beyond the structured data. 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 names a specific verb and resource ('Returns one zone profile in full') plus a second mode ('lists the account's profiles when id is omitted'), and defines what a profile is ('reusable templates applied to new zones'), which distinguishes it from the sibling eurodns_dns_get_zone that targets live zones. It also explicitly names eurodns_dns_save_zone_profile as the counterpart, so an agent can tell this tool apart from its siblings without opening 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?

Provides explicit sequencing guidance: 'read one before eurodns_dns_save_zone_profile', with the reason attached ('which replaces the whole profile with what you send'). This tells the agent when to call this tool in a workflow, but it does not state any explicit when-not or route to alternatives like eurodns_dns_get_zone for live zone data, so it stops short of full exclusion guidance.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds useful behavioral context about the dual mode: listing snapshots when id is omitted versus returning a specific snapshot when id is provided, plus the intended use case around rollback.

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 concise sentences, with the core behavior front-loaded and the recovery workflow in the second sentence. Every phrase earns its place and there is no redundancy.

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

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

Given the simple parameter set, rich schema, annotations, and existing output schema, the description covers the essential scenarios: retrieving a snapshot and listing snapshots. It also connects the tool to the adjacent save tool, making the overall behavior complete for an agent.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The tool description reinforces that id is optional and its omission switches to listing mode, but it does not add substantial new parameter-level meaning beyond the schema.

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

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

The description clearly identifies the action as returning a single previous zone state by snapshot id, or listing snapshots when id is omitted. It distinguishes this tool from others in the sibling list by naming the related save/restore path.

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

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

The description explicitly states when to use the tool: to inspect what a zone held before an unintended change. It also gives clear guidance on the alternative path, saying to use eurodns_dns_save_zone to restore that 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?

Discloses the destructive consequence beyond the annotations: 'Anything absent from the submitted document is deleted.' Annotations already mark it as a write (readOnlyHint=false) and idempotent, so the description's value-add is precisely the 'what gets destroyed' warning plus the safety precondition. Note: destructiveHint=false slightly understates this, but the description corrects rather than contradicts it.

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

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

Three sentences, zero filler, with the most critical fact (entire-zone replacement) front-loaded before consequences and alternatives. Every sentence carries decision-relevant 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 complex tool with a nested zone document, the description covers the key decision point (replace-all vs. upsert) and the data-loss risk. A small gap: it references 'a complete zone you have just read' without naming eurodns_dns_get_zone as the read source, leaving a slightly vague prerequisite for a less-informed agent.

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

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

Schema description coverage is 100%; the body parameter's schema description already explains that it must be the complete zone, that omissions are deleted, and that record values go in rdata. The tool description mainly reinforces the 'complete zone you have just read' precondition rather than adding new parameter-level meaning, so the high-coverage 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?

Opens with 'Replaces a zone in its entirety' — a specific verb and resource that corrects the vaguer title ('Save a DNS zone') by pinning down full-replacement semantics. The follow-up sentence ('Anything absent... is deleted') removes any ambiguity about partial vs. full save.

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?

Explicitly states the safe usage condition ('only safe with a complete zone you have just read') and names the alternative for the common single-record case ('prefer eurodns_dns_upsert_record, which reads, validates and saves for you'). This is textbook when-to-use / when-not-to-use guidance tied to a specific sibling.

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

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

Discloses the critical behavioral trait beyond annotations: replacing is 'in its entirety' and 'Records absent from the submitted document are dropped' — a direct data-loss warning an agent must know before invoking. It also states the return value and interacts well with openWorldHint=true, where the get-first advice mitigates the risk of dropping records the agent doesn't know about. No conflict with readOnlyHint=false; destructiveHint=false is consistent with save-not-delete semantics while the description still surfaces the destructive nuance.

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

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

Three dense sentences front-load the core action, follow with the most dangerous consequence (dropped records), and close with workflow routing. Every sentence earns its place; roughly 60 words cover a genuinely complex dual-mode tool.

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 dual create/replace semantics, destructive replacement behavior, and a rich output schema, the description covers all that matters: the two modes, the data-loss risk, the safe update starting point, and the non-saving validation alternative. Return-value details are handled by the output schema, so nothing essential is missing.

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

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

Schema coverage is 100% and the body parameter's own description already carries the replacement warning and the 'Record values go in rdata' hint, so the baseline is 3. The tool description adds the create-versus-replace trigger (id omitted vs. present), reinforcing and slightly extending what the schema states, which justifies a point above 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 names concrete verbs and resources — 'Creates a zone profile when id is omitted, or replaces the profile with that id in its entirety' — and immediately contrasts the two modes an agent needs to disambiguate. It also differentiates from the sibling family (get, check, delete profile) well enough that an agent can pick it out 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?

Provides explicit routing: 'start from eurodns_dns_get_zone_profile when updating' and 'eurodns_dns_check_zone_profile validates a candidate first without saving.' This tells the agent exactly when to use this tool versus its alternatives and gives the safe workflow for update versus validate.

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

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

Beyond the annotations, the description discloses that the tool returns nothing on success and warns that stopping signing while a DS record is published can cause validation failures. This is meaningful behavioral context not inferable from readOnlyHint=false or destructiveHint=false, and it does not contradict any annotation.

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

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

Three sentences with no filler: the action comes first, then the critical usage distinction, then the risk warning. Every sentence earns its place and the most decision-relevant caveat is included without bloating 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?

With an output schema, two fully documented parameters, explicit sibling differentiation, and a warning about failure conditions, the description is complete for safe and correct invocation. No material gap remains for an agent deciding whether and how to use this tool.

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

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

Schema coverage is 100% and both parameters already have inline descriptions. The description still adds value by clarifying that domainName means a zone hosted here and by linking enabled to the start/stop behavior, which strengthens an agent's understanding beyond the raw 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 ('Starts'/'stops') with a clear resource ('DNSSEC signing of a zone') and explicitly distinguishes itself from eurodns_domain_set_dnssec. An agent can immediately tell what the tool does and how it differs from a similarly named sibling.

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

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

The description gives explicit usage boundaries: use it only for domains registered elsewhere, and for domains registered here use eurodns_domain_set_dnssec instead. It also references eurodns_dns_get_dnssec_status for checking state, giving the agent a clear decision path.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, and the description is consistent. It adds useful workflow behavior: reads the zone, applies the change, validates with the API, and saves only if validation passes. This is valuable context beyond the annotations, though it doesn't describe failure outcomes in 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?

Three sentences, each earning its place: what it does, the read-validate-save workflow, and the explicit warning against the destructive sibling. Front-loaded and free of 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 an output schema exists and all parameters are documented in the schema, the description covers the essential operational semantics: identity key, validation flow, and alternative routing. A minor gap is unspecified behavior on validation failure, but this is mitigated by the output schema and annotations.

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 reinforces that 'type and host' form the identity key, which helps agents use required parameters correctly, but it doesn't add detail beyond what the schema descriptions already provide.

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 specific verbs ('Adds', 'updates') and names the exact resource ('DNS record in a zone') with the matching key ('same type and host'). It clearly distinguishes this from siblings like eurodns_dns_add_records, eurodns_dns_delete_record, and eurodns_dns_save_zone.

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?

Explicitly instructs 'Prefer this over saving a zone directly' and explains why: saving 'replaces the whole zone and drops anything not included.' This gives an agent a clear decision rule between this tool and eurodns_dns_save_zone, plus the add-vs-update condition.

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

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

The description adds useful behavioral context beyond the annotations by explaining that the tool queries registries, which supports openWorldHint and clarifies why it works for external names. It does not contradict the readOnlyHint or destructiveHint, and the output schema covers return 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 two sentences with no wasted words. The core purpose is front-loaded, and the second sentence efficiently explains scope and directs to the relevant sibling tool.

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

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

With a single parameter, a full output schema, and safety annotations already present, the description provides all necessary context. It covers scope, behavior, and the key alternative, leaving no important gap for an agent to invoke the tool correctly.

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

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

The input schema already provides complete parameter documentation with a clear example and explanation of 'fully qualified names'. The tool description itself does not add parameter semantics, so the high schema coverage keeps this at the baseline score.

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

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

The description clearly states the specific action: checking whether domain names are available to register and returning availability for each. It also distinguishes itself from eurodns_domain_get by noting that registered account domains should be handled there, making the purpose and scope 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 explicit guidance on when to use this tool by stating it queries registries and works for any name, whether registered here or not. It also names eurodns_domain_get as the alternative for domains already in the account, giving clear routing advice.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds value beyond annotations by scoping the operation to domains 'already registered in this account' and disclosing the returned data categories (status, expiry, renewal method, contacts, nameservers). No contradiction with annotations.

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

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

Two sentences, zero filler, with the core purpose front-loaded in the first sentence and sibling routing efficiently packed into the second. Every clause earns its place, and the semicolon-separated alternatives remain readable.

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

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

For a single-parameter read tool with a full output schema and safety annotations, nothing essential is missing. The description covers what the tool returns, which account scope it operates on, and routes both related use cases (availability checking and search) to the correct siblings.

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

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

Schema description coverage is 100%, and the single parameter's schema description is already strong ('Fully qualified domain name, e.g. example.com, as listed by eurodns_domain_search'). The tool description adds no new parameter-level detail beyond reinforcing the account-scoping context, so the baseline of 3 is appropriate — the schema carries the burden adequately.

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 ('Returns'), a specific resource ('one domain already registered in this account'), and enumerates exactly what is returned (status, expiry, renewal method, contacts, nameservers). It also differentiates itself from sibling tools by naming eurodns_domain_check_availability and eurodns_domain_search as distinct tools for other purposes.

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

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

The description gives explicit when-to-use guidance: 'Use it for a domain you hold'. It then names two alternatives with the conditions that select them — check availability via eurodns_domain_check_availability, find by criteria via eurodns_domain_search. This is fully explicit routing with no inference 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds non-obvious behavioral context: the search is strictly account-scoped ('never reports on domains held elsewhere') and returns summaries rather than full objects. This complements the annotations with scope and output-shape information they cannot convey, and nothing contradicts them.

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

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

Two sentences with zero filler: the first delivers function, filter scope, and return shape; the second adds the scope boundary and sibling routing. The most decision-relevant information is front-loaded, and 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?

Between the description, the exhaustive 100%-covered schema (including a strong body-level summary and pagination guidance), and the presence of an output schema, an agent has everything it needs to call this correctly. Minor gaps such as driver-level constraints and page-walking behaviour live in the schema rather than the top-level description, but nothing essential is missing.

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

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

Schema coverage is 100% — every parameter and nested body field has a description, including genuinely helpful guidance like 'walk pages until a short one comes back' and 'a wide page is truncated by the character limit'. The description only adds coarse semantic grouping ('filters for expiry, renewability and DNSSEC'), which is useful framing but does not carry meaning the schema lacks, so the baseline 3 holds.

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 ('searches'), a specific resource ('domains held in this account'), and the return shape ('one summary per domain'). It explicitly contrasts itself with eurodns_domain_get ('returns one domain in full'), so an agent can distinguish it from its closest sibling without inspecting 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?

It identifies this as 'the inventory query' and names eurodns_domain_get as the full-detail alternative, giving a clear selection condition: use this for summarised account inventory, use domain_get for one complete domain. It doesn't address other search-adjacent siblings such as eurodns_subscription_search or eurodns_domain_check_availability, though their distinct resource names lower the confusion risk.

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

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

The description adds important behavioral context beyond the annotations: it states the operation publishes or withdraws DS records at the registry, returns nothing on success, and highlights a concrete consequence of misuse (breaking validation for cached DS records). The readOnlyHint=false annotation is consistent with this mutating operation, and openWorldHint=true is appropriately paired with the registry-level side effect warning.

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

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

The description is three sentences with zero filler. The core action is stated first, followed by usage guidance and risk awareness, then the verification step. Every sentence earns its place and the most decision-relevant 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 two-parameter tool with a fully documented schema and an output schema, the description covers all essential surrounding context: the account-scoped domain prerequisite, the distinction from the similar sibling tool, the risk of premature withdrawal, and the follow-up verification step. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, so the parameters are already fully documented in the input schema. The description reinforces the enabled=true/false semantics and domain scope but does not add substantial new meaning beyond what the schema provides. 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 operation: publishing or withdrawing DNSSEC DS records for a domain registered in the account. It also names the sibling tool it is not (eurodns_dns_set_dnssec) and clarifies the resource scope, making it clearly distinguishable from the DNS-level 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 explicitly says to prefer this tool over eurodns_dns_set_dnssec for domains held in the account, implying the alternative when domains are not held here. It also warns about the risk of withdrawing while the zone stays signed and directs the agent to verify with eurodns_dns_get_dnssec_status, leaving no ambiguity about when and how to use it.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the bar for additional disclosure is lower. The description still adds value by revealing the dual get/search behavior, the specific data returned (mailbox, aliases, catch-all state), and the id's role across sibling tools, all beyond what the annotations state.

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

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

Two dense sentences carry all essential information without redundancy. The primary behavior is front-loaded, and the sibling differentiation and cross-tool id mapping are packed tightly but efficiently, 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?

Given the tool's dual mode, eight parameters, and existing output schema, the description covers the essential context: what is returned, when each mode applies, what filters are relevant, and how this tool relates to the mutation siblings. Nothing critical is missing for an agent to select and invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents every parameter individually. The description adds meaningful cross-tool semantics by stating that the id returned here is exactly what eurodns_email_set_alias, eurodns_email_set_catchall, and eurodns_email_update_password expect, and that omitting id switches to search mode with filters.

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

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

The description states a precise verb ('Returns one email subscription ... or searches') with an explicit resource and result content: the mailbox, aliases, and catch-all state. It also distinguishes itself from siblings by naming eurodns_subscription_search as the alternative for every product at once.

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 clearly explains when to use the get mode versus the search mode: provide id for a single subscription, omit id to search by status, domain, and user name. It also tells the agent that the id is the same one consumed by the alias, catch-all, and password mutation tools, and directs broader queries to eurodns_subscription_search.

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

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

Annotations already declare destructiveHint=true and readOnly=false, so the mutating nature is covered. The description adds useful behavioral context beyond annotations: the operation returns the updated subscription and explains that the alias delivers into the mailbox. It doesn't discuss irreversibility, but that is reasonably implied by the remove action.

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

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

Three sentences with no filler. The core operation is front-loaded, the sibling alternative is clearly identified, and the id source is given last without redundancy.

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

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

Given the output schema exists, the description covers all necessary decision points: what action this tool performs, when to choose this over the catch-all sibling, what it returns, and where to obtain the subscription id. No meaningful gap remains.

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

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

The input schema already provides full descriptions for all three parameters, including the enum for action and a concrete example for alias. The description adds only mild value by reinforcing where the subscription id comes from and clarifying the alias purpose, so the baseline 3 applies.

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

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

States a specific verb and resource: add or remove a mailbox alias, and explicitly distinguishes this from eurodns_email_set_catchall. The action parameter is directly reflected in the description, leaving no ambiguity.

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

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

Provides explicit guidance on when to use this tool ('named extra address') and names the alternative for catch-all usage. It also tells the agent where to get the subscription id, eliminating a prerequisite lookup.

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 annotations already indicating a non-read-only, potentially destructive mutation, the description adds useful behavioral context: it returns the updated subscription, and it warns about increased unsolicited mail when enabled and refusal when disabled. It does not contradict the annotations.

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

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

Three sentences, each earning its place: the action and return value, the behavioral consequence, and the sibling alternative. The core statement is front-loaded, with no filler or repetition.

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

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

For a simple two-parameter tool with a rich input schema, an output schema, and strong annotations, the description covers the action, the return value, the practical impact, and the alternative tool. Nothing essential is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds semantic value by mapping enabled:true to 'on' and enabled:false to 'off' and explaining the resulting mail routing behavior, going beyond the schema's brief descriptions.

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

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

States a specific verb and resource: 'Turns the catch-all on (enabled: true) or off (enabled: false) for an email subscription.' It clearly differentiates from the sibling eurodns_email_set_alias by noting the scope is domain-wide rather than a single named address.

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

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

Provides explicit alternative guidance: 'For one named address use eurodns_email_set_alias.' It also explains the practical consequences of each setting (delivering unknown addresses vs. refusing such mail), which helps an agent decide when to call this 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?

Annotations already convey readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavioral context beyond these: the password is 'written straight through to the provider and never recorded here,' and the operation returns the updated subscription. This discloses data-handling behavior that the annotations do not cover.

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

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

Two sentences with no filler. The primary action is front-loaded, followed by return behavior and a valuable note about data handling. The reference to the sibling tool is concise and earned.

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 rich input schema with 100% coverage, an output schema, and annotations covering safety/idempotence, the description supplies the remaining essential context: what the operation does, what it returns, and how to find the target subscription. An agent has enough information to invoke it correctly without missing dependencies.

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 both 'id' and 'body' fully documented in the input schema, including the nested password fields. The description adds little beyond what the schema already states, which is acceptable given the schema carries the semantic load. 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 names a specific verb, resource, and outcome: 'Sets a new password on the mailbox of an email subscription and returns the updated subscription.' This clearly distinguishes it from sibling email tools like set_alias and set_catchall, and the reference to get_subscription further orients the agent.

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 tells the agent how to locate the target entity by instructing to 'find the subscription with eurodns_email_get_subscription,' which provides a clear prerequisite. It does not explicitly list when-not-to-use or contrast with alternative email mutation tools, but the purpose is specific enough that an agent can infer the correct selection context.

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

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

Annotations (readOnlyHint=true, idempotentHint=true, destructiveHint=false, openWorldHint=true) already cover the safety profile. The description adds value beyond them by disclosing the returned fields and the behavioral constraint that HTTPS redirect subscriptions cannot be listed independently. Minor gap: no mention of behavior for a nonexistent/invalid id.

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

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

Two sentences with zero waste. The first front-loads the core action and return values; the second adds the critical id-acquisition path and the no-listing caveat. 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 single-parameter read-only getter with an output schema and full annotation coverage, the description is nearly complete: it covers what is returned, how to find the id, and the absence of listing. The only residual gap is error/not-found behavior for an invalid subscriptionId, which is minor at this complexity level.

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

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

Schema description coverage is 100% and the subscriptionId parameter already carries a thorough description, including its source (eurodns_subscription_search filtered on HTTPS_REDIRECT) and type. The tool description reinforces this but adds no new meaning beyond the schema, so the high-coverage baseline of 3 applies.

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

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

The description states a specific verb ('Returns'), a specific resource (HTTPS redirect subscription), and the exact fields returned (status, domain, term). It also differentiates this tool from sibling getters like eurodns_ssl_get_subscription and eurodns_email_get_subscription by tying it to the HTTPS_REDIRECT subscription type and naming the search tool that provides the id.

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?

Explicitly directs the agent to eurodns_subscription_search filtered on HTTPS_REDIRECT to obtain the id, and warns that no standalone listing exists. This tells the agent precisely when to use this tool versus alternatives, including the prerequisite step.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint: false, so the safety profile is fully covered by structured data. The description adds the consequential behavioral trait that omitting the id parameter changes the call from a single-invoice fetch into a search, and it sets scope expectations via sibling routing. It omits pagination and response-shape details, but those are covered by the schema and output schema respectively.

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

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

Two sentences with zero filler: the first front-loads the core dual-mode behavior, and the second delivers usage guidance and sibling routing. 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 complex 14-parameter, dual-mode tool, this description combined with a 100%-covered schema, four annotations, and an output schema leaves little unresolved. The only implicit point is that search mode returns a paginated set rather than everything at once, which the page and size parameter descriptions already clarify.

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 and the schema carries the full parameter burden, including per-status enum meanings and pagination quirks. The description contributes only a high-level grouping of filter dimensions (date, type, status, order, invoice profile), which helps quick mapping but adds no new semantics beyond the schema.

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

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

The description names a specific verb and resource — 'Returns one invoice with its lines by id, or searches invoices' — and covers both operating modes in a single sentence. It also distinguishes itself from siblings by explicitly naming eurodns_order_get and eurodns_invoice_profile_get as the homes for order and billing-identity 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 second sentence is an explicit usage directive: 'Use it for what was billed and whether it is paid.' It then names the alternatives for adjacent concerns — 'the order behind a line is in eurodns_order_get, and the billing identity in eurodns_invoice_profile_get' — so an agent knows exactly when not to use this 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful behavioral context beyond annotations: the tool switches between fetching a single profile and searching depending on whether id is present, and it explains the downstream invoice-listing workflow. No contradiction exists.

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

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

Two sentences carry the full purpose, the search behavior, the returned data scope, and the intended downstream use. Information is front-loaded and no words are wasted.

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 rich input schema, output schema, and annotations, the description fully covers what an agent needs to select and call this tool correctly. It explains the id-vs-search branching, the billing profile semantics, and how results connect to eurodns_invoice_get.

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 already 3. The description adds genuine semantic value by explaining that omitting id triggers the search path and that the returned profile id feeds into eurodns_invoice_get, which clarifies the central decision logic of the 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 states a specific verb and resource: it returns one customer invoice profile by id, or searches profiles by filters when id is omitted. It also names the specific billing data returned (name, address, VAT details), which clearly distinguishes this tool from generic profile or domain tools in the sibling list.

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 for when to use this tool: to locate the profile id a customer is billed under and then pass that id as cipId to eurodns_invoice_get. It explains the dual mode (get by id vs search when id is omitted) but does not explicitly name alternative search tools or state when not to use it, so it stops short of a perfect score.

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

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

Annotations already carry read-only, idempotent, open-world, and non-destructive safety, and the description reinforces that with 'reads the subscription record only — nothing here manages the tenant'. It adds useful behavioral context: using it is non-managing, and it exposes the tenant boundary. It doesn't mention pagination, but that behavior is already described inside the page/size parameters.

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

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

Two sentences, no filler, with the primary return semantics first and the alternative search mode second. The one-sentence sibling pointer is efficient. It packs a lot of meaning without bloating, though it could have been even shorter by omitting the parenthetical account-label phrase inside the first sentence, since the parameter schema already says it.

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 an 8-parameter, 0-required, read-only tool with an output schema and 100% schema parameter coverage, the description is complete. It explains the get-vs-search behavior, names the all-products sibling, and confirms the read-only/non-tenant-managing nature. Nothing an agent needs to choose or call it correctly is missing.

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

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

Schema coverage is 100%, so the schema already documents all 8 parameters. The description does not repeat parameter docs, which is correct. It adds meaning by explaining the id-omitted search semantics and reinforcing that sortField is spelled as in response items, when/where that matters. The description also clarifies the overall mode switch that gives meaning to id vs. filters.

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

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

The description names a specific verb (returns one subscription or searches them) and resource (Microsoft 365 subscriptions), lists the identity/status/domain/term fields, and distinguishes it from eurodns_subscription_search. It also notes that the sibling covers every product at once, so an agent can tell this from eurodns_email_get_subscription and eurodns_ssl_get_subscription too.

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

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

It explicitly says searches by status, domain and account label when id is omitted, which is exactly the mode-switch an agent needs to decide between a single-object get and a search. It differentiates from eurodns_subscription_search by saying 'every product at once is eurodns_subscription_search'. It does not list the other per-product getters by name, but the schema params are Microsoft-specific, so the sibling list plus the phrase 'Microsoft subscription' gives enough route.

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

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

Annotations cover read-only, idempotent, non-destructive behavior, so the description only needs to add non-safety behavior. It adds the dual id-or-list behavior, the default/deletable marking, and the relationship to save_profile. This is useful context beyond the annotations.

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

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

Two sentences, front-loaded with the core behavior, then a practical use case and sibling differentiation. Every clause earns its place and there is no filler or repetition of schema 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?

The description is complete for an agent to select and call the tool: it explains dual-mode behavior, the list markers, and the save alternative. The output schema exists, so return values need not be described, and all parameter semantics live in the input schema. Minor gaps like pagination nuance are already present in 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 description coverage is 100%, so the baseline is 3. The description adds only the high-level meaning of omitting id ('lists the account's nameserver profiles'), while detailed parameter semantics like page size and filtering are already fully documented in the schema. This is adequate but not compensatory beyond 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 clear dual behavior: returns one nameserver set by id, or lists all profiles when id is omitted, and notes the default/deletable markers. It distinguishes itself from eurodns_nameserver_save_profile, which is the obvious sibling, and the resource (nameserver profiles) is unambiguous.

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

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

It gives a concrete use case: 'Use it to find the profile a domain should point at' and names the alternative save_profile for creating/rewriting. It does not spell out explicit when-not conditions, but the contrast with the save sibling gives an agent enough 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?

It reveals a critical non-obvious behavior not captured by annotations: the API clears any omitted fields on update, so callers must send every field. It also discloses the return value. This goes well beyond the annotation hints.

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

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

Two sentences deliver the core purpose, the critical update behavior, and a pointer to the prerequisite read tool. No filler and the most important caveat 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 tool with nested objects and an output schema, the description covers the essential logic, the update pitfall, and the prerequisite lookup flow. The schema and annotations cover the rest, so nothing important 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 already complete, but the description adds meaning beyond the schema by explaining the role of id in deciding create versus update and by clarifying that body must contain all fields during update. This materially helps an agent construct correct calls.

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

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

The description clearly states the tool creates a nameserver profile when id is omitted and updates when id is provided, and it returns the saved profile. This distinguishes it from sibling save/profile tools by naming the exact object type and the create/update duality.

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

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

The description explicitly explains when creation versus update occurs based on the presence of id, and instructs users to start from eurodns_nameserver_get_profile for updates. This is actionable usage guidance that directly supports correct invocation.

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

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

The annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, so the bar for additional disclosure is lower. The description adds meaningful behavioral context: the returned order includes lines and delivery status, and omitting id switches the call into search mode. It also reveals that the related invoice lives in eurodns_invoice_get.

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

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

Two sentences, no wasted words. The first sentence states the core behavior and the second provides a motivating use case with a sibling pointer. 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 read-only retrieval/search tool with a full output schema and strong annotations, the description covers both operational modes, gives a concrete scenario, and names a related tool. The detailed filtering and pagination semantics are already thoroughly documented in the schema, so nothing critical is missing.

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

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

Schema description coverage is 100% and the parameter descriptions are already rich, covering id omission, pagination, size truncation, and status enum meanings. The description adds no parameter-level meaning beyond what the schema provides, so the 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 names the exact operation: return one order with its lines and delivery status by id, or search orders by status, date, and description when id is omitted. It clearly distinguishes the dual retrieval/search behavior and differentiates the resource being acted on.

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

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

The description gives a concrete use case: finding out what happened to a subscription that was created but never became active. It also points to eurodns_invoice_get for the related invoice, which helps route the agent to an alternative. It does not enumerate exclusions versus other sibling search tools, but the context is clear enough.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior. The description adds valuable context beyond those: it refreshes a cache, avoids waiting for cache expiry, and has no upstream side effects. This is strong complementary behavioral disclosure, though it does not go into output details or potential latency.

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 focused sentences deliver the core behavior, the triggering condition, and the key non-effect. There is no filler, and the most important information is front-loaded in the first sentence.

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

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

For a zero-parameter, read-only, idempotent cache-refresh operation with an output schema, this description fully covers what an agent needs to select and call it correctly. It states the trigger, the effect, the absence of side effects, and the correct sibling for listing domains.

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 is fully covered with an empty properties object. Baseline for zero-parameter tools is 4; the description does not need to explain parameter meaning.

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 specifies the exact action ('re-reads the account’s domains') and the purpose (refreshing cached domain list so recent names appear immediately). It clearly distinguishes this from listing domains, pointing to eurodns_domain_search for that role.

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

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

It explicitly tells the agent when to use the tool: 'right after such a change' involving a registration or transfer. It also clarifies what the tool does not do ('alters nothing upstream') and routes the actual domain listing to eurodns_domain_search, giving clear decision guidance.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), lowering the bar. The description adds meaningful behavioral context beyond annotations: the id-omitted search mode switch, the returned fields (status, term, domain), and the account-scoped search. No contradiction with annotations.

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

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

Two sentences with zero waste. The primary fetch-by-id behavior is front-loaded, the search mode follows naturally, and the usage guidance and sibling distinction wrap up in the second sentence.

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

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

Complete for a read-only list/fetch tool: 0 required params, full schema coverage, output schema present, rich annotations, and a description that covers purpose, both operation modes, use cases, and the sibling alternative. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% — all 7 parameters carry their own descriptions, so the schema does the heavy lifting. The description alludes to status/domain filtering and id omission, but adds little param-specific meaning beyond what the schema already states. 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 names a specific verb+resource ('Returns one Premium DNS subscription... by id, or searches...'), states the dual-mode behavior clearly, and names the alternative (eurodns_subscription_search) that covers every product. An agent can tell what this tool does and how it differs from related subscription tools 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?

Gives explicit use cases ('check a renewal date or before changing a plan') and an explicit routing rule with a selection condition: eurodns_subscription_search when every product needs to be covered at once. This is exactly the kind of when-to-use vs alternative guidance agents need.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds context about the specific data returned, which is useful, but does not disclose error behavior or other edge cases. With annotations covering the safety profile, this is adequate.

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

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

Two sentences with no filler: the first front-loads what the tool returns, the second gives id provenance and sibling routing. Every phrase earns its place.

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

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

For a simple read-only two-parameter tool with an output schema, the description covers purpose, returned data, id sources, and directs to a sibling for validation-related queries. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% and both parameters are well-documented with origins ('from the certificates eurodns_ssl_get_subscription returns' and 'from the list eurodns_ssl_get_subscription returns when called without an id'). The description merely restates this provenance, adding no new parameter meaning.

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

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

States a specific verb ('Returns') and resource ('one certificate of an SSL subscription'), enumerates the returned fields (common name, SANs, validity dates, issuance status), and differentiates from siblings by explicitly naming eurodns_ssl_get_validation and referencing eurodns_ssl_get_subscription as the source of ids.

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

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

Gives an explicit prerequisite: 'Both ids come from eurodns_ssl_get_subscription.' It also names an alternative for a different need: 'to see how a name is being validated, use eurodns_ssl_get_validation,' effectively providing a when-not condition.

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

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

The readOnly/openWorld/idempotent annotations already establish the safety profile, so the description only needs to add behavioral context beyond them. It adds that the result includes certificates and their expiry and that the tool either returns one subscription or searches, which is useful. It does not fully describe pagination or output shape, but the output schema and detailed parameter descriptions cover those.

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 dense sentences front-load the central dual behavior and follow with a practical routing hint. No words are wasted, and the description earns each clause while remaining readable.

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 rich input schema, complete annotations, and presence of an output schema, the description provides all additional context an agent needs: when to use it, how it differs from siblings, and what data it returns. Nothing critical is missing.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema carries the parameter documentation burden. The description summarizes the filter dimensions (status, common name, SAN, renewability) and the id-omission rule, but adds little beyond what the parameter descriptions already state. It does not introduce new parameter meaning.

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 resource (SSL subscriptions), the verb (returns/searches), and the dual by-id lookup versus filter-based search behavior. It also distinguishes itself from sibling tools by noting that eurodns_subscription_search covers every product, so an agent can select it correctly.

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

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

It explicitly says when to use the tool: to find the certificateId needed by eurodns_ssl_get_certificate and eurodns_ssl_get_validation. It also gives an explicit alternative, eurodns_subscription_search, for all-product searches, and clarifies that omitting id triggers the search variant.

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

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

Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds mild behavioral context by indicating the tool reports the current validation state and the validation method, but it does not disclose details such as auth needs, rate limits, or how the returned token should be handled. Given the annotations cover the main side-effect concerns, this is acceptable but not exceptional.

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 tightly written sentences front-load the core behavior, then give the use case and cross-reference the relevant sibling tools. Every sentence earns its place with no padding, repetition, or irrelevant 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 simple read-only status tool with a full output schema and rich annotations, the description is complete. It explains what the tool returns, when to call it, and what to do next if action is needed. The parameter schema additionally covers how to fill each argument, so no important context is missing.

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

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

Schema description coverage is 100%, so the input schema already documents all three parameters clearly, including where their values come from (e.g., sanName from eurodns_ssl_get_certificate, certificateId and subscriptionId from eurodns_ssl_get_subscription). The description itself adds no parameter-level meaning beyond what the schema provides, 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 states a specific verb ('Returns') with a precise resource: the validation status of one certificate name, including method, approver, token, and current state. It is clearly distinct from sibling tools like get_certificate or get_subscription because it targets validation of a single SAN name. The purpose is unambiguous and actionable.

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

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

The description gives an explicit trigger: 'Check it when an ordered certificate has not been issued.' It also names the exact alternatives for follow-up actions: eurodns_ssl_update_validation_approver for changing the method or approver, and eurodns_ssl_resend_approver_email for resending the email. This fully routes the agent to the correct tool and away from wrong 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?

The description states that the subscription term is unchanged and no charge is made, which are important non-obvious behavioral details. It does not mention potential validation steps or whether the old certificate is invalidated, but the annotations already indicate a non-read-only, non-destructive operation, and the description does not contradict them.

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

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

The description is compact and front-loaded with the main action and result, followed by the key differentiator and alternative. Parameter descriptions are concise and avoid redundancy with the schema.

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

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

Given the output schema is present and the operation is well-scoped, the description provides sufficient context: the operation reissues, returns a new certificate, does not alter term/charge, and points to the alternative for renewal. No critical context appears 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?

All three parameters are described with meaningful detail: subscriptionId and certificateId reference the source lists, and the body parameter explains encodedCsr and sanEntries, including the nuance that SANs are ignored unless multi-domain. This fully supports 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 tool reissues an existing certificate against a new CSR, gives a concrete example (key rotation), and distinguishes it from renewing the term. This leaves no ambiguity about the tool's core 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?

It explicitly provides a use case ('after a key rotation') and names the alternative tool for a different scenario ('to extend the term instead, use eurodns_ssl_renew_subscription'). This gives clear guidance on when to use this operation versus its sibling.

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

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

The annotations already indicate non-read-only, non-idempotent behavior, and the description adds that the tool 'returns nothing on success' and that it resends an email. This gives useful behavioral context beyond the annotations, though it does not elaborate on potential side effects like duplicate emails or failure modes.

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

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

The description is two concise sentences with no redundant information. It packs the action, the condition, the return behavior, and the alternative tool reference into a tight, easily parsed format.

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 resend action, the description is complete: it states what happens, when to use it, what to do in the related wrong-address case, and what the success return is. The sibling-tool context reinforces the surrounding workflow without requiring more detail.

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 with detailed descriptions for all three parameters, including where to obtain each ID. The top-level description does not add significant parameter-level meaning beyond saying 'one certificate name', so it stays at the baseline for high schema coverage.

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

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

The description clearly states the action ('Sends the validation email'), the target ('one certificate name'), and the recipient ('to its approver'). It also distinguishes itself from the sibling tool eurodns_ssl_update_validation_approver by explicitly noting that changing a wrong address should be done there first.

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 an explicit condition for use ('when the approver did not receive it') and an explicit alternative for a different scenario ('if the address itself is wrong, change it first with eurodns_ssl_update_validation_approver'). This leaves no ambiguity about when to choose this 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true, so the mutation profile is covered. The description adds useful details — that only one certificate name is affected and that it returns the updated validation — but does not disclose downstream consequences such as whether changing the method triggers a new validation cycle or invalidates the current one. No contradiction with annotations.

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

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

Two tight sentences with no filler: the first front-loads the action and return value, the second delivers the usage trigger and prerequisite pointer. Every clause earns its place.

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

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

For a 4-parameter mutation with a nested body, output schema, and safety annotations, the description covers purpose, trigger condition, and the lookup dependency well. The one meaningful gap is not explicitly routing agents between this tool and eurodns_ssl_resend_approver_email when the approver can still receive mail, though the trigger phrasing implies the distinction.

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

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

Schema description coverage is 100%, and the schema already explains that approver must come from the allowedApprovers list and that verificationMethod has an enum with per-method behavior details. The tool description reinforces the connection to eurodns_ssl_get_validation, but adds no parameter information beyond what the schema provides, so the baseline 3 applies.

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

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

The description states a specific verb and resource: 'Changes the validation method or approver address for one certificate name and returns the updated validation.' This clearly distinguishes it from read-only siblings like eurodns_ssl_get_validation, email-resend siblings like eurodns_ssl_resend_approver_email, and broader operations like eurodns_ssl_reissue_certificate.

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

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

The description gives an explicit trigger condition: 'Use it when the current approver cannot receive the email,' which implies the alternative case where the approver is reachable. It names eurodns_ssl_get_validation as the prerequisite lookup for allowed approvers, but does not explicitly discuss the adjacent alternative eurodns_ssl_resend_approver_email or state a when-not-to-use condition.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive behavior. The description adds useful context beyond those annotations: it returns status, expiry, and auto-renewal settings across all products, and clarifies that product-specific tools return the full record. It doesn't need to restate safety traits the annotations already cover.

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

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

Two sentences with no wasted words. The main behavior is front-loaded, and the second sentence provides actionable routing guidance. The description earns its place without redundancy.

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

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

Given the fully documented 8-parameter schema, an output schema, and comprehensive annotations, the description is complete enough. It explains the cross-product scope, the typical use case, and the path to sibling tools. Any remaining operational details like pagination and sorting are already documented in 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 description coverage is 100%, so the baseline is 3. The description does not add parameter-level guidance beyond what the schema already documents, such as filtering by domainName, autoRenewEnabled, subscriptionTypes, or subscriptionStatus. This is acceptable 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 states a specific verb and resource: it searches every subscription on the account across all products, and lists representative product types. It also distinguishes itself from product-specific siblings by positioning itself as the cross-product search and pointing to eurodns_ssl_get_subscription and its siblings for full records.

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

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

It explicitly says to start here for an expiry review and to switch to product-specific subscription tools once the product is known. This gives the agent both a when-to-use and a clear when-to-use-an-alternative signal.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond those: the list is scoped to 'the TLDs this account can order' (narrowing the openWorldHint expectation) and warns that 'the full list is large', which informs agent pagination strategy. No contradiction with annotations.

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

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

Two sentences with zero filler: the first front-loads the primary get-by-id behavior and return contents, the second delivers usage guidance and a scale warning. Every clause earns its place, and the compact structure handles a dual-mode tool without redundancy.

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

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

For a dual-mode, 6-parameter read tool with pagination, the combination of the description, 100%-covered schema, output schema, and annotations is nearly complete: account scoping, large-list warning, and use-before-ordering guidance are all present. The one minor gap is that sort behavior is not tied to the list mode in the description, though the schema's sortField note covers it implicitly.

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

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

Schema description coverage is 100%, and the schema descriptions are unusually rich (e.g., 'walk pages until a short one comes back', 'a wide page is truncated by the character limit'). The description reinforces id, tldName, and page usage but adds no meaning beyond the schema, so the baseline 3 applies.

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

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

The description uses specific verbs bound to a distinct resource: 'Returns one TLD by id with its registration terms, duration limits and registry-specific requirements, or lists the TLDs this account can order when id is omitted.' It fully disambiguates the dual-mode behavior and names concrete return contents, and the TLD resource is unique among all siblings, so it cannot be confused with eurodns_domain_get or eurodns_domain_check_availability.

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

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

The description gives explicit when-to-use guidance: 'Check a TLD before ordering an unfamiliar extension', plus a concrete how-to-use recommendation to filter with tldName or page instead of requesting the full list. It does not name an alternative tool or state when-not-to-use, but no sibling covers TLD metadata, so exclusions are less critical.

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