EmailMCP

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

No annotations are present, so the description carries the burden. It discloses concrete behaviors: generates DKIM keys and returns the 4 DNS records the customer must add. It does not mention side effects, failure modes, or prerequisites, but for a simple add operation 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 three short sentences, front-loaded with the core purpose. Every sentence contributes meaningful context, 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?

For a tool with one parameter, no output schema, and no annotations, the description covers purpose, behavior, and output (DNS records). It could mention prerequisites (e.g., domain uniqueness) or verification steps, but overall it is adequately complete for such a simple operation.

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 fully describes the parameter 'domain' with an example (100% coverage). The description adds no additional parameter semantics beyond that, so the baseline score of 3 applies.

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

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

The description starts with a clear verb 'Add' and resource 'customer sending domain', making the action unambiguous. It also mentions generating DKIM keys and returning DNS records, which distinguishes it from siblings like list_sending_domains or remove_sending_domain.

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 adding sending domains, but does not explicitly state when to use this tool vs alternatives or when not to use it. The 'self-hosted' comparison to SendGrid provides some context but no clear exclusion or alternative 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 must fully disclose side effects and behavior. It states a check and possible setup guidance, but it is unclear whether 'guide setup' involves performing mutations or just providing instructions. This ambiguity is problematic for an agent that needs to know if the tool could change state.

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

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

The description is a single, efficient sentence that quickly conveys the tool's purpose. However, it crams two actions ('check' and 'guide setup') into one sentence without clear structure, making it slightly less clear than a two-sentence version would be.

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 no parameters and no output schema, but the description still leaves important gaps: it does not explain what 'configured' means, what the return value looks like, or what 'guide setup' entails. Given the lack of annotations and output schema, the agent would be under-informed about the expected 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 has zero parameters, and the description correctly aligns with that. Per the baseline for zero-parameter tools, a score of 4 is appropriate because no parameter explanation 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 uses a specific verb 'Check' with a clear resource 'email providers' and a clear outcome ('if configured'). It also mentions a secondary action 'guide setup if needed'. However, it does not explicitly distinguish itself from the sibling tool 'test_email_config', which likely has a similar purpose, so it loses a point for lack of 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?

There is no guidance on when to use this tool versus alternatives. The description implies a context of verifying email configuration but never mentions 'test_email_config' or other related tools, leaving the agent without clear selection criteria. No exclusions or alternative mentions are 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 full burden of behavioral disclosure. It indicates the tool handles 'pending' requests, suggesting read-only behavior, but it does not disclose whether repeated calls are safe, what happens for non-pending requests, or any side effects. The description is minimal and leaves significant behavioral 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, clear sentence with no unnecessary words. It is front-loaded with the action and resource, making it easy to scan and understand instantly.

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 clear schema, the description is adequate but not complete. It omits guidance on what the response looks like (no output schema) and does not distinguish itself from provision_status, which could confuse an agent selecting between similar tools.

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

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

Schema coverage is 100%, and the parameter description for request_id already explains its origin and the 'saved request' fallback. The tool description adds no parameter-specific meaning beyond this, 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 ('Check') and resource ('status of a pending WireGuard IP provisioning request'), which clearly defines the tool's purpose. It distinguishes itself from sibling tools like check_email_config or get_health_status by focusing on WireGuard IP provisioning.

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 used after requesting an IP (via request_email_ip), but it does not explicitly state when to use this tool over alternatives like provision_status. There is no mention of exclusions or alternative choices, so the guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden of disclosing side effects. 'Step-by-step guidance' suggests an interactive or instructional flow, but it doesn't state whether the tool actually sends API calls, modifies configuration, or only returns instructions. No info about authentication, reversibility, or what happens on failure.

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 without fluff. It is front-loaded with the core purpose. However, it could be slightly more informative without becoming verbose, so it earns a 4 rather than 5.

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 configuration tool with no annotations and no output schema, the description is too minimal. It doesn't explain what 'step-by-step guidance' entails, whether it's a wizard, what the expected outcome is, or how it interacts with other email setup tools. Key context is missing.

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

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

Schema description coverage is 100% for all three parameters (api_key, domain, from_email), each with clear examples. The description adds no additional parameter context 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 verb 'Configure' and resource 'Mailgun email provider', making the basic purpose understandable. However, it does not distinguish this from sibling tools like set_personal_email_credentials or verify_email_setup, so it doesn't fully differentiate.

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 doesn't mention prerequisites (e.g., domain verification), whether it's for initial setup, or how it relates to sibling tools like add_sending_domain or verify_email_setup. No exclusions or contextual recommendations.

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 highlights a critical trait: 'Returns SMTP password once — save it,' which is non-obvious and essential for the agent. It also states the account can send/receive via this server, implying successful setup. However, it omits potential side effects like domain verification requirements or conflict behavior if the address already exists, so it is not fully comprehensive.

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 verb, and every sentence earns its place. The critical 'save it' instruction and the usage capability are both included without any fluff. No redundant or irrelevant information is present.

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

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

For a tool with no output schema and no annotations, the description covers the essential outcome: it returns the SMTP password exactly once. It also indicates the account is operational for sending/receiving. However, it does not mention upstream requirements such as domain verification or what happens if the address already exists, which could be relevant for an agent to use the tool correctly. Still, it provides a clear and sufficient overview for basic use.

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

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

The input schema has 100% description coverage for all parameters (address, domain, display_name), so the schema already explains their meanings. The description adds no parameter-specific details beyond what the schema provides. Baseline of 3 is appropriate since the schema does the heavy lifting and the description does not conflict or add extra semantics.

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

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

The description clearly states a specific action: 'Create an email account with SMTP credentials.' It specifies the resource (email account) and distinguishes it from siblings like create_mailbox by emphasizing SMTP functionality. The added detail that the account can send/receive via the server further clarifies the tool's unique role.

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

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

The description provides no guidance on when to use this tool versus alternatives such as create_mailbox or configure_mailgun. It does not mention exclusions, prerequisites, or when not to use it. The only implied usage is that the account is for sending/receiving, but no explicit comparison or rationale is given.

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 exist, so the description carries full behavioral burden. It discloses that actions trigger on matching emails and lists action types, but omits important behavior like rule evaluation order, priority handling, stop semantics, or side effects of actions (e.g., sending auto-replies). The schema includes priority and stop, but the description does not add context beyond the basic trigger condition.

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, compact sentence that conveys the core purpose and enumerates the supported action types. No unnecessary words, and it is front-loaded with the primary action.

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?

Though the tool has nested objects and six parameters, the schema descriptions are comprehensive (100% coverage), so the description does not need to explain each parameter. It provides the core purpose and action types, which is sufficient for an agent to select this tool. No output schema exists, but for a creation operation the return value is not critical.

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

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

Schema coverage is 100% with thorough parameter descriptions, so baseline is 3. The description adds only a list of action types, which already appears in the schema enum. It provides no extra semantic meaning for parameters beyond what the schema already documents.

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 'Create a rule that triggers actions when incoming emails match conditions,' with a specific verb and resource. It distinguishes from sibling tools like update_email_rule and delete_email_rule by focusing on creation, and lists the action types (forward, auto_reply, etc.) which further clarifies its 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 gives clear context that this tool is for creating new email rules, implied by the verb 'Create.' However, it does not explicitly contrast with update_email_rule or list_email_rules, nor does it provide when-not or alternative guidance. This is clear context without 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 that each address gets its own inbox accessible via MCP tools, which is useful behavioral context. However, it doesn't explain what 'autonomous mode' entails, potential side effects (e.g., duplicate addresses), or required permissions, 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?

The description is two sentences, front-loaded with the core action, and contains no redundant information. It is concise while providing essential details about purpose and outcome.

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 create tool with 2 parameters and no output schema, the description conveys the purpose and result (each address gets its own inbox). It doesn't explain return values or error handling, but given the tool's simplicity, the current coverage is mostly sufficient. A slightly higher score is prevented by the lack of any mention of what happens after creation or prerequisites.

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?

Input schema coverage is 100% (both 'address' and 'display_name' have descriptions). The description adds no extra parameter meaning beyond the schema, so a baseline score of 3 is appropriate given the schema already documents the parameters.

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

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

The description clearly states the action ('Create') and the resource ('a new local mailbox for receiving email'), specifying 'autonomous mode' which distinguishes it from sibling tools like create_email_account. It also adds that each address gets its own inbox, further clarifying the tool's specific 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 provides clear context for when to use the tool—creating a local mailbox for receiving email in autonomous mode—and implies its scope (local mailboxes vs. other email creations). It doesn't explicitly name alternatives or exclusions, but the context is sufficient for basic usage differentiation.

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

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

The description discloses a meaningful side effect (revoking SMTP credentials) beyond the tool name, which is helpful given no annotations exist. However, it omits other important behavioral traits like permanence, required permissions, or effects on associated mailboxes/email rules.

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, front-loaded sentence with no superfluous words. Every element contributes to understanding the tool's action and immediate consequence.

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

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

For a simple tool with one parameter and no output schema, the description covers the core action and a key side effect, making it mostly complete. It lacks usage guidance and broader context, which prevents a higher score.

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 describes the single 'address' parameter with 100% coverage, so the description adds no additional parameter meaning. This aligns with the baseline of 3 when the schema does the heavy lifting.

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

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

The description uses a specific verb and resource ('Delete an email account') and adds the key scope 'revoke its SMTP credentials,' which clearly distinguishes it from sibling tools like delete_mailbox and delete_email_rule.

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 such as delete_mailbox or reset_account_password. The description implies a delete operation but gives no exclusions, prerequisites, or context for choosing this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action 'delete' without revealing whether deletion is irreversible, requires permissions, or has cascading effects on related resources like email accounts or forwarding rules.

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

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

The description is one short, front-loaded sentence that directly states the verb and resource, with no redundant or extraneous content.

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

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

The tool is simple with a single parameter and no output schema, so the description covers the basic operation. However, missing annotations and behavioral context (e.g., irreversibility) leave some gaps for a mutation tool, making it only minimally complete.

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

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

The schema already provides 100% coverage with a description 'Rule ID to delete' for rule_id. The description merely restates that deletion is by ID, adding no new meaning beyond confirming the parameter's role.

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 'Delete an email rule by ID' clearly states the action (delete) and resource (email rule) with the identifier method (by ID), distinguishing it from sibling tools like create_email_rule and update_email_rule.

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, such as update_email_rule or list_email_rules. There is no mention of prerequisites, deletions being permanent, or any exclusion criteria.

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 does disclose a key side effect: deleting all stored emails. However, it does not mention irreversibility, required permissions, or what 'autonomous mode' entails. This is partial transparency, but a critical detail (permanent data loss) is implied rather than explicitly stated.

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 action and object. Every word earns its place — no fluff or redundancy.

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

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

For a destructive one-parameter tool with no output schema and no annotations, the description is adequate but lacks context around 'autonomous mode' and any prerequisites or post-conditions. It fully explains the primary effect but leaves ambiguity about what makes this mailbox 'local' and whether the deletion is reversible.

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

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

Schema coverage is 100% — the only parameter 'address' is described in the schema. The description adds the qualifier 'local mailbox' but does not provide extra semantic value beyond the schema field description. 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 ('Delete') and a clear resource ('local mailbox') plus what is included ('all its stored emails'). It distinguishes itself from siblings like delete_email_account by specifying 'local' and 'autonomous mode', making the tool's purpose unambiguous.

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

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

There is no guidance on when to use this tool versus the many sibling deletion tools (e.g., delete_email_account, delete_email_rule). The phrase 'autonomous mode' hints at a specific context but is not explained, and no alternatives or 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. The description only says 'get full conversation context' without explaining what 'full' means, how maxEmails affects results, or any other behavioral details like read-only nature, pagination, or return format. This is insufficient given the lack of annotation support.

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, direct sentence with no unnecessary words. It is front-loaded and concise, making it easy to parse quickly.

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

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

For a simple tool with two parameters and no output schema, the description provides the core purpose but lacks crucial context such as what the response contains, how maxEmails influences results, or any prerequisites. It is minimally viable but 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?

The schema already describes both parameters (threadId and maxEmails) with clear descriptions, so schema coverage is 100%. The tool description does not add any additional meaning or clarify the parameters further, thus 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 action ('Get') and the resource ('full conversation context for a specific thread'). It is specific about the scope, distinguishing it from sibling tools like get_conversation_threads which likely list threads rather than retrieve a single thread's full 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 implies usage when you need conversation context for a particular thread, but provides no explicit guidance on when to use this tool versus alternatives like get_threads_for_sender or read_inbox. No exclusions or alternative mentions are present.

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 of behavioral disclosure. It says 'Get' which implies read-only, but it does not explain what is returned (e.g., whether forwarding emails are included in the thread), pagination, authentication requirements, or any side effects. The minimal detail provides little 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, front-loaded sentence that clearly identifies the primary action and resource. Every word earns its place with no filler or redundancy.

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

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

Given no output schema and no annotations, the description is too thin to be complete. It does not clarify the meaning of 'with forwarded emails', nor does it differentiate from related siblings like get_forwarded_emails. The agent would need to guess at the tool's exact behavior and return format.

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

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

All four parameters (limit, since, subject, participant) have descriptions in the schema, achieving 100% coverage. The tool description adds no parameter-specific 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 'Get conversation threads with forwarded emails' clearly states the operation (get) and resource (conversation threads), though 'with forwarded emails' is slightly ambiguous. It does not distinguish from sibling tools like get_threads_for_sender or get_conversation_context, so it falls short of a 5.

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. The description does not mention any context, exclusions, or differentiators, leaving the agent to infer usage from the name alone.

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 bears the burden of disclosing behavior. It states that the tool 'Outputs copyable records for your DNS provider,' which explains what the tool produces and that it's a generation action rather than a mutation. It does not mention side effects or prerequisites, but for a generator tool the behavior 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 two sentences long, front-loaded with the primary action, and contains no filler. Every word adds value, specifying the exact record types and the output format.

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

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

For a generation tool with 5 parameters and no output schema, the description explains the purpose, output format (copyable records), and the context (autonomous email). It does not detail the exact output structure, but that is not necessary for understanding the tool's core function. The absence of an output schema is mitigated by the clear statement about copyable DNS records.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description does not add parameter-specific meaning beyond what the schema provides, which meets the baseline of 3 for high coverage.

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

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

The description clearly states the tool's function: 'Generate all required DNS records (A, MX, SPF, DKIM, DMARC) for autonomous email.' It uses a specific verb (generate) and resource (DNS records), which distinguishes it from sibling tools like get_domain_dns_records that likely retrieve existing 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?

The phrase 'for autonomous email' provides clear context on when to use this tool. It implies this should be used when setting up or configuring DNS for an autonomous email domain. While it doesn't explicitly exclude alternatives or name them, the context is specific enough for an agent to select it over retrieval 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 provided, the description carries full responsibility for behavioral disclosure. It indicates a read operation through 'Get,' but does not state that the operation is non-destructive, whether it requires any prerequisites, or what the response contains. This is a minimal disclosure for a read-only 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 a single, front-loaded sentence that conveys the tool's core purpose without unnecessary words. Every word earns its place, and there is no repetition of schema or annotation content.

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

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

The tool is simple with one parameter, so the description is moderately complete. However, since there is no output schema, the description should explain what kind of DNS records are returned (e.g., MX, SPF, DKIM) or how many records to expect. It does not, leaving a gap for an agent trying to use the returned data.

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 for the single domain parameter, so the baseline is 3. The description adds little beyond the schema, merely framing the domain as a sending domain, which matches the parameter's purpose but does not clarify format, validation rules, or edge cases.

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 ('Get') and a clear resource ('DNS records') with a qualifier ('for a sending domain'). This distinguishes it from the sibling tool get_dns_records, which lacks the sending-domain scope, and aligns with adjacent setup tools like add_sending_domain.

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 'a customer needs to add' implies this is used during sending-domain setup, but the description does not explicitly state when to use it versus alternatives like get_dns_records or start_domain_verification. No exclusions or alternative recommendations are 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 provided, the description carries the full burden of behavioral disclosure. It adds meaningful context by mentioning the 'verification window' and the fact that it bypasses the forward_to mailbox, which implies a targeted, read-oriented behavior. However, it does not explicitly state that the operation is read-only, what data it returns, or any side effects.

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 that is front-loaded with the core action and includes a helpful example. Every word earns its place, and there is no redundant or filler content.

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

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

This is a simple, single-parameter tool with no output schema. The description explains what the tool does, the scope, and even a practical use case. It could be more explicit about the returned email content or count, but for the tool's complexity it is sufficiently complete for an agent to select and invoke it correctly.

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

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

The schema has one parameter 'domain' with 100% coverage, describing it as 'Domain to filter on'. The description reinforces this by saying 'for a given domain' and gives a concrete example, but does not add substantial new meaning beyond the schema. Baseline 3 applies because the schema already documents the parameter adequately.

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

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

The description uses a specific verb ('List') and clearly defines the resource ('mails received in the verification window') and scope ('for a given domain'). The example about Apple's verification code makes the purpose immediately understandable and distinguishes it from sibling tools like get_domain_verification_status and read_inbox.

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 retrieve verification emails for a domain, specifically to find codes without checking the forward_to mailbox. It provides a clear use case and an implicit alternative (checking the forward_to mailbox), though it does not explicitly name sibling tools or state when not to use it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. Although it does not explicitly state 'read-only', the verb 'Show' clearly implies a non-mutating status check. The description adds transparency by listing the specific output components (active verification windows, receiver state, TTLs), giving the agent a clear picture of what to expect.

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, front-loaded sentence with no filler. Every word contributes meaning: 'Show' identifies the action, and the three listed items specify the data returned. It is optimally 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 zero-parameter status tool, the description sufficiently explains what the tool does and what it returns. No output schema or annotations exist, so the description must stand alone, and it does. However, it could be more complete by mentioning the relationship to verification workflow (e.g., 'use after start_domain_verification'), but this is not essential given the low 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 tool has zero parameters, so the baseline is 4. There is no parameter information needed, and the description does not attempt to describe any parameters. The schema already covers 100% of the (empty) parameter set.

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 'Show' and identifies the exact resource (domain verification status) along with the specific information returned (active verification windows, receiver state, TTLs). This clearly distinguishes it from sibling tools like start_domain_verification or get_domain_verification_emails, 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?

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, such as needing to start verification first, or exclusions. The description simply states what it does without contextualizing its place among the sibling 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 provided, the description carries the full burden of behavioral disclosure. It states 'Reads from persistent stats,' which is a useful attribution indicating a read-only, historical data operation. However, it does not delve into potential data delays, granularity of the per-domain breakdown, or any constraints around the filters, so some opacity remains.

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 resource, then immediately enumerates the key output categories. It is concise, front-loaded, and every word earns its place.

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

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

Given the tool's simplicity and the absence of an output schema, the description lists the main return facets (delivery rate, bounce rate, per-domain breakdown, top bounce reasons) which gives a reasonable picture. It does not explain the optional parameters' interplay, but the schema covers those. Overall, it is sufficiently complete for an agent to understand what the tool offers.

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 parameter descriptions for domain, period, and account already providing meaning. The tool description adds no additional parameter-specific detail beyond what the schema states, 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 the specific verb 'Get' with a clear resource ('email usage statistics') and details the specific metrics returned (delivery rate, bounce rate, per-domain breakdown, top bounce reasons). This clearly distinguishes it from siblings like get_suppression_list or get_mailbox_status.

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 through its enumeration of statistics, so an agent knows it addresses email delivery/bounce analytics. However, it does not explicitly state when to use this tool over alternatives nor mention any exclusions or when-not-to-use scenarios, leaving the guidance implicit rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not explain return format, pagination, sorting, authentication needs, or any side effects. The word 'Retrieve' implies a read operation, but this is not explicitly stated beyond the action itself.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the primary action and mentions filtering in a compact way, though it is terse and lacks detail.

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

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

For a tool with no output schema and no annotations, the description is too sparse. It does not explain what constitutes a 'forwarded email', what the response looks like, or how filtering behaves. Given the tool's moderate complexity (4 optional parameters), more context 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 baseline is 3. The description adds minimal value by noting 'optional filtering', but does not elaborate on how the parameters interact or provide examples. It relies entirely on the schema for parameter meaning.

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

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

The description states a specific action ('Retrieve forwarded emails') and mentions optional filtering, which is clear. However, it does not distinguish this tool from sibling tools like read_inbox or get_threads_for_sender, leaving some ambiguity about when to use it.

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

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

There is no guidance on when to use this tool versus alternatives. The description only says 'Retrieve forwarded emails with optional filtering' and does not mention exclusions, prerequisites, or specific use cases.

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 relies on the verb 'Get' to imply a read-only operation, which is acceptable but not explicit. It does not disclose any potential side effects, latency, or what a 'current health status' concretely returns (e.g., JSON with pass/fail flags). The listed checks provide some context but lack behavioral depth.

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 verb and object, then specifies the scope with a dash. Every word adds value, with no filler or redundancy.

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

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

For a simple zero-parameter tool with no output schema, the description provides sufficient context by naming the four health areas it covers. However, it stops short of indicating the response format or how to interpret the status, which would make it more complete for an agent.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. The description does not need to add parameter semantics, and the schema already confirms no arguments are required.

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 ('Get') and resource ('current health status of the email server'), and clearly enumerates the checked components (tunnel, SMTP, DNS, IP blocklist). This distinguishes it from sibling tools like get_idle_status or get_mailbox_status, which target narrower aspects.

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

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

The description implies this is the tool for overall health checks by listing components, but it does not explicitly state when to prefer it over alternatives like get_smtp_receiver_status or check_ip_status. There is no mention of exclusions or when not to use it.

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

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

There are no annotations, so the description carries full weight. It discloses the specific status data returned (accounts watched, connection status, email counts), which is useful. However, it does not mention whether a watch must be active, how connection status is represented, or that the operation is read-only, though 'Get' implies non-mutating behavior.

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

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

A single, front-loaded sentence states the verb and resource first, then enumerates the key returned data. No filler or repetition.

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

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

Without an output schema, the description adequately outlines return values (watched accounts, connection status, email counts). It could be more exhaustive about error conditions or empty states, but for a no-parameter status endpoint it provides the essential information.

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 schema coverage is trivially 100%. According to the rubric, a baseline of 4 applies, and the description correctly omits parameter details since none exist.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource as 'status of IMAP IDLE watchers', listing concrete output types (accounts being watched, connection status, new email counts). This distinguishes it from sibling status tools like get_health_status or get_smtp_receiver_status.

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?

While no explicit alternatives are mentioned, the description's focus on IMAP IDLE watchers gives clear usage context: use it to monitor active IDLE watching sessions. It does not exclude related tools, but the resource specificity makes the intended use 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?

With no annotations, the description must carry the transparency burden. It discloses the credential dependency (IMAP configured in .env) but doesn't explain what 'status information' includes, whether the call is read-only, makes network requests, or what response to expect. This leaves significant behavioral 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?

Two sentences, front-loaded with the primary action and followed by a credential/account tip. Every word earns its place with no redundant content.

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

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

Without an output schema, the description should explain what status data is returned, but it remains silent. The nested imap_config object and optional parameters are only partially contextualized, leaving the tool under-specified for an agent to predict its behavior and output.

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

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

The schema already covers account and mailbox details, and the description adds the nuance that credentials are unnecessary if IMAP is pre-configured in .env, which clarifies the role of imap_config. However, it doesn't elaborate on mailbox options or the imap_config object beyond the schema, so the added value is modest.

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-resource pair ('Get status information for an email mailbox') that clearly distinguishes it from siblings like read_inbox or list_mailboxes by focusing on 'status'. However, it doesn't explicitly differentiate from other status tools (e.g., get_health_status) and 'status information' is somewhat vague.

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

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

It provides clear context on credential handling: if IMAP is configured in .env, no credentials are needed, and it instructs to use the 'account' parameter to select a named account. It doesn't explicitly mention when to use this over alternatives, but the situational guidance is direct.

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 responsibility for behavioral disclosure. It states 'Get the current status' which implies a read-only operation, but it does not mention potential outcomes (e.g., whether the receiver must be started), the nature of the status values, or any side effects. This is a minimal disclosure that leaves important operational details unspecified.

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 that is front-loaded with the main action and target. It contains no filler, fluff, or redundant information, making it highly concise 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?

Given the tool has no parameters, no output schema, and no annotations, the description is somewhat thin. It explains the basic function but omits context such as what the returned status represents, whether the receiver must be active to get a meaningful response, or how this relates to the lifecycle tools (start_smtp_receiver/stop_smtp_receiver). For a zero-parameter read tool, this may be adequate, but it leaves the agent without a full picture of expected results.

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

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

The tool has zero parameters, and the schema coverage is effectively 100% (an empty object). The baseline for parameter semantics is 4 when there are no parameters, as the description need not add parameter details. The description adds nothing about parameters but is not required to.

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 'Get the current status of the SMTP forward receiver' clearly identifies the action (get) and the target resource (SMTP forward receiver status). It distinguishes itself from sibling tools like start_smtp_receiver and stop_smtp_receiver by focusing on status retrieval, making the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_health_status or get_mailbox_status. While the purpose is clear, there is no explicit context about prerequisites, typical scenarios, or exclusions, leaving the agent to infer usage from the name alone.

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 burden of behavioral disclosure. It explicitly states 'these addresses will be rejected on send', which reveals the practical impact of the suppression list and implies a read-only operation (via 'View'). It does not describe pagination or output format, but for a simple list tool this is adequate.

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

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

The description is a single sentence that promptly leads with the verb 'View' and states the resource. It includes only necessary information — the list's purpose and consequence — with no fluff or repetition of the tool name.

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 parameters, no output schema), the description provides sufficient contextual information: what the list contains, that it causes send rejection, and implicitly that it is read-only. This fully equips an agent to understand when and why to use 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?

The tool has zero parameters, and the schema is empty. Per the rubric, a baseline of 4 is appropriate when there are no parameters, so the description does not need to explain parameter details.

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

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

The description clearly states the tool's function: 'View all addresses on the bounce suppression list' — a specific verb ('View') plus a specific resource (suppression list). It also differentiates from sibling tools like remove_from_suppression and validate_email by focusing on viewing rather than modifying or validating.

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 see suppressed addresses before sending), but it does not explicitly mention alternatives or exclusions. It provides useful context that rejected-on-send behavior, but no direct 'use this instead of X' 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 full burden. It discloses the scope ('all conversation threads involving a specific sender'), which is useful, but it does not mention return format, whether threads are sent, received, or both, or any pagination behavior. This is minimally viable 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, front-loaded sentence with no redundant words. It effectively communicates the tool's core function in under ten words, earning the highest score for conciseness.

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

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

For a simple single-parameter read tool with no output schema, this description adequately covers the main purpose and parameter. It lacks usage guidance and output details, but given the low complexity, it is reasonably complete. Slightly more detail about return value or sender matching would push it to 5.

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 only parameter, senderAddress, with a clear description. The tool description adds no extra semantic value beyond restating the parameter's purpose. Since schema coverage is 100%, 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 'Get' with a clear resource 'all conversation threads' and adds a precise qualifier 'involving a specific sender.' This distinguishes it from sibling tools like get_conversation_threads, which likely lists threads without the sender filter. The purpose is immediately 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 the tool is for retrieving threads when you care about a specific sender, but it does not explicitly state when to choose this over get_conversation_threads or get_conversation_context, nor does it mention any exclusions. This is adequate but lacks explicit alternative 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?

With no annotations provided, the description carries the full transparency burden. It communicates that the operation is a read-only listing and specifies the returned attributes, which covers the main behavioral expectations. It does not mention pagination or data freshness, but for a zero-parameter list tool, this is not a significant gap.

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

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

The description is a single sentence that is front-loaded with the primary action ('List supported cloud providers') and avoids any filler. Every word adds value, making it appropriately 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?

Given the tool's simplicity (no parameters, no output schema, no annotations), the description is complete. It fully specifies what the tool returns—cloud providers along with pricing, regions, and PTR support info—without requiring 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 no parameters, so the description earns a baseline score of 4. The description adds no parameter details, but none are needed; the schema is already complete for an empty parameter set.

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 supported cloud providers and enumerates the specific information included (pricing, regions, PTR support). This verb+resource combination unambiguously distinguishes it from all email-related sibling tools, none of which involve cloud providers.

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 'supported cloud providers' provides clear context that this tool is used to discover available providers and their attributes. While it does not explicitly mention alternatives, the tool is unique among siblings, so no exclusions are needed; the intended use case is evident.

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 burden. The verb 'list' implies a read-only operation, and 'configured' scopes the behavior, but no explicit safety guarantees or caveats (e.g., whether accounts are sorted, whether it includes disabled accounts) are disclosed.

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

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

Two short sentences, front-loaded with the main purpose and a secondary detail. No unnecessary words, ideal for an agent scanning for tool relevance.

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

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

The description is adequate for a zero-param list operation, but the presence of nearly identical siblings like 'list_email_accounts_managed' means the description could be more explicit about what is included (e.g., all accounts vs managed) and what the return shape looks like, since there is no output schema.

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

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

The tool has zero parameters, so the input schema is exhaustive. Baseline for 0 params is 4; the description adds no parameter-specific info because none 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 verb ('List') and resource ('configured IMAP email accounts'), making the primary purpose explicit. However, it doesn't explicitly differentiate from the sibling tool 'list_email_accounts_managed', although the qualifier 'configured' provides a subtle distinction.

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 given on when to choose this tool over alternatives like 'list_email_accounts_managed' or 'list_mailboxes'. The description simply states what it does without placement in the broader toolset.

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 of behavioral disclosure. It does not state that the operation is read-only, whether it returns actual credentials or just indicates their presence, or any potential side effects or limitations. Exposing SMTP credentials is a sensitive behavior that is not addressed.

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 is front-loaded with the action and resource. It contains no unnecessary words or repetition, 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?

While the tool is simple with one optional parameter and no output schema, the description lacks essential context about return values and what 'managed' means relative to the sibling list_email_accounts. It does not specify whether it returns full credentials or just account metadata, leaving a completeness 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 schema already provides 100% coverage for the sole parameter 'domain' with a clear description ('Filter by domain'). The tool description merely restates this ('optionally filtered by domain') without adding extra meaning, so the baseline of 3 applies.

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

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

The description clearly states the tool lists all email accounts with SMTP credentials, which is a specific verb+resource+scope. It inherently distinguishes itself from the sibling list_email_accounts by adding the qualifier 'with SMTP credentials', giving it a clear 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 implies when to use the tool (when you need email accounts with SMTP credentials or filtered by domain) but does not explicitly mention alternatives or exclusions. The sibling list_email_accounts exists but no guidance is given on which to choose, so usage is only implied.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns all rules with specific fields, implying a read-only operation. For a parameterless list tool, this is adequate, and it adds value beyond the name by detailing the returned 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?

The description is a single sentence that is front-loaded with the action and resource. It provides no unnecessary details and every word earns its place.

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

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

For a parameterless list tool with no output schema, the description is complete. It states the scope ('all email rules') and the returned fields (match conditions, actions, hit counts), giving an agent sufficient information 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?

There are no parameters in the schema, so the description does not need to explain them. The baseline of 4 for zero parameters applies, and the description appropriately focuses on output rather than input.

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 email rules and specifies the included fields (match conditions, actions, hit counts). This distinguishes it from sibling tools like create_email_rule or delete_email_rule, which perform different verbs on the same resource.

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 retrieving email rules but does not explicitly compare it to alternatives or provide exclusion criteria. The context is clear from the verb 'list' and the resource, so usage is implied rather than explicitly stated.

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 of behavioral disclosure. It states the operation (list) but does not disclose any side effects, permissions required, or whether it is a safe read operation. The phrase 'autonomous mode' is unexplained, and no information about return behavior is given.

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 verb and resource. It contains no filler or redundant information, earning high marks for efficiency.

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

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

For a zero-parameter list tool, the description is minimal but adequate. However, it does not describe the return format or clarify what 'local' and 'autonomous mode' mean in practice. Given the lack of an output schema and annotations, some additional context about expected results would improve completeness.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The description adds context by specifying 'all local mailboxes' and 'autonomous mode', which clarifies the scope of the operation. Baseline for zero parameters is 4.

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

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

The description uses a specific verb 'List' and resource 'local mailboxes', with scope 'on this server' and mode 'autonomous mode'. It clearly states what the tool does. However, it does not explicitly differentiate from the sibling tool 'list_mailboxes', leaving potential ambiguity about the distinction between local and non-local mailboxes.

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 such as 'list_mailboxes' or 'list_email_accounts'. There is no mention of prerequisites or contexts where this tool is preferred, leaving the agent to infer 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. It discloses the .env credential shortcut but does not mention the imap_config parameter, what happens if either method fails, or what the return format is. Some context is provided but key behavioral details are missing.

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

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

Two concise sentences that front-load the purpose and add the key credential context. No filler, every word earns its place.

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

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

The tool has a nested object parameter and no output schema, yet the description does not explain what the returned mailboxes look like or how imap_config is used. It also doesn't clarify the relationship between account and imap_config, leaving significant gaps for a 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?

Schema description coverage is only 50%. The description mentions the 'account' parameter but completely ignores 'imap_config', which is a nested object with a password field. This leaves half the parameters unexplained beyond the raw schema, and the description does not compensate.

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 lists all available mailboxes for an email account, using a specific verb and resource. It doesn't explicitly distinguish from sibling 'list_local_mailboxes', but the IMAP mention suggests remote mailboxes, so it's mostly 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?

It provides useful context about .env IMAP configuration and using the 'account' parameter. However, it does not explicitly say when to use this tool instead of alternatives like list_local_mailboxes or list_email_accounts, and no exclusions are given.

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 implies a read-only operation via 'List', which is non-destructive and safe, and mentions the output includes verification status. However, it does not disclose potential pagination, ordering, default limits, or any required permissions. Adequate for a simple list 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, concise sentence with no wasted words. It is front-loaded with the action ('List') and includes the most relevant detail (verification status) with maximum efficiency.

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

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

For a tool with no parameters, no annotations, and no output schema, the description adequately conveys the tool's purpose and the nature of its return (domains plus verification status). It could mention whether the list is paginated or filtered, 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, and the schema is empty, so the description does not need to explain parameters. Baseline for 0 params is 4; the description adds no param information, which is appropriate since none exist.

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

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

The description 'List all configured sending domains with their verification status' uses a specific verb ('List'), a clear resource ('configured sending domains'), and adds the key detail of including verification status. This cleanly distinguishes it from sibling tools like list_email_accounts or get_domain_verification_status.

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 states only what the tool does, with no guidance on when to use it compared to alternatives such as get_domain_verification_status or list_email_accounts. There is no mention of prerequisites, exclusions, or preferred scenarios, so the usage context is entirely implicit 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?

With no annotations, the description carries the burden. It discloses a key behavioral trait: automatically detecting the current phase and advancing through the provisioning sequence. However, it does not cover potential side effects, idempotency, failure handling, or what happens if the phase is already complete, which is a gap for a state-advancing 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 two sentences, front-loaded with the purpose and behavior, followed by targeted usage guidance. 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?

For a tool with no parameters and no output schema, the description covers the essential workflow, the advancement sequence, and the trigger condition. It could optionally mention the outcome of a successful run, but the current content is adequate for the tool's 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 tool has zero parameters, so the baseline is 4. The description correctly adds context about when to use it (after user actions) without needing to explain parameters. It does not introduce any parameter-related ambiguity.

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: 'Resume provisioning from where you left off' and describes the specific behaviors of detecting the current phase and advancing through WireGuard → DNS → TLS → verification. This distinguishes it from siblings like provision_start and provision_status by implying continuation rather than initiation or status checking.

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

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

The description gives explicit usage guidance: 'Run this after each user action (connecting WireGuard, adding DNS records).' This tells the agent when to invoke the tool. It does not explicitly name alternative tools for exclusions, but the context is clear enough for a resume operation.

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 discloses the main actions (create VPS, generate WireGuard config, return connection details) but omits important side effects such as cloud charges, irreversibility, and whether existing resources are affected. This is a notable gap for a resource-creating 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 extremely concise and front-loaded with 'Phase 1', immediately conveying its purpose. Each sentence provides distinct value: creation, config generation, output, and provider support. 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 multi-provider provisioning tool with no output schema and no annotations, the description covers the essential actions but lacks operational context such as expected duration, idempotency, failure behavior, and cost implications. This is a moderate gap given the complexity and potential side effects of the operation.

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

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

The input schema has 100% description coverage, so the baseline is 3. The description adds the list of supported providers, which aligns with the enum but adds no new semantics beyond what the schema already provides. It does not elaborate on region or service_domain, so it does not elevate the score above baseline.

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

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

The description clearly states the tool's function with specific action verbs: 'Create a cloud VPS', 'Generates WireGuard config', and 'Returns the IP and instructions to connect'. It is distinguished from siblings like provision_resume and provision_status by explicitly labeling itself 'Phase 1', indicating it is the initial step in the provisioning workflow.

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 'Phase 1' provides clear contextual guidance that this is the first step in a multi-phase process, implying use before provision_resume or provision_status. It also lists supported cloud providers, suggesting the user must choose one. However, it does not explicitly mention alternatives or exclusions (e.g., when to use provision_resume instead), so it falls short of full 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?

With no annotations provided, the description must carry the burden of disclosing behavioral traits. 'Show' suggests a read-only operation, but the description does not explicitly confirm it has no side effects. It does add useful context about the content of the status (phases, next steps), but stops short of a full disclosure of safety or side-effect profile.

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, front-loaded sentence that immediately states the tool's purpose. The em dash adds detail without bloat, and every word earns its place. There is no extraneous information.

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

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

For a simple status tool with no parameters and no output schema, the description is complete enough to convey what the tool does and what information it returns. It could have noted that it is safe to call at any time or should be used after provision_start, but this is not essential for basic understanding.

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 input schema is fully covered by default. The description introduces no parameter-specific semantics, and the baseline for a zero-parameter tool is 4, which is appropriate here.

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

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

The description uses a specific verb ('Show') and a clear resource ('current provisioning state'), and adds what it reports ('which phases are complete, what to do next'). This distinguishes it from sibling tools like provision_start and provision_resume, which are mutating operations.

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

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

The description clearly implies it is for checking the status of provisioning, especially after starting or resuming. It offers context for when to use it ('which phases are complete, what to do next') but does not explicitly mention alternatives or state when not to use it, such as saying 'use provision_start to initiate provisioning'.

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 must carry the burden. It only covers basic purpose and auth configuration, but omits side effects (e.g., mark_as_read), return format, error handling, or network behavior. The schema mentions options like mark_as_read, but the description does not clarify the default behavior or consequences of using 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 three short sentences, front-loaded with the primary purpose. Every sentence adds useful context about credentials or account selection, with no fluff or 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 tool is complex (4 params with nested objects), has no output schema, and no annotations. The description fails to explain return values, default behaviors (e.g., mark_as_read defaults to false), or error conditions. An agent would lack critical information about what to expect after invoking 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?

With 50% schema description coverage, the description should compensate for undocumented top-level parameters (filter, options). It only mentions 'account' and .env fallback, which are already in the schema's property descriptions. The phrase 'with filtering options' is vague and adds no specifics about how to use filter or options objects.

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 'Read emails from an inbox via IMAP with filtering options,' clearly identifying the action (read), resource (emails from an inbox), and method (IMAP). This distinguishes it from sibling tools like send_email, create_email_rule, or check_email_config.

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 useful context: 'If IMAP is configured in .env, no credentials needed' and 'Use "account" to pick a named account (work, personal, etc.).' It gives clear operational guidance, though it does not explicitly mention when not to use this tool or name alternatives as in some other tools.

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

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

No annotations are provided, so the description carries the full burden. It implies a destructive overwrite ('regenerate the complete zone file') but does not disclose side effects, prerequisites, propagation delays, or reversibility. For a mutation tool, this is a significant transparency gap.

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

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

The description is two sentences, front-loaded with the core function and followed by a practical usage trigger. Every word earns its place with no redundancy.

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

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

For a zero-parameter tool, the description gives enough to select and invoke it: what it does and when to use it. However, the lack of any note about output, side effects, or success/failure indicators reduces completeness for a regeneration action.

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

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

The tool has zero parameters, so there are no parameter semantics to clarify. The schema is empty, and the description appropriately focuses on the action. Baseline of 4 applies for a no-parameter tool.

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

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

The description clearly states the tool regenerates the complete DNS zone file for the service domain including all customer subdomains. The specific verb 'Regenerate' and resource 'DNS zone file' differentiate it from read-only DNS tools like get_dns_records and get_domain_dns_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?

The description explicitly provides a usage trigger: 'Use after adding/removing domains.' This gives clear context for when to invoke the tool, though it does not mention alternatives or exclusions, which would merit 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?

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states the effect (removes suppression, allows sending again) but omits details like permissions, reversibility, or side effects beyond bounce suppression.

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

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

A single sentence that front-loads the action and purpose, containing no filler or redundant information.

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

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

For a simple one-parameter tool with full schema coverage and no output schema, the description communicates the essential purpose and effect. It could mention return behavior or idempotency, but the core context is 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 fully covers the only parameter with 'Email address to unblock', and the description adds no additional semantic detail beyond what the schema already provides, 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 'Remove' with a clear resource 'address from the bounce suppression list' and adds a manual override context, clearly distinguishing it from siblings like 'remove_sending_domain' and 'get_suppression_list'.

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

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

The phrase 'manual override to allow sending again' implies the primary use case—re-enabling sending to a previously suppressed address. It offers clear context but does not explicitly name alternatives 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?

The description adds a key behavioral trait: it also removes DKIM keys. However, with no annotations provided, it does not disclose whether the removal is irreversible, requires special permissions, or impacts other associated data. It gives some useful context but does not fully cover the destructive nature.

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 immediately conveys the operation and the side effect. 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?

Given the low complexity (one parameter, no output schema), the description is largely complete. It covers the primary action and a key side effect, but the lack of any cautionary language about irrevocability 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?

The single parameter 'domain' is fully described in the schema with 100% coverage. The description does not add additional semantic detail beyond what the schema provides, so it is at the baseline for schema-covered parameters.

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

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

The description clearly states the verb ('Remove') and the resource ('a sending domain'), and explicitly notes that it also removes DKIM keys. This distinguishes it from siblings like add_sending_domain and list_sending_domains.

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

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

The description clearly indicates this tool is for removing a sending domain, which provides clear context. It does not explicitly mention when not to use it or name alternatives, but the purpose is unambiguous given the operation and sibling 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?

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It discloses that the request is asynchronous ('Submits to the provisioning queue'), which is useful. However, it does not mention potential side effects, required permissions, idempotency, or what the response contains. For a mutation-like operation, this is a moderate gap.

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

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

The description is exceptionally concise and front-loaded. It uses two short sentences to convey the core action and the queue behavior. There is no filler or redundant detail, earning a top score.

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 (2 parameters, no nested objects, no output schema), and the description covers the primary action. However, because there is no output schema, the description should ideally indicate what the caller receives after submitting (e.g., a request ID or status) and how to follow up. The mention of the provisioning queue hints at next steps but does not explicitly guide the agent on subsequent status checking, leaving some ambiguity.

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 descriptions for both parameters with 100% coverage, so the baseline is 3. The tool description adds no additional parameter semantics beyond what the schema provides. It does not explain how email_domain or account_id are used in the request, but this is not required 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 a specific action: 'Request a dedicated WireGuard IP for email sending.' It identifies the resource (dedicated WireGuard IP), the purpose (email sending), and the mechanism (submits to provisioning queue). This distinguishes it from sibling tools like provision_start or check_ip_status, which either manage provisioning generally or check IP status.

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 ('Request a dedicated WireGuard IP for email sending') and mentions the provisioning queue, but it does not explicitly state when to use this tool versus alternatives such as provision_start, provision_status, or check_ip_status. No exclusions or alternative tool references are provided, so the agent must infer when this tool is appropriate.

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

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

No annotations are present, so the description carries the full burden. It does disclose a key behavioral trait: 'Returns new password once,' which is valuable because the new password cannot be retrieved later. However, it does not mention whether the old password is immediately invalidated, if there are impacts on existing sessions, or any authentication requirements.

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-loaded with the action, and contains no filler. Every word contributes to understanding the tool's purpose and key return 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 simple one-parameter tool, the description covers the core action and the return value. However, it lacks usage guidance and explicit side-effect warnings (e.g., irreversible password change, inability to see the password again), which would be expected given the lack of annotations.

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

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

The input schema fully covers the address parameter with its description, and the schema description coverage is 100%. The tool description adds minimal context by clarifying that the password being reset is the SMTP password, but it does not add format, syntax, or usage 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 uses a specific verb-resource pair: 'Reset the SMTP password for an email account.' This clearly distinguishes it from sibling tools like create_email_account or set_personal_email_credentials, which have different functions.

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. For instance, there is no mention of when reset_account_password is preferred over set_personal_email_credentials, and no caveats or prerequisites are given.

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 only states that it sends an email, without disclosing side effects like provider selection, personal account behavior, or delivery limitations. Since no annotations are provided, the description fails to reveal behavioral details, though some are covered in parameter descriptions.

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 communicates the basic function without extra words. However, it omits useful context about the tool's capabilities, making it efficient but under-informative.

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 10 parameters, no output schema, and no annotations, the description provides only a minimal overview. The schema's parameter descriptions compensate for some missing context, but the description itself does not cover behavioral or usage aspects, leaving the agent with an incomplete picture.

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% parameter description coverage, including detailed explanations for 'from', 'bulk_mode', and 'attachments'. The description itself adds no parameter semantics, but per baseline, high schema coverage earns a 3.

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 verb 'send' and resource 'email', and specifies content types 'text or HTML'. It distinguishes from siblings like send_template_email by its content-type emphasis, though not explicitly naming 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 send_template_email or other email tools. The description lacks any context about use cases, 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 no annotations provided, the description carries full burden for behavioral disclosure. It only restates the action ('send an email using a predefined template') without detailing side effects, requirements, rate limits, or that this actually sends emails (non-reversible). No additional behavioral context is given beyond the tool name.

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 is front-loaded and contains no wasted words. It efficiently conveys the core purpose without redundancy or extraneous detail.

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

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

Although the schema is rich and covers parameters well, the tool is complex (6 params, nested objects, enums) and is a sending operation with potential side effects. The description provides no information about return values, safety, or when to use this tool among many email-related siblings, making it incomplete for confident invocation based on description alone.

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 already well-documented (e.g., bulk_mode explains options, provider lists examples). The tool description adds no extra parameter context, so the baseline score of 3 applies: the schema does the heavy lifting.

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

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

The description states 'Send an email using a predefined template', which clearly identifies the verb (send), resource (email), and scope (using a template). This distinguishes it from the sibling 'send_email' tool by emphasizing the template-based nature, even though it does not explicitly name the alternative.

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

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

The description implies usage for cases where a predefined template exists, but it does not provide explicit guidance on when to choose this over 'send_email' or other email tools, nor does it mention any exclusions or prerequisites. The usage context is merely implicit.

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 responsibility. It goes beyond the schema by explaining the side effect on send_email (SMTP sending and IMAP-APPEND to Sent folder) and discloses AES-256-GCM encryption at rest with EMAILMCP_SECRET. This is detailed behavioral 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 sentences, front-loaded with the action and resource, and every clause adds value (purpose, services, effect, encryption). 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?

The description covers the core behavior and security, and the schema fully documents all parameters. It lacks explicit mention of prerequisites like account creation (though schema says 'must already exist') and behavior on overwrite, but given no output schema, return values are not needed. Overall adequate for a 10-param 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 baseline is 3. The description adds context like service examples and the encryption aspect, but individual parameter descriptions in the schema already provide examples and defaults. The description does not add substantial new meaning for specific parameters beyond what the schema includes.

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 attaches SMTP + IMAP credentials to an existing account, with a specific verb 'attach' and resource 'credentials to an existing account'. It distinguishes from siblings like create_email_account by emphasizing the existing account and personal services (iCloud, Gmail, Fastmail, Office365).

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

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

The description implies when to use it: for personal accounts with existing credentials, and notes the effect on send_email. It does not explicitly exclude alternatives or name sibling tools, but the context 'to an existing account' clarifies that the account must already exist, which is sufficient 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 description discloses key behaviors: 'Generates DKIM keys, creates DNS records, and outputs everything needed.' However, it does not disclose potential side effects such as overwriting existing DNS records, permission requirements, or reversibility. With no annotations provided, the description carries the full burden, and while it covers main actions, it omits 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 two concise sentences, front-loaded with the main purpose: 'Auto-configure DKIM, SPF, and DMARC for autonomous email.' The second sentence adds concrete actions without redundancy, earning its place. No filler or repetition.

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

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

For a complex setup tool with no output schema and no annotations, the description gives a good high-level overview but lacks details about the output format ('outputs everything needed' is vague), potential side effects (e.g., whether DNS records are automatically added to the zone), and how it fits with sibling tools like verify_autonomous_setup. The description is adequate but 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 description coverage is 100%, so the input schema already documents all four parameters (domain, ipv4, dmarc_policy, dkim_selector). The description does not add any parameter-specific meaning beyond what the schema provides. Per the rubric, baseline is 3 for high schema coverage, and this description neither improves nor undermines parameter understanding.

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: 'Auto-configure DKIM, SPF, and DMARC for autonomous email.' It uses a specific verb ('auto-configure') and identifies the resource (email authentication protocols). It distinguishes from siblings like verify_autonomous_setup (verification vs. setup) and add_sending_domain (domain addition vs. authentication setup).

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 initial setup of email authentication, but does not explicitly state when to use it vs. alternatives, nor does it mention exclusions or prerequisites. There is no reference to sister tools like verify_autonomous_setup, which would clarify the setup-verify workflow. Thus, usage guidance is implied but not explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It transparently explains temporary MX redirection, starting or reusing the SMTP receiver, forwarding of all inbound mail, and automatic teardown after ttl_minutes. This is unusually complete for a state-changing tool, covering the main side effects and safety-relevant behavior.

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 entire operation—MX change, receiver behavior, forwarding, and teardown—is conveyed in a single dense sentence with no filler. It is front-loaded with the verb and resource, and every clause adds necessary detail.

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

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

For a multi-step state-changing tool with no output schema or annotations, this description covers the main workflow, prerequisites (via the schema), and teardown behavior. It could mention expected return values or failure modes, but the combination of tool description and rich schema descriptions is nearly complete for the tool's 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%, so the baseline is 3. The description adds workflow-level meaning by explaining that domain and forward_to work together to relay *@domain mail, and connects ttl_minutes to auto-teardown. real_mx_target is not repeated in the description but is fully described in the schema, so the added context beyond the schema justifies a 4.

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 ('Begin a domain-verification window') and details the exact mechanism: set MX to verify.setip.io, start/reuse the SMTP receiver on :25, and forward inbound mail to forward_to. This clearly distinguishes it from siblings like start_smtp_receiver (which only starts a receiver) and stop_domain_verification.

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 use case (obtaining email verification codes from providers) and mentions auto-teardown, but it does not explicitly state when not to use the tool or name sibling alternatives. The prerequisite that the domain must be a POC owned in setipio-api appears only in the parameter schema, not in the tool description. Clear context but no exclusions makes this a 4.

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

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

With no annotations, the description carries the full burden. It adds useful behavioral details (frequency, specific checks, auto-restart), but leaves gaps: what 'auto-restarts' means exactly, whether the monitor can be stopped, and what side effects it may have. It does not contradict any annotations since none are provided.

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 action and packs in specifics (checks, frequency, auto-restart). Every clause 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 0-param tool with no output schema, the description covers the main behavior but omits practical context: what the tool returns, how to stop the monitor, and any prerequisites like the server already being provisioned. It is adequate but leaves the user/agent to infer these details.

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

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

The tool has zero parameters, and the schema coverage is trivially 100%. The baseline for 0 params is 4, and the description adds no irrelevant parameter information, so it deserves the baseline.

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

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

The description states a specific verb ('Start'), a resource ('the provisioned email server'), and the exact scope of monitoring ('checks tunnel, SMTP, DNS, and IP reputation'). This clearly distinguishes it from sibling tools like get_health_status (a one-time check) or start_idle_watch (a different monitoring target).

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 continuous monitoring ('every 60 seconds', 'auto-restarts on failure') but does not explicitly state when to use this tool versus alternatives or mention any exclusions. Unlike the high-quality example, it names no alternative tools or when-not-to-use conditions.

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 that the tool performs real-time IMAP IDLE watching and triggers push notifications, which is a key behavior. However, it omits details such as whether the watch is persistent, how notifications are delivered, prerequisites (e.g., account configuration), or how to stop the watch, which are expected for a start-type 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 two sentences long, front-loads the core action and purpose, and adds useful compatibility info without redundancy. Every word contributes value, making it highly 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?

The tool has one optional parameter, no output schema, and no annotations. The description explains the action, its purpose, and compatible providers, which is sufficient for a simple start command. However, it could be more complete by specifying how push notifications are delivered (e.g., webhook) and any prerequisites, making 4 rather than 5.

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

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

Schema coverage is 100%, and the parameter 'account' is already described with examples and default behavior ('Omit to watch all configured accounts'). The description adds general context about email accounts but does not provide additional semantic detail beyond the schema, 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 clearly states the tool starts real-time IMAP IDLE watching on email accounts, with the specific outcome of push notifications for new emails. It distinguishes itself from sibling tools like stop_idle_watch and get_idle_status by focusing on the start action and its real-time 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 the tool should be used when the user wants push notifications for new emails, and mentions compatibility with Gmail, iCloud, Office365, etc. However, it does not explicitly contrast with alternatives like read_inbox or start_smtp_receiver, nor does it state when not to use it.

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

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

With no annotations provided, the description must disclose behavioral traits, yet it only states the high-level action. It does not mention whether the server runs in the background, whether it blocks execution, what happens on subsequent calls, or any side effects. The description is too terse to provide meaningful transparency beyond the obvious mutation implied by 'start'.

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 immediately states the action and purpose. It is perfectly front-loaded, containing no filler, irrelevant details, or repetition. Every word earns its place, making this an exemplary model of conciseness.

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

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

The tool has no output schema and no annotations, so the description must explain behavior and expected results. It does not mention return values, whether the server persists across requests, or the implications of optional parameters like port or receivingDomains. The description is a bare minimum and leaves critical behavioral questions unanswered for a tool that starts a long-running server.

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 all four parameters with clear descriptions, achieving 100% coverage. The tool description adds no parameter-specific meaning, relying entirely on the schema. Baseline of 3 is appropriate because the schema does the heavy lifting and the description offers no additional clarification or context.

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

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

The description clearly states a specific action ('Start') and a specific resource ('SMTP server'), along with the purpose ('to receive forwarded corporate emails'). This distinguishes it from sibling tools like stop_smtp_receiver and get_smtp_receiver_status, making the tool's function unmistakable.

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, exclusions, or contrast with related tools such as stop_smtp_receiver or get_smtp_receiver_status. A user must infer the appropriate context from the tool name alone.

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 the main behaviors: restoring MX via snapshot or real_mx_target, removing the forwarder, and conditionally stopping the receiver. It omits permission/error details but is reasonably transparent for the tool's complexity.

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-loaded with the main action, and every phrase adds value. It avoids fluff and is very 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?

Given the tool's moderate complexity and lack of output schema, the description covers the core behavior, parameter implications, and a side effect. It is sufficiently complete for an agent to understand when and how to invoke it, though it could mention what the tool returns or prerequisites.

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

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

Schema coverage is 100% and both parameters have descriptive definitions. The description adds slight reinforcement (e.g., 'supplied real_mx_target' referencing the override) but does not go beyond what the schema already provides, 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's purpose with a specific verb ('tear down') and resource ('domain-verification window'), and details the key actions (restore MX, remove forwarder). This distinguishes it from sibling tools like start_domain_verification and get_domain_verification_status.

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 (to tear down an active verification window) and includes a conditional note about stopping the receiver when no other windows remain. However, it does not explicitly mention alternatives or exclusions, though the sibling context makes it 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?

No annotations are provided, so the description carries full responsibility for disclosing behavior. It states the action and scope but omits side effects, idempotency, prerequisites, or behavior when no watch is active. For a state-changing tool, this is a notable gap.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the operation and parameter scope.

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 this simple tool with one optional parameter and no output schema, the description covers the essential operation. It lacks behavioral details like idempotency or error conditions, but given the simplicity, the description is 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?

The schema already provides a description for the account parameter (100% coverage), so the tool description adds no new semantics. The phrase '(or all accounts)' restates what the schema already says, yielding no additional value.

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

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

The description clearly states the specific action (Stop), the resource (IMAP IDLE watching), and the scope (account or all accounts). This distinguishes it from sibling tools like start_idle_watch and get_idle_status.

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 as the counterpart to start_idle_watch and provides scoping guidance via the optional account parameter. It does not explicitly mention exclusions or alternative tools, but the context is clear enough for correct invocation.

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

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

No annotations are provided, so the description carries the full burden. It merely restates the tool name and adds 'forward receiver server', but does not disclose side effects (e.g., dropped connections, queued emails), reversibility, or whether it is destructive. This is minimal behavioral disclosure.

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

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

The description is a single sentence with no filler words. It is front-loaded with the action verb and clearly states the target. Every word earns its place.

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

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

Given the simplicity (0 params, no output schema), the core purpose is clear. However, without annotations, the description lacks context about the operational impact of stopping the server (e.g., whether it can be restarted, whether it affects forwarded emails). It is minimally adequate but incomplete.

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 baseline is 4. The description correctly avoids inventing parameter details and adds no unnecessary semantics.

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

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

The description clearly states a specific action ('Stop') on a specific resource ('the SMTP forward receiver server'). It distinguishes from siblings like start_smtp_receiver and get_smtp_receiver_status by being the inverse operation.

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

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

The usage is implied by the verb 'Stop'—use it when you want to shut down the receiver. However, there is no explicit guidance on prerequisites (e.g., server must be running) or when not to use it, and no mention of alternative 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 burden. It does disclose the key side effect (sending a test email), but it does not explain potential side effects, failure modes, or what happens after the email is sent. The return value and error behavior are unaddressed, so transparency is moderate.

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

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

A single, compact sentence that front-loads the purpose and method. Every word earns its place, with no redundant 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?

The tool is simple (one optional parameter, no output schema), but the description does not explain what the tool returns or how success/failure is indicated. This absence is notable since no output schema exists, leaving the agent without guidance on interpreting results.

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 the 'test_email' parameter fully described in the schema. The tool description adds no additional parameter semantics, but since the schema already covers the parameter, the baseline 3 is appropriate.

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

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

The description uses the specific verb 'Test' with the resource 'email configuration' and clarifies the method ('by sending a test email'). This clearly distinguishes it from siblings like check_email_config (which might not send) or send_email (which sends real emails).

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. The description only states the action, and no exclusions or alternative tools are mentioned, leaving the agent without context on when to select this over check_email_config or send_email.

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 must disclose side effects. It only says 'update' which implies mutation but does not clarify whether unspecified fields are preserved or reset when only some parameters are passed, nor explain return values or error behavior. This is a significant gap for a mutation 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?

A single, front-loaded sentence that communicates purpose and scope efficiently without wasteful words. It even uses parentheses to enumerate key options.

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

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

For a tool with 6 optional parameters, nested objects, and no output schema, the description is too terse. It fails to explain partial update semantics, behavior on invalid rule_id, or what the API returns. Given the complexity and lack of annotation support, this is incomplete.

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 covers 100% of parameters, so baseline is 3. The description adds a concise overview of which parameters are involved ('match/actions/priority') but does not add syntax, validation rules, or interactions beyond what the schema already states.

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

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

The description clearly states the verb 'Update' and the resource 'existing email rule', then enumerates the changeable aspects: 'enable/disable, change match/actions/priority'. This distinguishes it from sibling tools like create_email_rule and delete_email_rule.

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 'existing email rule' implies this is for modifying already-created rules, distinguishing it from create/delete alternatives. It provides clear context but does not explicitly state when not to use it or name alternatives.

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 but only says 'validate' and 'check deliverability'. It does not disclose that this may involve network calls, MX/SMTP checks, potential side effects, rate limits, or what the return value contains. The behavior is largely opaque.

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, front-loaded with the verb 'Validate'. It has zero waste and every word contributes to conveying the core purpose. This is appropriately sized for a simple tool.

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

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

The tool has no output schema and no annotations. The description only states the basic action, omitting return format, behavioral nuances, and usage context. Given the complexity of email validation (MX/SMTP checks, deliverability semantics), the description is not complete enough for an agent to fully understand the tool's 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?

Schema description coverage is 100%, so the baseline is 3. The description itself adds no extra parameter meaning beyond the schema's existing descriptions of 'emails', 'check_mx', and 'check_smtp'. No interpretation or additional context is given.

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 validates email addresses and checks deliverability, which is a specific verb and resource. It does not explicitly distinguish from sibling tools like check_email_config or test_email_config, but the focus on email addresses rather than configuration makes it clear enough.

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. There is no mention of prerequisites, exclusions, or preferred scenarios, leaving the agent to infer usage from the name and schema alone.

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 lists what is checked but does not disclose side effects (e.g., read-only), required credentials, or how results are returned (e.g., success/failure details). This leaves significant behavioral gaps for a verification 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 a single, focused sentence that front-loads the action ('Verify') and efficiently lists verification targets. No filler or redundant 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?

With no output schema or annotations, the description should explain return behavior and any prerequisites. It only states the scope of verification, not what the user receives (e.g., a report, pass/fail) or how to interpret results. This is a notable gap for a tool with one parameter and no other structured metadata.

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 the 'domain' parameter already described. The description does not add any extra semantics 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 a specific verb ('Verify') and a specific resource ('autonomous email') with explicit components (DNS records, DKIM, SMTP send/receive). This differentiates it from general email tools, though siblings like verify_email_setup and check_email_config are similar without explicit contrasts.

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 on when to use this tool vs. alternatives. It does not mention prerequisites, exclusions, or situations where another sibling would be more appropriate.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action without revealing side effects, return format, or whether test emails are actually sent. The optional test_email parameter suggests delivery attempts may occur, but this is not disclosed.

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

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

The description is a single concise sentence that is easy to parse and front-loads the core purpose. It avoids unnecessary words, though it could be slightly more detailed without becoming 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?

Given no output schema, no annotations, and a moderately complex verification task, the description is incomplete. It does not explain what constitutes 'verification', what outputs to expect, or how the parameters interact, leaving significant gaps for an agent to select and 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?

Schema description coverage is 100%, so each parameter is already well-documented. The tool description adds slight context by mention IP whitelisting and provider configuration, but does not deepen understanding of parameter semantics beyond the schema.

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

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

The description clearly states the tool verifies IP whitelisting and email provider configuration, using the specific verb 'verify' and a defined resource. It distinguishes from generic checks like 'check_email_config' by narrowing scope to IP whitelisting and provider setup, but does not explicitly differentiate from similar sibling tools.

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

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

No guidance is provided on when to use this tool versus alternatives such as check_email_config or test_email_config. The description does not mention prerequisites, use cases, or exclusions, leaving the agent to infer the appropriate context.

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