nslookup

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

Without annotations, the description conveys that this is a read-only check, specifically noting it skips VMC validation and returns specific fields (record, logo URL, authority URL). While it doesn't explicitly state side effects or permissions, the nature of the tool and detailed return info provide adequate behavioral context.

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

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

The description is two sentences, front-loaded with the core purpose, and every clause adds value. It efficiently explains the tool's scope, speed advantage, and return data without fluff.

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

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

Given the simple tool (1 parameter, no output schema), the description is complete: it explains what the tool does, how it differs from bimi_vmc, and what it returns. The agent has enough to decide when to invoke it and what to expect.

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 no additional parameter semantics beyond what the schema already provides; it only reiterates that the domain is checked and gives an example in the schema.

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

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

The description explicitly states the verb 'Check' and the resource 'BIMI DNS record for a domain', clearly distinguishing it from bimi_vmc by noting it skips VMC validation. It also lists the exact return values, leaving no ambiguity about the tool's function.

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 names the alternative tool (bimi_vmc) and explains the trade-off: bimi_check is faster because it skips VMC certificate download and validation. This gives clear guidance on when to use this tool versus the sibling.

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

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

No annotations are provided, so the description carries the burden. 'Check' implies a read-only operation, and the description discloses what is returned, but it does not mention potential limitations, error scenarios, or any permissions/rate limits. This is adequate but not rich.

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

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

The description is a single sentence, front-loaded with the action, and lists return values efficiently. 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 single-parameter tool with no output schema, the description is fairly complete. It names the specific return items (DNS status, VMC details, logo URL, trademark info, expiry) and the input domain. Minor gaps like error handling or prerequisites are not critical here.

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 a descriptive 'domain' parameter. The description repeats 'domain' but adds no extra parameter semantics beyond what the schema already provides. 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 clearly states the tool 'Check BIMI and VMC for a domain' with specific verb and resource, and lists return values. However, it does not explicitly distinguish itself from sibling tool 'bimi_check' or other DNS/SSL tools, so it lacks sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'bimi_check' or 'ssl_certificate'. The description only states what it does, not context or exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: statelessness, comparison of current vs. proposed state, deterministic rule-based findings, and the risk score. It does not explicitly say it never applies changes, but 'Review ... BEFORE applying' and 'Stateless' strongly imply a read-only, non-mutating operation.

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

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

The description is two sentences, front-loaded with the core purpose, and then efficiently lists outputs and the key statelessness trait. Every sentence adds value with no redundancy or fluff.

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

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

Given the moderate complexity and the lack of an output schema, the description adequately covers what the tool returns (diff, findings, fixes, risk score) and its non-persistent behavior. The schema covers parameters thoroughly. It could mention pagination or formatting of the diff, but that is not essential for correct invocation.

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

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

The input schema already provides 100% coverage with detailed descriptions for all three parameters, including the critical nuance that 'records' is the complete desired state and omissions are deletions. The tool description adds no parameter-specific meaning beyond what the schema already offers, 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 verb ('Review') and a specific resource ('proposed DNS changes'), and clearly distinguishes itself from siblings like dns_lookup or dns_health by focusing on pre-application review with diff, findings, and risk score. This is a unique, well-scoped purpose.

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

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

The phrase 'BEFORE applying them' gives clear timing context for when to use the tool, and the description implies the review workflow. It does not explicitly name alternatives or state when not to use it, but the context is clear enough to guide selection among DNS-related siblings.

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

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

No annotations are provided, so the description carries the full burden. It explains that the tool performs an audit and returns scores, but it doesn't explicitly state that it makes no changes or mention any potential latency or rate limits. The audit nature implies read-only, but the disclosure is not explicit.

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, information-dense sentence that front-loads the purpose and then lists all key categories and the output format. There is no redundant or filler content, making it highly efficient.

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

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

With one parameter and no output schema, the description provides all necessary context: what it does, the scope of checks, and the output (overall score plus per-category). It is complete for an audit tool of this complexity.

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

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

The schema already provides 100% coverage for the domain parameter with a clear example. The description adds no additional parameter-specific meaning beyond using the word 'domain' in the first sentence, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Run') and resource ('DNS health audit') and details 39 checks across 7 categories, clearly distinguishing it from sibling tools like dns_lookup or dns_record. It also specifies the output (severity-weighted score) which further clarifies its purpose.

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

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

The description clearly establishes that this is a comprehensive audit tool, appropriate for a full DNS health assessment rather than a simple lookup. However, it doesn't explicitly name alternatives or state when not to use it, so it earns a 4 rather than a 5.

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

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

With no annotations, the description carries the full burden. It clearly indicates a read-only lookup operation and mentions the DNS server context, but it does not disclose potential errors, timeouts, or the response format. The behavior is straightforward, yet lacks depth for a fully transparent picture.

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, front-loads the purpose, and lists the record types efficiently. Every word earns its place with no redundancy or fluff.

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

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

Without an output schema, the description should explain the structure of returned results, but it only says 'returns results' without specifying format or shape. The tool has only two parameters and no side effects, yet the missing return details leave a notable gap for the 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?

The input schema provides 100% coverage with descriptions for both 'domain' and 'server', including an enum and a default value. The tool description adds minimal semantic value beyond what the schema already states, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('look up') and a resource ('all common DNS records') with a clear list of record types, which distinguishes it from sibling tools like dns_health or dns_propagation. It also specifies that results come from a designated DNS server, fully clarifying the tool's scope.

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 general usability for comprehensive DNS lookups but does not explicitly state when to use this tool versus alternatives like dns_record or dns_propagation. No exclusions or conditional guidance are provided, leaving the agent to infer the tool's place among siblings.

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

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

With no annotations, the description carries the full burden. It reveals the tool's scope (18+ servers) and outcome (shows propagation worldwide), but does not disclose behavior such as whether it is read-only, rate limits, or error handling. The read-only nature is implied but not explicit.

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 main verb and purpose, with no unnecessary words. It is concise and well structured.

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 2-parameter tool with no output schema, the description is fairly complete: it explains what it checks, the scope, and the expected insight. It could mention how results are presented, but is adequate for a basic query tool.

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

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

Schema description coverage is 100%, so the schema already explains both parameters well. The description adds context about the global server coverage but does not introduce new semantic details 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 states a specific verb ('check') and resource ('DNS propagation for a domain'), with clear scope ('across 18+ global DNS servers'). It also differentiates from sibling tools by emphasizing worldwide propagation status rather than a simple lookup or health check.

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

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

The description implies its use case: verifying if DNS changes have propagated globally. It provides context but does not explicitly mention when to prefer it over alternatives like dns_lookup or dns_health, nor any exclusions.

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

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

No annotations are provided, so the description carries the full burden. It only states that the tool 'looks up' records and supports many types, but does not disclose network behavior, read-only nature, rate limits, or any side effects. This leaves the agent without important behavioral context.

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

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

The description is a single sentence with a clear purpose and a list of supported types. It is concise and front-loaded, with no redundant words or filler.

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

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

The tool is relatively simple, and the schema covers all parameters. However, there is no output schema and no description of the return format, error behavior, or how to interpret results. An agent would benefit from knowing what the response contains.

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 no extra parameter semantics beyond the schema; it merely repeats record types already in the enum. The server parameter is not mentioned in the description at all.

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: 'Look up a specific DNS record type for a domain.' It specifies the verb (look up), resource (DNS record type), and scope (for a domain). It also lists many supported record types, distinguishing it from broader DNS tools like dns_lookup.

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 usage is implied: use this tool when you need a specific DNS record type. However, there is no explicit guidance on when to use this instead of sibling tools like dns_lookup or dns_health, and no exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns per-indicator scores and detected issues, but it does not explicitly state whether the operation is read-only, requires authentication, or has any side effects. For a scanner, read-only is implied but not stated, leaving some ambiguity.

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

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

The description is a single, focused sentence that front-loads the purpose and provides the key output details. Every word contributes value, with no redundancy or unnecessary 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?

Given the tool's simplicity (one parameter, no output schema), the description covers the essential aspects: what is scanned, which indicators are evaluated, and what is returned (scores and issues). It does not explain the scoring scale or issue types, but it is sufficiently complete for a straightforward scanner tool.

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

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

The input schema has 100% coverage with a clear description for the only parameter 'domain'. The tool description adds no additional meaning beyond the schema, such as format examples or constraints, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb 'Scan' and clearly defines the resource as 'a domain's email security posture' with the exact protocols (SPF, DKIM, DMARC, BIMI). This distinguishes the tool from broader siblings like security_scan or dns_lookup, which focus on general security or DNS.

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

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

The description clearly implies the appropriate use case: assessing a domain's email security against spoofing and phishing. However, it does not explicitly mention when not to use it or contrast it with sibling alternatives such as bimi_check or security_scan, though the email-specific focus provides adequate contextual guidance.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It discloses return values (three scores, AI crawler access, structured data analysis, recommendations) and implies a read-only check. It does not mention potential prerequisites or side effects, but for a checker tool this is reasonably transparent.

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

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

The description is a single, well-structured sentence that front-loads the purpose and then enumerates the key outputs. Every clause adds value with no fluff.

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

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

The tool has one input parameter and no output schema, but the description lists the expected return content, which is adequate for a read-only checker with low complexity. It does not explain the scoring methodology, but that is not necessary for basic usage.

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

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

Schema description coverage is 100% for the single 'domain' parameter, so the schema already documents the parameter. The description adds no additional parameter-specific details, but no compensation is needed given full 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 tool checks a domain's GEO score and explains what GEO means, listing specific outputs. This is a specific verb+resource pairing and is distinct from sibling tools covering DNS, SSL, and uptime.

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 conveys when to use the tool: to check AI search engine optimization. It does not explicitly mention when not to use it or provide alternatives, but the purpose is sufficiently distinct from siblings to imply appropriate usage.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It lists the output categories in detail, which is good, but it does not mention error handling, behavior for invalid domains, or limitations (e.g., hidden server locations behind CDNs). The tone is purely declarative about results, missing some situational 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?

The description is a single, information-dense sentence that front-loads the core purpose and then enumerates all report components. It is concise and each clause adds value, though the enumeration is slightly long. Overall it is well-structured for quick parsing.

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 lack of an output schema, the description compensates by explicitly listing all result categories (IP/ASN, CDN, SSL, mail, etc.). This gives the agent a solid understanding of the return content. It does not explain data freshness or sources, but for a lookup report it is reasonably complete.

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

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

Schema description coverage is 100%: the single 'domain' parameter already explains its meaning and normalization behavior. The description adds no additional parameter semantics beyond that, so the baseline of 3 is appropriate.

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

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

The description opens with a specific verb+resource ('Find out who hosts a website') and enumerates the full scope of the combined report (hosting provider, IP/ASN, server location, DNS/nameserver, CDN, SSL issuer, mail). It clearly differentiates from sibling tools like dns_lookup or ssl_certificate by emphasizing the combined, single-report nature.

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 when a comprehensive hosting-related summary is needed, explicitly stating it returns 'one combined report.' It does not enumerate exclusions or name alternative tools, but the combined-report framing gives clear context for when to choose it over individual lookup tools.

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

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

With no annotations, the description carries the full behavioral burden. It explicitly discloses the output contents, the ordering, the 30-day highlight, and the sign-in requirement, making the tool's behavior transparent for a read-only overview. It does not cover edge cases like empty results or error handling, but that's acceptable for a zero-param read tool.

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

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

The description is exactly two sentences: the first lists the output features, the second states the auth requirement. No fluff, and the main action is front-loaded.

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

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

Given the tool's simplicity (zero parameters, no output schema, no annotations), the description provides a comprehensive overview: purpose, output specifics, and prerequisites. It could be slightly more detailed about the exact return structure, but it's sufficient for an agent to correctly invoke the tool.

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

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

There are zero parameters, so the schema is empty and the baseline is 4. The description adds no parameter semantics but correctly notes the sign-in requirement as the only prerequisite, which is not a parameter.

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

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

The description clearly states it retrieves an SSL certificate expiry overview for monitored domains, with specific output details (per-alert-level counts, sorted certs, 30-day highlight). This distinguishes it from sibling tools like ssl_certificate or my_overview by focusing on certificate expiry across the user's monitored set.

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 for reviewing certificate statuses across monitored domains, and notes the sign-in prerequisite, but it does not explicitly state when to prefer this over ssl_certificate or other alternatives. No exclusions or when-not-to-use guidance is provided, so it only reaches the 'implied usage' level.

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

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

No annotations are provided, so the description carries the burden. It discloses authentication requirements (sign-in or API token) and details the output structure (0-100 risk score, severity counts, added/removed/modified counts, latest risk per monitor). This goes beyond simple 'list' to explain what the agent can expect, though it omits pagination or 'how recent' details.

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

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

The description is two sentences with no fluff. The first sentence front-loads the primary purpose and output contents, while the second covers authentication. Every phrase adds value and is appropriately sized.

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 adequately explains the return values (risk score, counts, per-monitor risk) and the auth requirement. It is complete for a simple list tool with one optional parameter, though it could mention the default limit or scope of 'recent' changes.

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 fully describes the single 'limit' parameter with its default, min, and max. The description adds no extra parameter-specific meaning beyond the schema, so the baseline 3 for 100% schema coverage is appropriate.

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

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

The description clearly states the tool lists recent DNS changes on monitored domains with risk assessment details. It uses a specific verb ('List') and resource ('DNS changes'), and the mention of 'DNS Change Review' implies a connection to the sibling tool, but it does not explicitly distinguish itself from dns_change_review.

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

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

The description implies the tool is for viewing recent DNS changes with risk assessments, which is clear context. However, it does not explicitly state when to use this tool instead of alternatives like dns_change_review, nor does it provide exclusions or prerequisite steps beyond requiring sign-in.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the authentication requirement (sign-in or API token), indicates the default behavior (open incidents) and the option for full history, and reveals the summary output. While it does not explicitly say the operation is read-only, the verb 'List' implies non-destructive behavior. This is substantial disclosure beyond the schema.

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

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

The description is two concise sentences, front-loaded with the primary action and resource. The first sentence lists incident types and behavior, the second covers authentication. Every clause adds value with no redundancy or filler. This is an exemplar of concise, informative tool documentation.

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

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

For a simple list tool with two optional parameters and no output schema, the description covers all essential aspects: resource (incidents), scope (monitoring), types of incidents, default vs. full history, summary feature, and authentication. No critical operational details are missing, making it complete in 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?

The input schema already provides 100% coverage for both parameters (limit and status) with descriptions. The description reinforces the status semantics ('open ones by default, or the full recent history') but does not add new information beyond what the schema offers. Therefore, the description adds minimal value on top of low parameter complexity, keeping it at the baseline 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 clearly states the tool lists incidents from NsLookup.io monitoring, enumerating incident types (downtime, SSL expiry, DNS changes, propagation issues, VMC problems) and mentions an additional summary feature. It uses a specific verb ('List') and resource ('incidents'), distinguishing it from sibling tools like my_monitors or my_certificates.

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

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

The description provides clear context for when to use the tool—listing monitoring incidents—and notes the default vs. full-history behavior. It does not explicitly name alternatives or state when not to use it, but the context is specific enough that an agent can infer its appropriate use. A minor deduction for lacking explicit exclusions.

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

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

With no annotations, the description carries the burden. It discloses the auth requirement (sign-in or API token) and that it returns configuration and latest state. However, it does not explicitly confirm read-only behavior or describe response format/pagination, leaving some transparency gaps.

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

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

Two tight sentences: the first clearly conveys the action and scope, the second the auth requirement. No filler or repetition; information is front-loaded and easy to parse.

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

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

For a parameterless listing tool with several sibling types, the description covers the essential aspects: what it lists, the types included, the auth requirement, and a hint at the output (configuration and state). It could add more detail about return structure, but the simplicity of the tool makes this sufficient.

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

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

The tool has zero parameters, so the schema fully covers them. Per the rubric, a baseline of 4 is given for 0 params. The description adds no parameter-specific detail but correctly notes the auth requirement, which is a non-parameter prerequisite.

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 lists all monitors across the NsLookup.io account, enumerating specific types (uptime, API, DNS, WHOIS, etc.). This distinguishes it from sibling tools that focus on individual monitor types or specific actions.

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

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

The description implies this is the broad 'list everything' tool by saying 'across every type', but it does not explicitly state when to choose this over sibling tools like my_certificates or my_dns_changes. No exclusions or alternative guidance is provided.

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

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

With no annotations, the description carries the burden of explaining relevant behavior. It discloses the authentication requirement and what the output contains (health score, subsystem breakdown, quota). It does not mention whether the operation is read-only or any error behaviors, but the word 'snapshot' and 'Get' reasonably imply a non-mutating read.

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, front-loaded with the primary purpose, and every phrase adds useful detail (aggregated score, breakdown categories, quota, authentication requirement). There is no redundancy or 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 simplicity (no params, no output schema, no nested objects), the description adequately covers what the tool does and what it returns. It explains the output structure well enough for an agent to understand the value and prerequisites without additional 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?

The tool has zero parameters, so the schema provides no semantic information to add. Per the rubric, the baseline for 0 parameters is 4, and the description does not need to explain anything beyond what it already does.

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

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

The description clearly identifies the tool as an account health snapshot with a specific verb ('Get') and resource ('account health snapshot for NsLookup.io monitoring'). It distinguishes itself from sibling tools by explicitly listing the aggregated 0-100 score and per-subsystem breakdown, making its unique role clear.

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 its use case: getting a high-level overview of account health and limits, as opposed to individual checks like uptime_check or ssl_certificate. It clearly states the prerequisite of signing in, but does not explicitly mention when not to use it or name alternatives, so it gets a 4 rather than a 5.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly mentions the authentication requirement (sign-in or API token), which is critical. It also describes the return data (availability stats and hourly buckets), providing transparency about the response. Minor gaps like lack of pagination or rate limit details are acceptable for this simple read operation.

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

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

The description is two sentences, front-loaded with the core purpose, then details on identification and auth. Every sentence earns its place with no repetition or fluff. Excellent structure for quick parsing.

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 no output schema or annotations, the description covers the essential aspects: purpose, input selection, authentication, and response content. It lacks a precise breakdown of the return format, but for a history tool, 'availability stats plus hourly buckets' is sufficient for an agent to infer the response shape. Slightly more detail on the stats (e.g., uptime percentage) would make it complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining that monitorId and url are alternative ways to identify the monitor, which is not apparent from the schema alone. This clarifies the relationship between parameters and helps the agent choose the right one. No other additions 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 gets 'uptime and response-time history' for a specific monitor, specifying the resource type (NsLookup.io uptime monitors) and the data returned (availability stats plus hourly buckets). It distinguishes itself from siblings like uptime_check (single check) and my_monitors (list) by focusing on historical data.

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

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

The description gives clear context: it is for historical uptime/response data, and identifies the monitor by id or URL. It doesn't explicitly name alternative tools for current status or monitor listing, but the 'history' framing implies when to use it. Excluding explicit 'when not to use' guidance keeps it one point below 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?

With no annotations provided, the description carries full behavioral disclosure. It does reveal return contents (specific fields, raw JSON) and auto-detection behavior. However, it omits potential errors, rate limits, or external lookup implications, leaving some gaps in transparency.

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

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

Two well-structured sentences: the first identifies the action and inputs, the second enumerates outputs. Every word adds value, with no repetition or 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 complexity (multi-type queries, no output schema), the description lists a comprehensive set of return fields and input types. It lacks explicit error/edge-case handling, but for a standard lookup tool, the provided context is largely sufficient.

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

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

The input schema already provides 100% description coverage with examples. The description adds beyond-schema meaning by explaining that query type is auto-detected, reducing ambiguity about how to format the 'query' parameter for IPs, ASNs, or domains.

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 ('look up') and resource ('registration data via RDAP'), and clearly enumerates accepted input types (IP, ASN, domain). This distinguishes it from sibling DNS/SSL/uptime tools, which focus on different concerns.

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 lists valid query types and notes automatic detection, making it clear when this tool is appropriate. It does not explicitly name alternative tools or exclusion cases, but the scope is well-defined enough for an agent to select it for registration/ownership lookups.

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

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

With no annotations, the description carries full burden. It discloses the outputs (findings with severity levels) and the scan scope, which is informative. It doesn't mention potential side effects or authentication needs, but for a scan tool this is less critical.

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 action, no fluff. It earns its place and is easy to parse.

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 tool with no output schema, the description covers purpose, scope, and return format. It lacks details on any prerequisites or limitations, but these are minimal for this kind of tool.

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

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

The schema fully documents the single domain parameter, so baseline is 3. The description confirms the domain input but doesn't add syntax or additional constraints 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 states the tool runs a security scan on a domain and lists specific checks (DNS misconfigurations, SPF/DKIM/DMARC, cookie security, web vulnerabilities). This distinguishes it from siblings like dns_health or ssl_certificate by covering a broader security posture.

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 (when you need a security scan for a domain) but doesn't explicitly compare with sibling tools or specify when not to use. It provides clear context but no exclusions.

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

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

With no annotations, the description carries the full burden. It lists output fields, which reveals the tool's read-type behavior, but it does not explicitly state that it is non-destructive, makes network requests, or any other side effects. There is no contradiction with annotations, but the description omits safety assurances.

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 leads with the action and then lists key return fields. It is concise and information-dense with no wasted words.

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

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

The tool is simple with one parameter and no output schema; the description compensates by enumerating the returned data (issuer, expiry, chain validity, etc.). This provides useful context, though it omits potential error scenarios or network behavior.

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

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

The input schema already fully documents the single 'domain' parameter with an example. The description adds little beyond the schema, listing return values but not giving extra detail about the parameter itself, 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 clearly states the tool's function as checking SSL/TLS certificates for a domain and enumerates the specific data returned, distinguishing it from broader tools like security_scan, but it does not explicitly reference sibling tools. This gives clear purpose but lacks explicit differentiation.

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

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

No guidance is provided about when to use this tool versus alternatives such as my_certificates or security_scan. The description simply states what it does without any contextual or exclusionary instructions.

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

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

With no annotations provided, the description carries the full burden. It explicitly states this is a read operation and enumerates the returned data (page name, overall status, per-component status/uptime, active incidents/maintenance). It also discloses the one-of constraint. It does not mention error handling or non-mutating guarantees explicitly, but 'Read' implies safety.

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 fluff. It front-loads the purpose, then returns, then lookup mode and constraint. Every sentence contributes essential 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?

No output schema exists, so the description adequately compensates by listing return values. It covers input modes and the one-of rule. The only gap is not specifying behavior when both slug and domain are provided, but for a read-only lookup tool this is a minor 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 coverage is 100%, so the baseline is 3. The description adds value beyond the schema by introducing mutual exclusivity ('Provide exactly one of slug or domain') and by illustrating how each parameter is used via hosted.nslookup.io/slug and custom domain examples, which the schema descriptions do not fully convey.

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

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

The description uses the specific verb 'Read' and clearly identifies the resource as a 'public status page hosted on nslookup.io status pages.' This distinguishes it from sibling tools like uptime_check or my_incidents, which target different resources or user-specific data.

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

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

The description provides clear lookup context: by slug or custom domain, with the explicit instruction to provide exactly one of them. However, it does not name alternative tools or state when not to use this tool, so it stops short of explicit exclusions.

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

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

With no annotations, the description carries the full burden. It discloses the one-time execution, single-location scope, and the exact return values (up/down status, HTTP status code, response time in ms). While it does not discuss redirects or failure modes, for a simple read-only check this is solid coverage.

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: first states the core function and outputs, second names the alternative. Every sentence earns its place with no redundancy or 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 simple single-URL uptime check with no output schema, the description covers the purpose, the specific output fields, and the only relevant alternative. It is complete within its low complexity context.

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

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

Schema description coverage is 100%, so the URL and timeout parameters are already fully documented. The description adds no additional parameter-specific meaning beyond what the schema provides, but it does not need to; the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Perform a one-time HTTP uptime check') and clearly identifies the resource (a URL) and scope (from a single location). It also distinguishes itself from the sibling tool uptime_check_multi by explicitly noting the multi-location 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?

It clearly states when to use this tool versus the alternative: 'For multi-location checks, use uptime_check_multi instead.' It also notes the 'one-time' nature, implying it is not for continuous monitoring, which provides clear context against siblings like my_monitors or my_uptime_history.

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

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

With no annotations, the description carries the full transparency burden. It discloses the action and return values (status, response time, HTTP code) for each location, which is helpful. However, it does not mention behavioral traits such as how 'up' is determined, the fact that 7 concurrent requests are sent to the target, or error handling, leaving some gaps.

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

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

The description is two sentences, front-loaded with the core purpose, and efficiently lists the locations and return values. Every sentence contributes valuable information without redundancy.

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

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

The description covers the primary function and return values, which is sufficient since there is no output schema. It lacks minor details like edge cases or the exact meaning of 'status', but overall it provides a complete understanding for a tool of this simplicity.

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

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

The input schema fully describes both parameters (url and timeout) with explanations and a default value, so schema coverage is 100%. The tool description adds no extra parameter-specific meaning, which is acceptable given the 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 ('Check if a website is up or down') and the specific resource ('from 7 global locations simultaneously'), listing the exact locations. It distinguishes itself from sibling tools like uptime_check by emphasizing the multi-location aspect, making its unique purpose explicit.

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

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

The description implies usage for geographically distributed uptime monitoring by mentioning '7 global locations simultaneously', but it does not explicitly state when to prefer this over alternatives like uptime_check or provide exclusions. The context is clear, but direct guidance is missing.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It accurately describes the primary behavior (A/AAAA lookup and domain representations) but omits potential edge cases like DNS errors, timeouts, or validation of invalid 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?

The description is two concise sentences with no fluff. The primary function is front-loaded, and the additional detail about punycode/unicode representations is placed second.

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 nature of the tool and the schema fully documenting the parameter, the description covers the core functionality well. It could mention potential limitations (e.g., live vs cached data) but is reasonably complete for a DNS lookup tool.

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

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

The input schema provides 100% coverage for the single 'domain' parameter, including an example. The description adds no additional semantic information beyond what is already in the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool retrieves IPv4 and IPv6 addresses via A and AAAA records for a given domain, and also returns punycode/unicode representations. This specific verb+resource combination distinguishes it from broader sibling tools like dns_lookup.

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 when IP addresses are needed, but does not explicitly mention when to prefer this over DNS-related sibling tools like dns_lookup or dns_record. No alternatives or exclusions are provided.

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