TLDMath

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

Annotations already declare readOnlyHint and idempotentHint, covering the non-mutating nature. The description adds useful behavioral context: it explicitly notes that X, Instagram, and TikTok are only manually checked via links, and includes a 'Not legal advice' caveat. This goes beyond what annotations provide without contradicting 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 a single, well-structured sentence that front-loads the core action and platform list, then adds manual-check links and the legal disclaimer. Every clause serves a purpose; there is no redundant or filler 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?

For a simple one-parameter read-only tool, the description covers the essential scope (which platforms are checked, which are manual, trademark links, and the legal caveat). It lacks explicit return format details, but given no output schema exists, a brief mention of return type could improve completeness. The core information needed to decide on and invoke the tool is present.

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

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

The schema fully describes the only parameter (name) with a pattern, length constraints, and an example. Schema description coverage is 100%, so the description does not need to add parameter details. The description adds no extra parameter semantics beyond the schema, matching the baseline of 3 for high 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 a specific verb ('check') and resource ('name free as a handle') across enumerated platforms (GitHub, npm, PyPI, crates.io, YouTube) and trademark databases. It distinctly differentiates from sibling tools focused on domains and DNS by listing social and trademark checks, making the tool's 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 implies usage context by listing specific platforms and trademark databases, which clearly separates it from domain-focused siblings. It does not explicitly state when NOT to use it or name alternatives, but the platform list gives sufficient contextual signal for an agent to select this tool for social handle and trademark checks.

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

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

The description discloses output behavior—per-registrar registration/renewal/transfer prices, premium status, and a 2-year cost recommendation—which is valuable because there is no output schema. It also says 'live' and 'across registrars,' indicating external network queries; annotations already cover read-only/idempotent/destructive safety. The 10-minute cache default is only in the `fresh` parameter schema, but this is not a 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?

The description is a single sentence with no wasted words. It front-loads the scope and action, then packs in return contents and the recommendation basis without filler.

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

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

For a two-parameter tool with no output schema, the description covers the required input domain shape, the optional freshness behavior via the schema, and the return content in prose. Nothing required for invoking the tool 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%, with clear descriptions for `domain` and `fresh`. The main description reinforces the 'one exact domain' idea and gives an example, but it adds no new parameter semantics beyond what the schema already 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 action—live availability and price comparison—for a specific resource: one exact domain across registrars. The 'one exact domain' scope clearly separates it from siblings like check_name_across_tlds or compare_tld_prices without needing their 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 clearly scopes use to a single exact domain rather than name exploration or TLD comparison, which is the main decision point among siblings. It doesn't explicitly name alternatives or say when not to use it, so it provides clear context but not full 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds useful behavior beyond that: each call returns availability plus the best 2-year price, and it names the default TLD set. It provides no unnecessary 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?

Three short sentences front-load the core behavior and then give defaults and constraints. It is compact, though the defaults and max-8 detail also appear in 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?

For a simple read-only lookup with two parameters, the description and schema together cover what an agent needs: required name, optional tlds, defaults, and return concept. It could be slightly more explicit about the return shape or about using list_supported_tlds to know valid TLDs.

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 applies; both parameters are documented in the schema, including the tlds default. The description reinforces defaults and the 8-TLD maximum, but does not add 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 names a specific action and object ('Check one name ... across several TLDs at once') and states the result (availability plus best 2-year price). It is clear and self-contained, but it does not explicitly contrast with sibling tools like check_domain or compare_tld_prices.

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

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

The description implies the primary use case—checking a single name over the default TLD set—and gives constraints (max 8 TLDs). It does not state when to prefer an alternative or mention that check_domain/compare_tld_prices exist for single-domain or price-comparison needs.

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 valuable behavioral context: it explains data sources (public registry RDAP), limitations (some TLDs have no RDAP), and that it suggests a free email reminder service. This goes beyond the annotations and helps the agent set expectations.

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

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

The description is compact and front-loaded: it states the core purpose first, then the data sources and limitations, then the extra reminder service. Every sentence earns its place, and the structure is easy to scan.

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

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

For a read-only, single-parameter tool with 100% schema coverage and no output schema, the description is quite complete. It covers what data is returned (registrar, expiry, renewal price, cheapest transfer registrar, two-year saving), the source (RDAP), and a known limitation (.io). The only minor gap is that it doesn't explicitly state what happens for TLDs without RDAP (e.g., does it skip them or return an error?), but this is a small omission.

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 the 'domains' parameter with an example. The description adds context about the max of 20 domains and that they must be owned, but it doesn't add new parameter-level semantics 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 verb ('check') and resource ('renewals for owned domains'), and clearly distinguishes itself from siblings like check_domain and compare_tld_prices by focusing on domains the user already owns, with registrar, expiry, renewal price, and transfer savings. It also names the free reminder service, which adds specificity.

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

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

The description clearly implies when to use this tool: when the user owns domains and wants renewal/transfer information. It does not explicitly name alternatives or exclusions, but the scope ('domains the user already owns') and the mention of RDAP limitations (e.g., .io has no RDAP) provide practical context. It could be improved by explicitly saying 'use check_domain for a single domain's availability/WHOIS' or similar, 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 establish read-only, idempotent, non-destructive behavior. The description adds meaningful context beyond that: ranking basis, free-tier caps, overage pricing, and importantly the provenance of prices ('curated from each provider's pricing page with a date'). This helps set expectations about data freshness and output structure.

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

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

Three sentences, no filler. The key ranking criteria are front-loaded, the data provenance is compactly stated, and the workflow hint about plan_dns_setup is a single useful clause. 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 one optional parameter, no output schema, and read-only annotations, the description conveys what is compared, how it is ranked, relevant pricing constraints, data freshness caveat, and the logical next step. Nothing critical is missing 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?

Schema coverage is 100%, so the single optional parameter emails_per_month is already well documented with range and default. The description's phrase 'at a monthly volume' maps to this parameter but does not add new semantic detail beyond the schema, so the baseline score is appropriate.

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

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

The description clearly identifies the resource ('services an app sends email through') and the specific action (ranked by two-year cost with free-tier caps and overage prices). It is distinct from email hosting generally, but it does not explicitly differentiate itself from the sibling 'compare_email_hosting', leaving that contrast implicit.

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

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

The description implies when to use it by focusing on transactional email like sign-in links and password resets, which gives a clear context. However, it provides no explicit exclusions or direct comparison against sibling tools, and the only alternative guidance is a follow-up recommendation to use plan_dns_setup.

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 readOnly and non-destructive behavior. The description adds valuable context: it includes intro-price traps, per-user vs flat pricing, and price provenance with a date. It does not specify freshness/update policy, but the added context goes 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 dense sentences front-load the core purpose and scope, then add caveats and provenance. No wasted words; examples improve clarity without bloating the text.

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

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

For an informational tool with 2 optional parameters and no required inputs, the description is nearly complete: it states the ranking basis, included pricing nuances, and data provenance. It does not describe the exact output format, but 'ranked by two-year cost' implies the returned structure sufficiently.

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 baseline is 3. The description adds meaning by mapping provider categories to the `need` enum (forward, mailbox, suite, private) and clarifying that cost depends on mailbox count via per-user vs flat pricing.

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 it ranks custom-domain email providers by two-year cost, naming concrete provider categories (free forwarding, cheap mailboxes, office suites, encrypted). This strongly differentiates it from sibling tools like compare_tld_prices, which focus on domain pricing rather than email hosting.

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 scope is clear: use this when comparing email hosting providers for a custom domain. It does not explicitly name alternative tools or conditions for when not to use it, so it stops short of a 5, but the context is unambiguous.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds behavioral context beyond this: prices are refreshed daily, sorted by 2-year cost, and limited to standard (non-premium) prices. This gives agents useful expectations about data freshness and ordering. It doesn't contradict 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 with zero waste. It front-loads the core purpose and immediately provides usage guidance. Every clause contributes to agent understanding, making it exemplary in conciseness.

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 tool with one parameter, the description is complete. It states what the tool returns (prices across registrars, refreshed daily, sorted by 2-year cost) and how to use it. With annotations covering safety and no output schema, no critical information is missing.

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

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

The schema describes the tld parameter with a pattern and example, achieving 100% coverage. The description merely refers to 'one TLD' without adding further syntax or format details beyond what the schema provides. Per the rubric, the baseline of 3 applies when the schema handles the parameter documentation, and the description adds no extra value here.

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 (compare), the resource (TLD prices), and the scope (one TLD across registrars, non-premium). It explicitly differentiates itself from the sibling check_domain by naming it, so an agent can immediately tell which tool to use for general price inquiries versus specific name checks.

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 direction: use for general questions like 'how much is a .io domain' and directs to check_domain for a specific name. This provides both when and when-not to use, along with the alternative tool, leaving 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds some context about the data scope ('daily price tables' and 'registrars TLDMath queries live'), but it does not explain output behavior, ordering, or the meaning of 'supported' beyond that fragment.

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

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

The description is very short, which is appropriate for a zero-parameter tool, but it is grammatically incomplete and awkwardly phrased. It is concise but not well-structured enough to clearly convey the tool's purpose.

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

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

With no output schema, the description should clearly explain what the tool returns, but it only vaguely references TLDs and registrars. It does not explicitly state that the tool returns a list of supported TLDs, nor does it clarify the relationship between TLDs, daily price tables, and registrars.

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 schema description coverage is 100%, so there are no parameter semantics for the description to clarify. The baseline of 4 applies because no parameter documentation burden exists.

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 is a noun phrase fragment ('TLDs with daily price tables, and the registrars TLDMath queries live') rather than a clear statement of what the tool does. It fails to state an action like 'lists' or 'returns', and it does not meaningfully distinguish the tool from siblings such as tld_price_changes or compare_tld_prices.

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

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

There is no guidance about when to use this tool versus alternatives. It does not mention any sibling tools, conditions, or use cases, leaving the agent to infer when list_supported_tlds is appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and non-destructive, so safety is covered; the description adds real value on top with 'from public records only', 'each line shows its evidence', and 'no sign-in'. Coverage is good, though it says nothing about latency, lookup failures, or partial results for unregistered domains.

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?

Front-loaded with the core answer, then the evidence/scope caveat, then usage cases. The long enumerated clause is dense but each item is functional rather than filler; slightly heavy for a one-parameter lookup.

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?

No output schema exists, and the description compensates by itemizing the returned facets and noting that each line carries its evidence. An agent knows both inputs and expected output shape well enough to call it correctly.

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

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

Single parameter with 100% schema description coverage, so the schema already carries the semantics; the description adds no format or edge-case guidance (e.g. subdomains, IDN, bare vs. www) beyond what the schema 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?

States a specific resource ('which companies a domain depends on') and enumerates the exact dimensions resolved: registrar/RDAP, DNS host, website host, MX, SPF/DKIM/bounce, DMARC. That granularity clearly separates it from siblings like check_domain or check_renewals, which cover only one of those facets.

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 concrete triggers: handoffs ('which accounts do I open when it breaks?'), before moving hosts, and setup audits. It does not, however, position itself against the closest siblings (check_domain, compare_email_hosting), so the agent must infer when a narrower tool is preferable.

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 destructiveHint=false, so the safety profile is largely covered; the description reinforces it ('Read-only: it changes nothing') and adds genuinely new behavior: show steps and ask before running any command, and that commands prompt for secret values themselves. Good extra context beyond 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?

Front-loaded with the purpose and the ordered step list, then usage and safety constraints. Dense but every clause carries information; only minor compression is possible.

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

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

With no output schema, the description effectively outlines the returned plan (export, keep data/sign-ins, deploy, env vars, auth redirects, domain, DNS switch, verify, disconnect), plus the DNS re-check flow. 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% (baseline 3), but the description adds real meaning: pass dependency names from package.json, variable NAMES from .env.example, and 'never pass values or secrets'—clarifying the intent and safety boundary of env_names and dependencies beyond the schema text.

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

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

States a specific verb+resource ('ordered, repeat-safe plan for moving an app built in an AI app builder...to the user's own host') and enumerates the concrete steps included. An agent can distinguish it from plan_dns_setup and plan_launch_steps 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 clear invocation context ('Call again after the DNS change to confirm, or use plan_dns_setup') and conditions for passing optional data ('If you can read the project, pass dependency names...'). Names an alternative tool but doesn't state explicit when-not-to-use exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description reinforces 'Read-only: it never changes DNS.' It adds useful behavioral context beyond annotations: live public DNS checking, status categories (in place/missing/needs change), SPF merging, and identifying records to remove. 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?

The description is information-dense and covers all key points in a single structured sentence. The read-only statement is slightly redundant with annotations but harmless. Overall it is appropriately sized and front-loaded with the main purpose.

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

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

With no output schema, the description provides a high-level account of what the tool returns: record statuses, DNS hosting location, and records to remove. It also covers use cases, parameter interplay, and read-only behavior, making it complete enough for correct invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds helpful context about how host, email, and sender parameters relate to DNS record types and SPF merging, but it does not add syntax-level detail beyond what the schema already provides.

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

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

The description uses a specific verb ('Plan') and a clear resource ('DNS setup for a domain'), then enumerates exactly what the tool covers: website hosts, inbox providers, email-sending services, SPF/DKIM/DMARC, live DNS checks, and record statuses. This clearly distinguishes it from sibling domain-search and comparison tools.

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

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

The description explicitly states when to use the tool: 'Use after the user buys a domain, or when their site or email on a custom domain isn't working.' It does not name when-not-to-use or alternative tools, but the context is clear enough for an agent to decide.

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/idempotent/destructive, and the description reinforces this ('Read-only: TLDMath runs nothing') while adding substantial non-annotation context: the specific required env vars (CLOUDFLARE_API_TOKEN, RESEND_API_KEY), that commands are for the user's own tools, and explicit interaction guardrails (ask first, never request keys in chat, no deletes without naming the record). This is well beyond what structured fields convey.

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?

Purpose is front-loaded in the first clause, and every sentence adds operational value (env vars, re-call rule, guardrails). It is dense and slightly run-on with parentheticals, but there is little fat to cut.

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

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

With no output schema, the description must (and does) characterize the return shape ('ordered, repeat-safe steps with commands', a manual list fallback) and references 'the guardrails in the result'. For a multi-provider planning tool this is nearly complete, though it does not explain response structure or how many/which steps are returned.

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 enums are self-documenting, so the schema carries the parameter burden. The description gestures at the categories (website host, inbox, app-email sender) but adds no syntax or format detail 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?

States a concrete verb+resource (produces an ordered, repeat-safe DNS plan with runnable commands) and names the tooling/environment it targets. It is distinguishable from general utilities, but it never names its closest siblings plan_dns_setup or plan_app_move, so the agent must infer which planning tool to pick.

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 one real usage rule — 'call it again after each change' because only not-yet-placed records get commands — which is genuinely useful re-invocation guidance. However, it offers no when-to-use/when-not guidance relative to plan_dns_setup or plan_app_move, leaving the sibling choice implied.

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

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

Annotations already cover the read-only, non-destructive, open-world profile with lower disclosure burden. The description adds real value beyond them: 'Nothing is stored', the exact result cardinality (3-5 TLDs, 10 names), availability screening on the top 3 TLDs, and cheapest standard 2-year cost basis. It does not explain run-to-run variability despite idempotentHint=false, a minor gap.

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

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

Three dense sentences, front-loaded with the core output contract, then optional inputs, then the hand-off to check_domain. Every clause carries information and nothing is repeated from 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?

No output schema exists, yet the description supplies the return shape (3-5 ranked TLDs with reasons, 10 names, screening status, 2-year cost), which is exactly what an agent needs. Combined with the sibling hand-off, nothing essential is missing.

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

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

Schema description coverage is 100% and all six parameters are documented in the schema itself, so baseline is 3. The description only names the optional parameters (style, include_word, position, max length) without adding syntax or constraints beyond what the schema already states.

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

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

States a specific verb (recommend) and resources (TLDs and brandable names) with exact output counts and screening scope. It is clearly distinguishable from siblings like check_domain, which it names for a different task.

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

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

Gives clear context ('Given a short project description') and routes the agent to check_domain for live per-registrar prices, implicitly framing this as the screening/ideation step. It lacks an explicit when-not condition, but the alternative routing is well specified.

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 read-only/idempotent safety; the description adds value by disclosing that the drop window is an estimate, that marketplace parking means 'possibly for sale', and that it points to external alert URLs. This makes the tool's uncertainty and non-authoritative nature transparent 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?

The description is a compact, front-loaded list with no filler; the opening condition identifies the audience and the colon organizes the data points. The second sentence on alerts is the only add-on, and it earns its place as a distinct feature.

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

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

With no output schema, the description nonetheless enumerates the main return categories and the external alert destination, which is sufficient for an agent to decide whether results meet the user's goal. It also states the precondition (taken domain) and avoids promising availability checking.

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 'domain' parameter is fully documented in the schema with an example and length constraints, so the description carries little parameter burden. It adds the contextual meaning that the domain is someone else's, but no additional syntax or formatting details.

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 function: produce options for a domain owned by someone else, and enumerates the returned data (registrar, expiry, lifecycle stage, drop window, marketplaces, backorder links). It clearly distinguishes from availability-checking siblings by framing the domain as taken, so an agent can route 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?

The opening phrase 'For a domain someone else owns' gives a clear condition for use: only when the domain is not available. It makes the tool's context obvious, though it does not explicitly name an alternative or state when not to use it.

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

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

Annotations already mark the tool read-only, idempotent, and non-destructive. The description adds useful behavioral context beyond those hints: it specifies the time window (upcoming and past year), the data source (TLDMath daily checks), and the distinction between registry wholesale and registrar standard prices. This gives an agent a reliable sense of what information the tool covers.

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, immediately states what the tool reports, provides memorable usage examples, and ends with the optional filter. Every part earns its place and no filler is present.

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

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

For a read-only lookup with two optional, well-documented parameters, the description is largely complete: it defines data scope, source, relevance, and an optional filter. It does not describe the return shape, but given no output schema and the simple nature of the tool, that is a minor gap rather than a blocking omission.

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

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

The input schema has 100% description coverage, with both tld and days clearly documented, so the baseline is 3. The description adds a small reminder that TLD filtering is optional, but it does not need to explain parameters further because the schema already carries that burden effectively.

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

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

The description clearly identifies a specific resource—domain price changes—and distinguishes the content: announced registry wholesale increases, upcoming and past-year changes, plus registrar standard price changes observed by TLDMath. This differentiates it from siblings like compare_tld_prices, which logically focuses on current price comparison rather than changes over time.

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 concrete use cases ('is .com going up?' or 'should I renew early?') and notes optional TLD filtering, giving an agent clear context for when to call this tool. It does not explicitly name alternative tools or state when not to use it, so it falls just 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.