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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the description's burden is lowered. It adds context about what BIMI is but does not disclose behavioral specifics such as what constitutes 'valid', which DNS record type is queried, or edge-case behavior (e.g., nonexistent domain). No contradiction with annotations.

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

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

The description consists of just two sentences: the first states the primary action and the second provides brief background on BIMI. It is front-loaded, concise, and every sentence contributes useful context without excess.

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 does not specify the return value or error behavior, which remains an ambiguity for the agent. However, given the tool's simplicity (one parameter, strong annotations) and the self-explanatory nature of a 'check', the description is minimally adequate for invocation, though not fully complete.

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

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

Schema coverage is 100% for the single required parameter, with domain_name already including an example ('e.g. example.com') and format description. The description repeats the concept of 'domain' without adding any additional semantic detail beyond the schema, 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 'Check' and a specific resource 'valid BIMI DNS record', clearly distinguishing it from sibling tools like dkim_check, spf_check, and dns_lookup. It also expands the BIMI acronym to provide helpful context.

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 states the tool's use case: checking if a domain has a valid BIMI record. However, it does not explicitly mention when to use this tool over alternatives or provide exclusions, though the niche nature of BIMI makes the intended use fairly obvious.

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

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

Annotations cover key traits (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), so the bar is lower. The description adds minimal context by implying a hosting/serving action, but does not detail behavioral aspects like rate limits, authentication needs, or what 'host and serve' entails operationally. No contradiction with annotations exists.

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

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

The description is a single, efficient sentence that front-loads the core action ('Host and serve') without unnecessary details. Every word contributes to understanding the tool's purpose, making it appropriately sized 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?

Given the tool's moderate complexity (2 parameters, no output schema), annotations provide safety and idempotency info, but the description lacks completeness. It does not explain what happens after hosting (e.g., how the file is served, any URLs or confirmation returned), leaving gaps for the agent to infer outcomes.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters (domain_name and bimi_file). The description does not add meaning beyond the schema, such as explaining the purpose of these inputs in the hosting process, so it meets the baseline of 3 without compensating for any gaps.

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 ('Host and serve') and resource ('BIMI SVG file for email authentication'), distinguishing it from sibling tools like bimi_check (which likely verifies rather than hosts) and other DNS/email authentication tools. It specifies the exact purpose without being vague or tautological.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a domain and BIMI file ready), exclusions, or comparisons to siblings like bimi_check or dmarc_generate, leaving the agent to infer usage context.

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

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

The description states the core behavior (checking blacklists) and adds context about email deliverability impact. With strong annotations (readOnlyHint=true, idempotentHint=true), the description doesn't need to repeat safety traits. It adds no additional behavioral details like rate limits or response format, so it meets the baseline but doesn't exceed it.

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

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

The description is two sentences, front-loaded with the action, and every word contributes. The second sentence provides useful rationale without being verbose.

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, the description adequately explains the purpose and context. However, since there is no output schema, the description could have mentioned what the tool returns (e.g., a list of blacklists or a boolean), which would make it more complete. This is a minor gap.

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

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

Schema coverage is 100% since the only parameter has a description. The description does not add any new information about the parameter beyond what the schema already provides. It follows the baseline for high schema coverage.

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

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

The description uses a specific verb 'Check' and identifies the resource 'domain or IP address' and the context 'listed in popular email blacklists (DNSBLs)'. This clearly distinguishes it from sibling tools like dns_lookup or spf_check, which have different purposes.

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

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

The description provides clear context by mentioning 'being blacklisted can severely impact email deliverability', implying it should be used when troubleshooting email deliverability. However, it does not explicitly name alternatives or state when not to use this tool compared to other DNS-related 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that it shows aliasing behavior, but does not disclose additional traits such as return format, potential errors, or rate limits. With annotations, the description is adequate but not enriching.

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 action ('Look up CNAME records') and a brief explanation of the output semantics. Every word earns its place; 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?

For a simple read-only DNS lookup with one well-documented parameter and no output schema, the description is sufficient to convey purpose and reasonable expectations. It could be more complete by describing the output structure, but overall it provides adequate context for an agent to invoke the tool correctly.

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

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

The schema has 100% coverage with a clear description of the 'domain_name' parameter including an example. The tool description adds a tiny bit of context ('Shows where a hostname aliases to') but does not significantly enhance the parameter understanding beyond what the schema already provides. 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 specific verb and resource: 'Look up CNAME (Canonical Name) records for a domain.' This directly distinguishes it from sibling tools like MX, TXT, or PTR lookups by naming the exact record type, fulfilling the requirement for a specific and distinguishing 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 provides clear context that this tool is for CNAME record lookups and explains what it does ('Shows where a hostname aliases to'). However, it does not explicitly mention alternatives or exclusions, such as 'for general DNS records, use dns_lookup.' This gives a clear scope without explicit when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the DKIM background and the selector requirement but does not detail result format or rate limits. This is acceptable given annotation coverage, but the added behavioral context is limited.

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

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

Two sentences with front-loaded function: the first sentence states the purpose, the second provides useful background. 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 a simple DNS check with annotations covering safety and full schema for parameters. The main gap is that the description doesn't specify the output format or what 'valid' means in the response, but for a check tool this is somewhat implied. Overall, it is largely complete for its 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?

Schema coverage is 100%, with both parameters (domain_name and dkim_selector) fully described. The description does not add meaning beyond 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 checks for a valid DKIM DNS record for a given selector, with a specific verb ('Check') and resource (domain + DKIM selector). It distinguishes itself from sibling tools like dmarc_check and spf_check by focusing specifically on DKIM.

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—when you need to verify DKIM DNS records—but does not explicitly mention alternatives or when not to use it. Sibling tools exist for other DNS email checks, but the description provides no exclusions or alternative tool names.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a semantic context (DMARC's effect on email handling) but does not disclose behavioral specifics like checking the _dmarc subdomain or what 'valid' entails. It does not 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?

Two sentences: the first states the tool's purpose, the second gives background context. No redundancy, filler, or inaccessible information. It is concise and front-loaded.

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

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

For a simple read-only DNS lookup tool with a single parameter and no output schema, the description is fairly complete. It explains what the tool does and why DMARC matters. A perfect score would require explicit mention of validation criteria or the _dmarc prefix, but these are not essential 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% — the single parameter domain_name is clearly documented with an example. The tool description adds no additional parameter-specific meaning beyond that, so a baseline score of 3 is appropriate.

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

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

The description states a specific action and resource: 'Check if a domain has a valid DMARC ... DNS record.' This clearly distinguishes it from sibling tools like dkim_check, spf_check, or dns_lookup. It also adds helpful domain context about what DMARC does.

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

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

The description provides implicit usage context by explaining DMARC's role in email authentication, but it does not explicitly state when to use this tool versus alternatives (e.g., when to use dmarc_generate or spf_check). No exclusions or alternatives 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?

The description adds value beyond annotations by disclosing that the tool 'Returns the record name, value, and type ready to be added to DNS', clarifying that it only generates the record and does not apply it. This complements the idempotentHint and the non-destructive nature, enhancing transparency.

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

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

The description is a single, concise sentence that front-loads the primary action and then specifies the return value. No wasted words; every element serves a purpose.

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

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

For a straightforward generator with full schema and annotations, the description provides enough context: what it does and what it returns. It omits details like the exact DNS record format, but the schema and the simplicity of the tool make it sufficiently 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% with each parameter well-explained (domain, email, policy). The tool description does not add further parameter details, but the schema already handles the heavy lifting, so the baseline 3 applies.

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

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

The description clearly states 'Generate a DMARC DNS record for a domain' with a specific verb and resource. It is easily distinguished from sibling tools like dmarc_check (which checks existing records) and spf_generate (which generates SPF records).

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

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

Usage is implied by the tool's name and description: use when you need to create a DMARC record. However, there is no explicit guidance on when to use this instead of alternatives like dmarc_check, or any exclusions or prerequisites.

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

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

With annotations already indicating readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior, the description adds context by specifying the exact record types returned and the 'one query' behavior. This provides useful behavioral details beyond the annotations, such as the comprehensive response scope.

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, each earn its place: the first defines the action and scope, the second lists outcomes. No redundant wording, and key information is front-loaded.

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

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

No output schema exists, so the description appropriately explains return values by listing record types. It gives the essential context for a simple read-only tool, though it could specify the response format (e.g., JSON) or edge cases, but that is beyond minimal expectations. The sibling context and annotations further round out completeness.

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

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

The schema description for domain_name already covers its purpose and format, giving 100% coverage. The tool description does not elaborate further on parameters, but since the schema is explicit, the baseline of 3 is appropriate; no additional semantic clarification is needed.

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

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

The description clearly states the tool's function: 'Look up all DNS records for a domain in one query.' It specifies the resource (domain), the action (look up), and the full scope of record types returned, distinguishing it from sibling tools that handle specific record types like cname_lookup or mx_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 when to use the tool: when you need multiple record types at once ('all DNS records in one query'). It does not explicitly name alternatives, but the list of sibling tools and the explicit enumeration of record types make the usage context clear, though it lacks direct exclusions or alternative references.

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

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

Annotations already indicate this is a read-only, non-destructive, idempotent, and open-world operation. The description adds value by specifying that it involves connection and authentication attempts, which provides context beyond the annotations. However, it doesn't detail potential outcomes like success/failure states or error handling, leaving some behavioral aspects unclear.

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 front-loaded with the core purpose in the first sentence and adds a usage guideline in the second, with zero wasted words. Both sentences earn their place by clarifying the tool's function and context efficiently.

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 (5 required parameters) and rich annotations covering safety and behavior, the description is mostly complete. It lacks an output schema, so it doesn't explain return values, but the purpose and usage are clear. A minor gap exists in not detailing potential results or errors, but annotations provide sufficient context for a testing 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%, with each parameter well-documented in the input schema (e.g., hostname examples, port ranges, encryption options). The description does not add any parameter-specific information beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without compensating further.

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

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

The description clearly states the specific action ('Test an IMAP server connection by attempting to connect and authenticate') and the resource ('IMAP server'), distinguishing it from sibling tools like 'imap_finder' which likely discovers servers rather than testing connections. The phrase 'verify email receiving configuration' further clarifies the use case.

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 this tool ('to verify email receiving configuration'), but does not explicitly mention when not to use it or name alternatives. For example, it doesn't contrast with 'smtp_check' for sending configuration or 'imap_finder' for server discovery, though the purpose is distinct enough to imply 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?

Annotations already cover read-only and idempotent behavior. The description adds value by specifying the output fields (host, port, encryption) and confirming it's a lookup operation. No contradiction with annotations.

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

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

Two concise, front-loaded sentences accomplish both purpose and usage guidance. No wasted words.

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

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

For a simple read-only lookup with one parameter and no output schema, the description covers the key aspects: what it does, what data it returns, and when to use it. It doesn't mention error handling or unknown providers, but that's not critical for this simple tool.

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

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

Schema coverage is 100% as the parameter description explicitly documents the provider name and examples. The description adds no additional meaning beyond what the schema already states, 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 uses a specific verb ('look up') and resource ('IMAP server settings'), clearly stating what the tool does. It doesn't explicitly name sibling tools like imap_check, but the focus on configuration settings rather than connectivity testing distinguishes it implicitly.

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 usage context with 'Use this to find the correct IMAP configuration' and provides example providers. It does not mention when NOT to use it or name alternatives, so it falls short of 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds behavioral context by specifying the return value (mail servers and priorities), which is useful for the agent. It does not contradict annotations and adds meaningful details beyond 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 extremely concise, only two sentences. It front-loads the action ('Look up') and efficiently states the resource and return value. Every word earns its place, with no fluff or repetition.

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

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

The tool is simple with one parameter and no output schema. The description fully covers what the tool does and what it returns, which is sufficient for an agent to invoke it correctly. Given the simplicity and availability of annotations, no additional detail is needed.

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 the domain_name parameter with an example. The description does not add any additional parameter semantics beyond what the schema provides, 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 'Look up' with a clear resource 'MX (Mail Exchanger) records' and a target 'for a domain'. It distinguishes itself from sibling tools like cname_lookup and dns_lookup by explicitly naming the record type, and adds the return value (mail servers and priorities).

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 context is clear: this tool is for looking up MX records, so an agent can infer when to use it. However, it does not explicitly mention alternatives or exclusions, such as 'for general DNS lookups use dns_lookup'. The clarity of purpose makes it obvious, but explicit guidance is absent.

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, covering safety and idempotency. The description adds domain context (email reputation) but no additional behavioral traits such as rate limits or error conditions. With annotations present, 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 three sentences, each adding value: it names the operation, defines the result, and gives practical context. No fluff or repetition.

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

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

For a simple one-parameter lookup tool with strong annotations and no output schema, the description sufficiently explains purpose and context. The email reputation note provides meaningful situational guidance, making 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?

The single parameter ip_address is fully documented in the schema with an example ('8.8.8.8 or 142.250.80.46'). The description does not add further parameter-level detail, but schema coverage is 100%, 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 clearly states 'Reverse DNS lookup' and specifies the action 'Find the hostname associated with an IP address'. This distinguishes it from sibling tools like dns_lookup or cname_lookup by emphasizing the inverse mapping from IP to hostname.

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

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

The description gives a clear context for use: 'A valid PTR record is important for email sending reputation'. This implies when to use it (e.g., email deliverability checks) but does not explicitly mention alternatives or when not to use it, so it falls short of 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?

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds valuable behavioral context beyond annotations by specifying that it 'attempts to connect and authenticate' and 'optionally sends a test email to verify full sending capability', which clarifies the tool's operational behavior and optional destructive action (sending email).

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 that are front-loaded with the core purpose and efficiently convey optional extended functionality. Zero wasted words - every phrase earns its place by adding distinct value about the tool's behavior.

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 connectivity testing tool with comprehensive annotations and full schema coverage, the description provides adequate context. It clarifies the two-phase nature (connection/auth test plus optional email sending) which isn't captured in structured fields. The main gap is lack of output format information (no output schema), but the description compensates reasonably given the tool's straightforward purpose.

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

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

Schema description coverage is 100%, so the schema fully documents all 7 parameters. The description mentions 'optionally sends a test email' which hints at the optional 'from_email' and 'to_email' parameters, but adds minimal semantic value beyond what's already in the schema descriptions. Baseline 3 is appropriate given complete 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's purpose with specific verbs ('test', 'connect', 'authenticate', 'sends') and resource ('SMTP server connection'). It distinguishes from sibling tools by focusing on SMTP connectivity testing rather than DNS lookups, BIMI checks, or other email-related diagnostics.

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 ('test an SMTP server connection') but doesn't explicitly state when to use this versus alternatives like 'smtp_finder' or 'imap_check'. No guidance on prerequisites or exclusions is provided, leaving the agent to infer appropriate scenarios.

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 agent knows it is a safe read operation. The description adds that it returns host, port, and encryption, but does not disclose additional behaviors such as network dependency or error handling. No contradiction with annotations.

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

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

Two sentences, front-loaded with the action, and includes all necessary information without fluff. Every sentence earns its place.

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

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

The tool is simple with one parameter and no output schema, yet the description still mentions the expected return fields (host, port, encryption). It provides a clear scope for supported providers. Minor omissions like unsupported providers or error cases are acceptable given the 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 schema description covers provider_name with examples (gmail, sendgrid, etc.), and the description reinforces this with examples like Gmail, Outlook, and SendGrid. No new meaning is added beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description uses the specific verb 'look up' and identifies the resource as 'SMTP server settings (host, port, encryption)' for an email provider. It then gives examples (Gmail, Outlook, SendGrid) and differentiates from sibling tools like smtp_check (which tests) and imap_finder (which finds IMAP settings).

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

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

Explicitly states 'Use this to find the correct SMTP configuration' and provides examples of providers, giving clear context for when to use the tool. However, it does not mention when not to use it or alternatives such as smtp_check for testing SMTP connectivity.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds a definition of SPF and the concept of 'valid', but does not disclose what happens when no SPF record exists, the return format, or any operational behavior like rate limits.

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

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

The description is exceptionally concise: two sentences that front-load the action and resource, followed by a brief definition of SPF. Every word 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?

Given the tool's simplicity and the rich annotations, the description is adequate but not complete. It lacks differentiation from sibling DNS tools and does not explain what 'valid' means in terms of return values or edge cases (e.g., no SPF record). For an agent selecting among many similar tools, this is a notable gap.

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

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

The input schema fully documents the single domain_name parameter with an example, achieving 100% schema description coverage. The description itself adds no further parameter semantics, so the baseline 3 applies.

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

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

The description clearly states the tool checks if a domain has a valid SPF DNS record, using the specific verb 'Check' and a distinct resource (SPF). It is implicitly distinguished from sibling tools by focusing solely on SPF, but does not explicitly name alternatives.

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 other DNS checks like dkim_check or dmarc_check. The description lacks any context, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name.

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

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

Annotations provide idempotency and non-destructiveness, and the description adds that the tool returns the record name, value, and type ready for DNS, which is useful given no output schema. It does not detail behavior for unsupported providers or external dependencies, but the openWorldHint annotation already suggests reliance on provider data.

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

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

Two sentences with no fluff; the main action and output are stated first, making the description immediately understandable.

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 core purpose, the basis for generation (provider), and the output format, which is essential since there is no output schema. It lacks explicit error conditions for unknown providers, but the parameter descriptions cover the inputs adequately for a simple generator.

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 contains 100% parameter descriptions, so the baseline is 3. The description adds no additional parameter semantics beyond restating the provider-based logic, and the schema already defines domain and hard_fail_boolean clearly.

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 'Generate' with a clear resource ('SPF DNS record') and scope ('based on the email provider being used'), distinguishing it from sibling check tools like spf_check and from dmarc_generate by naming the record type explicitly.

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

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

The description clearly indicates when to use the tool ('based on the email provider being used') and what it produces. However, it does not explicitly mention alternative tools or exclusions, such as 'use dmarc_generate for DMARC records,' so it falls short of full usage 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?

The annotations already declare readOnlyHint=true and idempotentHint=true, indicating a safe, non-destructive operation. The description adds that it returns 'all' TXT records for a domain, which is useful scoping, but does not disclose network behavior or response details. 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 two concise sentences. The first states the action, the second provides valuable context on TXT record uses, making it informative without waste.

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 DNS lookup with a single parameter, the description fully conveys the operation. The absence of an output schema means the return format need not be detailed, and annotations cover safety.

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 domain_name parameter with a clear example. The description adds no additional parameter semantics beyond 'a domain'.

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

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

The description states a specific action ('Look up all TXT records for a domain') and clarifies the content of TXT records, distinguishing it from sibling record-type-specific tools like cname_lookup or mx_lookup and from general 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 does not explicitly provide usage guidance or name alternatives. It implies this tool is for obtaining raw TXT records, but does not explain when to choose it over spf_check or dkim_check, which also deal with TXT record content.

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